diff --git a/.gitignore b/.gitignore
index e72561ed..0edf023e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,9 +6,21 @@ ext/fox16_c/*_wrap.cpp
 ext/fox16_c/*.o
 ext/fox16_c/conftest.dSYM
 ext/fox16_c/include/inlinestubs.h
+ext/fox16_c/extconf.h
 ext/fox16_c/swigruby.h
 ext/fox16_c/fox16.bundle
 ext/fox16_c/mkmf.log
 lib/fox16/kwargs.rb
+lib/[0-9].[0-9]
+lib/*.so
 fox-includes/diffs.py
 fox-includes/diffs.txt
+pkg
+tmp
+vendor
+*.orig
+*.rej
+/Gemfile.lock
+/ports
+/.bundle
+/.yardoc
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 00000000..43985e88
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,34 @@
+dist: xenial
+language: ruby
+
+addons:
+  apt:
+    packages:
+    - xpra
+    - xserver-xorg-video-dummy
+    - g++
+    - libxrandr-dev
+    - libfox-1.6-dev
+    - libfxscintilla-dev
+    - swig
+
+install:
+  - swig -version
+  - ls -l /usr/lib/libfxscintilla*
+  - bundle install
+
+before_script:
+  - "xpra --xvfb=\"Xorg +extension GLX -config `pwd`/test/dummy.xorg.conf -logfile ${HOME}/.xpra/xorg.log\"  start :9"
+
+script: bundle exec rake test DISPLAY=:9
+
+after_failure:
+  - "cat ~/.xpra/*"
+
+after_script:
+  - "xpra stop :9"
+
+rvm:
+  - "ruby-head"
+  - "2.6.0"
+  - "2.2"
diff --git a/Gemfile b/Gemfile
new file mode 100644
index 00000000..3528541c
--- /dev/null
+++ b/Gemfile
@@ -0,0 +1,22 @@
+source 'https://rubygems.org'
+
+# Specify your gem's runtime dependencies in fxruby.gemspec
+gemspec
+
+# For some reason this is required in addition to the gemspec
+# when 'bundle config force_ruby_platform true' is active:
+gem 'mini_portile2'
+
+group :development do
+  gem 'rake-compiler', '~> 1.0'
+  gem 'rake-compiler-dock', '~> 1.0'
+  gem 'yard', '~> 0.8'
+  gem "bundler", ">= 1.12", "< 3.a"
+  gem "rake", "~> 13.0"
+end
+
+group :test do
+  gem 'opengl', '~> 0.8'
+  gem 'glu', '~> 8.0'
+  gem 'test-unit', '~> 3.1'
+end
diff --git a/History.md b/History.md
new file mode 100755
index 00000000..8dd56b16
--- /dev/null
+++ b/History.md
@@ -0,0 +1,1456 @@
+## 1.6.42 / 2020-02-01
+
+* Fix a packing issue in 1.6.41: `lib/fox16/input.rb` had owner permission only.
+
+## 1.6.41 / 2020-01-26
+
+* Add support for Ruby-2.7
+* Fix build error on FreeBSD. #51
+* Fix handling of scroll events to FXText instance.
+* Add 8 virtual methods of FXText to be passed through ruby.
+* FXText#findText: Return multi entry array only when searching Regex.
+* Fix several example apps in example/ dir.
+* Update to rake-compiler-dock-1.0 and use parallel cross build.
+* Update to libpng-1.6.37, jpeg-turbo-2.0.4, libtiff-4.1.0 on Windows binary gem.
+
+## 1.6.40 / 2018-12-28
+
+* Fix some library classes which failed, when Fox was not included into the global namespace.
+* Add new accessor FXImage#dataPtr to access raw image data from FFI, Fiddle or OpenGL.
+* Ensure zero terminated strings in values of C-argv.
+* Remove various Ruby and C++ warnings.
+* Update libfox to 1.6.57.
+* Add support for RubyInstaller-2.6
+* Set minimum required ruby version to 2.2.
+
+## 1.6.39 / 2017-12-26
+
+* Fix FXGLVisual.supported and .supported?
+* Add support for RubyInstaller-2.5
+
+## 1.6.38 / 2017-07-27
+
+* Update dependent libraries for Windows binary gem.
+* Replace libjpeg-9b by libjpeg-turbo-1.5.2 on Windows binary gem.
+* Fix build with clang on FreeBSD (and possibly other OS). Fixes #41
+
+## 1.6.37 / 2017-06-24
+
+* Add a 3rd type of FXRbObjects which is used for callbacks. Fixes #39
+
+## 1.6.36 / 2017-06-04
+
+* Support the fxruby source gem on Windows (only RubyInstaller-2.4).
+* Replace our self-made directory search methods by pgk-config.
+* Enable the use of Win32 unicode functions. Fixes #30 and #38
+* Fix segfault in vsprintf on Windows 10.
+* Update support for RubyInstaller-2.4.1-1
+* Update to libjpeg-9b
+* More automation for gem releases
+
+## 1.6.35 / 2017-02-15
+
+* Adjust for Ruby-2.4 with unified Integers
+* Add support for RubyInstaller-2.4
+* Drop support for Ruby-1.8 and 1.9. It may work with them, but is no longer tested.
+* Add compat with SWIG-3.0
+* Fix an issue with FXApp#removeInput introduced in fxruby-1.6.30.
+* Work around missing /usr/lib/libfxscintilla.so file in Ubuntu
+* Update dependent gems.
+* Update libraries for Windows build.
+
+## 1.6.34 / 2016-04-26
+
+* Add support for RubyInstaller-2.3
+* Avoid RARRAY_PTR() which broke fxruby on ruby-2.3.0.
+* Make use of StringValueCStr() where it is suitable.
+* Fix initialisation of runOnUiThread event handler, when FXApp is called with a block.
+* Disable GVL on RubyInstaller-1.9.3. Fixes #24
+
+## 1.6.33 / 2015-08-20
+
+* Avoid rb_* calls that are prohibited during GC. Fixes #23
+* Use copy'ing getters for FXVec members in FXMat*, FXMaterial and FXLight.
+  This fixes the TC_FXMaterial#test_bug test case.
+* Fix test suite, so that all tests pass.
+* Add a travis-ci test setup and connect it to the github account.
+
+## 1.6.32 / 2015-08-07
+
+* Avoid call to rb_class2name() during GC. Fixes #21
+* Use release mode, unless extconf.rb is called with --enable-debug,
+  so that all FXTRACE() and FXASSERT() calls are skiped, per default.
+* Remove self made GC detection by ruby's rb_during_gc().
+* Fix Windows binary x86-mingw32.gem for Ruby versions < 2.0
+
+## 1.6.31 / 2015-07-21
+
+* Replace pipe2() by pipe() and fcntl(), because pipe2() is not as portable.
+* Add missing include statement. Fixes #20
+
+## 1.6.30 / 2015-07-07
+
+* Fix crashes in rb_gc_mark(): 0x00000003f54af8 is T_ZOMBIE / T_NONE
+* Release Ruby's GVL while calls to FXImage#savePixels, #loadPixels
+  and FXApp#run* methods.
+* Add a working version for FXApp#addInput event handling on Windows.
+  This works for sockets only for now.
+* Add FXApp#runOnUiThread and FXId#runOnUiThread .
+  This allows to safely execute GUI code from other threads.
+* Use rake-compiler-dock for building windows binary gems.
+
+## 1.6.29 / 2015-02-17
+
+* Add Windows binaries for Ruby-2.1 and 2.2.
+* Use shared libs for Windows binary gems to reduce gem size.
+* Allow non owned assignment of image data to FXImage derivations
+  without copy'ing pixel data.
+* Allow retrival of parts of the pixel data.
+* Fix namespace specifier for FXRGB in kwargs.rb.
+* Change GC'ing of TreeListBox and FXTreeItem. Fixes #10
+* Update to swig version 2.0 or newer. Fixes #13
+
+## 1.6.28 / 2013-07-05
+
+* Fix build for Ruby-2.0.0-p127+
+* Update libraries for win32 build: libfox-1.6.49
+
+## 1.6.27 / 2013-04-05
+
+* Add support for Ruby-2.0.
+* Add cross compilation for x64-mingw32 target.
+
+## 1.6.26 / 2013-02-16
+
+* Mark all text strings retrieved from fox as UTF-8 when running on Ruby 1.9
+* Fix loading error on Ruby 1.8.7 by renaming the C++ extension to fox16_c
+* Update libraries for windows cross compilation
+
+## 1.6.25 / 2012-06-17
+
+* Windows: Fix slow loading of fox16.so by using a more recent mingw-w64 compiler
+  (reported by Allen Doug and Igor Jorobus)
+* Fix two possible segfaults in conjunction with FXSplashWindow (reported by Igor Jorobus)
+
+## 1.6.24 / 2012-06-06
+
+* Update libraries for win32 build: libz-1.2.7 libpng-1.5.10 libjpeg-8d libtiff-4.0.1 libfox-1.6.45
+* Avoid Segfauls in lots of methods when called with nil instead of FXApp, FXComposite or FXWindow objects
+
+## 1.6.23 / 2012-03-08
+
+* Add YARD documentation support
+* Use generated Manifest.txt
+* Support for parallel task execution with drake
+
+## 1.6.22 / 2012-02-21
+
+* Allow better access to raw pixel data of FXImage and derivatives
+* Build Windows binary gem per cross compiler on Linux
+* Add support for Rubinius (currently requires rubinius from git)
+* Add alias FXApp#modalWindow, as described in rdoc
+* Add quality parameter to FXJPGImage and FXJPGIcon
+* Fix invalid memory access in final GC call when using FXMenuCommand with acckey
+* Fix double referenced foxObj when borrowed object registration is triggered from C++
+* Fix Segfault while GC'ing FXWindows
+* Fix 'object allocation not allowed while garbage collection' bug
+* Fix clipboard handling on windows
+* Add missing namespace qualifier to FXSEL in FXAccelTable
+* Fix GC bug in FXAccelTable
+* Fix double free in FXMemoryStream#giveBuffer
+* Fix invalid memory access in typemap to zero terminated FXchar* (such as fillItems methods)
+* Fix FXApp#addInput for Ruby 1.9 on Linux
+* Fix "ruby_code case not handled: Regexp" issue with newer rubygems
+
+## Changes For Version 1.6.20 (November 09, 2009)
+
+* Integrated the Hoe and rake-compiler extensions into the Rakefile and
+  removed redundant tasks.
+* Did some work to provide support for MinGW builds.
+* The previous release of FXRuby couldn't be built from source against Ruby 1.9.1 final
+  due to a change in some of the file-related utility libraries
+  (see RubyForge Bug #23786). This problem has been corrected.
+
+
+## Changes For Version 1.6.19 (March 6, 2009)
+
+* The previous release of FXRuby couldn't be built from source against Ruby 1.9.1 final
+  due to a change in some of the file-related utility libraries
+  (see RubyForge Bug #23786). This problem has been corrected.
+* The previous release of FXRuby couldn't be built from source against Ruby versions 1.8.5 or
+  earlier (see RubyForge Bug #23967). This problem has been corrected.
+* A change in the return value for Ruby's `instance_variables` method broke
+  some of the code related to message handling in FXRuby (see RubyForge
+  Bug #23787). This problem has been corrected.
+* The `addAccel` method for the `FXAccelTable` class
+  now accepts lambda functions (or any other objects that respond to `call`). See
+  the API documentation
+  for `FXAccelTable` for examples of how this works.
+
+
+## Changes For Version 1.6.18 (December 29, 2008)
+
+* Some users were having trouble building FXRuby on 64-bit operating systems
+  (see RubyForge Bug #23375). This problem has been corrected.
+
+
+## Changes For Version 1.6.17 (December 24, 2008)
+
+* The Ruby interpreter was generating a large number of warning messages about redefined methods
+  in the `kwargs.rb` library
+  (see RubyForge
+  Bug #19231 and elsewhere). This problem has been corrected.
+
+* Due to recent changes in Ruby's garbage collection algorithm, FXRuby applications could under some circumstances
+  crash for large numbers of table items
+  (see RubyForge bugs ).
+  This bug has been fixed.
+
+* The documentation for the `FXTable` class referred to the non-existent `setColumnX`
+  and `setRowY` instance methods
+  (see RubyForge
+  Bug #21987). These entries have been removed from the documentation.
+
+* A number of instance methods for the `FXTable` class could crash an application if they
+  were passed out-of-bounds index arguments
+  (see RubyForge
+  Bug #21987). These methods now raise `IndexError` when they're passed out-of-bounds
+  indexes.
+
+* Due to a change in the URL scheme for the Dilbert web site, the `dilbert.rb` example
+  program was no longer working properly
+  (see RubyForge
+  Bug #21538). This has been fixed.
+
+* The `lower` method for the `FXRangef` was returning
+  ´self´ instead of an `FXVec3f` instance for the range's low
+  bound
+  (see RubyForge
+  Bug #22488). This has been fixed.
+
+* Made a number of minor fixes for compatibility with Ruby 1.9.1.
+
+
+## Changes For Version 1.6.16 (July 3, 2008)
+
+* Historically, if you called `create` on a
+  window before its parent window was created, your application would
+  crash (see RubyForge
+  Bug #20702 and elsewhere). Now, the code should raise a
+  ´RuntimeError´ with a message indicating the
+  problem.
+
+* The message data that the `FXPicker` widget
+  sends along with its ´SEL_CHANGED´ and
+  ´SEL_COMMAND´ messages wasn't being handled
+  properly, and as a result, applications using this widget could crash
+  (see RubyForge
+  Bug #20780). This problem has been fixed.
+
+
+## Changes For Version 1.6.15 (June 4, 2008)
+
+* FXRuby applications could crash (with a segmentation fault) if
+  ´nil´ was passed in as the first argument to
+  `FXDialogBox.new` or
+  `FXMainWindow.new` (see RubyForge
+  Bug #14642). These methods now raise an
+  ´ArgumentError´ if ´nil´ is
+  passed as the first argument.
+
+* You should only ever construct one `FXApp`
+  object per application, but there was no protection against doing so
+  in the code (see RubyForge
+  Bug #16275). Now, `FXApp.new` will
+  raise a `RuntimeException` if an
+  `FXApp` object already exists.
+
+* The `babelfish.rb` example program, which
+  previously depended on an external web service to perform translation
+  between languages, was broken since that web service no longer exists
+  (see RubyForge
+  Bug #16962). The example has now been updated to use Dr. Nic's
+  Tranexp library instead.
+
+* The value of the ´MBOX_SAVE_CANCEL_DONTSAVE´
+  option (for the `FXMessageBox` class) wasn't
+  wrapped properly and was unusable (see RubyForge
+  Bug #17094). There was also no constant corresponding to the
+  ´MBOX_CLICKED_DONTSAVE´ return value. Both of these
+  problems have been fixed.
+
+* The fields for new `FXHiliteStyle` objects
+  were uninitialized and as a result sometimes gave unpredictable
+  results (see RubyForge
+  Bug #19637). This has been fixed.
+
+* The `columnHeaderFont` and
+  `rowHeaderFont` attributes for
+  `FXTable` weren't implemented properly (see
+  RubyForge
+  Bug #20142). This has been fixed.
+
+* Ruby 1.8.7 adds a new `first` method to
+  the `Enumerable` module, and this conflicts with
+  the existing `first` method defined in the
+  `FXWindow` base class for a number of FXRuby
+  classes which mix in `Enumerable` (see RubyForge
+  Bug #20418). This problem has been resolved.
+
+* Due to a bug in the `extconf.rb` script, the
+  build was failing for Ruby 1.9.0 (see RubyForge
+  Bug #20426). This has been fixed.
+
+
+## Changes For Version 1.6.14 (March 29, 2008)
+
+* Updated the documentation for the `FXImage`
+  class to indicate which methods call `render`
+  after they're finished, and which ones do not.
+
+* Corrected a little typo in the
+  `gembrowser.rb` example program.
+
+* Updated the `dilbert.rb` example program to
+  use the more popular-and-likely-to-be-installed Hpricot HTML
+  parser library instead of Rubyful Soup.
+
+* Re-added the documentation for the
+  ´TOGGLEBUTTON_KEEPSTATE´ option, which had
+  mysteriously disappeared (see RubyForge
+  Bug #2286).
+
+* Made a number of minor fixes to support building FXRuby against
+  Ruby 1.9.
+
+* Added a binary gem for OS X. This works with the Ruby that's
+  included with OS X (Leopard).
+
+* The binary gem for Windows was built with FOX version 1.6.32 and
+  FXScintilla version 1.71.
+
+
+## Changes For Version 1.6.13 (November 9, 2007)
+
+* Calls to the `extractText` method for the
+  `FXTable` class were causing various
+  memory-related errors on certain platforms (see RubyForge
+  Bug #15444). This problem has been fixed.
+
+* The binary gem for Windows was built with FOX version 1.6.28 and
+  FXScintilla version 1.71.
+
+## Changes For Version 1.6.12 (October 19, 2007)
+
+* The API documentation for `FXMDIClient`
+  referred to the non-existent instance method
+  `activeChild=` (see RubyForge
+  Bug #10259). This method has been added.
+
+* The API documentation for `FXMDIClient`
+  also referred to the non-existent instance methods
+  `getMDIChildFirst` and
+  `getMDIChildLast`. These entries have been
+  removed.
+
+* The API documentation for `FXMDIChild`
+  referred to non-existent instance methods
+  `getMDINext` and
+  `getMDIPrev` (see RubyForge
+  Bug #10436). The documentation has been corrected.
+
+* Added the ´:repeat´ parameter for the
+  `addChore` and
+  `addTimeout` methods. See the documentation for
+  more details, and `gltest.rb` for an example of its
+  use.
+
+* Corrected a number of minor typos in the API
+  documentation.
+
+* Corrected a typo in the `imageviewer.rb`
+  example.
+
+* Modified the `inputs.rb` example program to
+  use `Pipe.read_nonblock()` instead of
+  `Pipe.read()`.
+
+* Fixed a bug in the implementation of the
+  `findText` method for the
+  `FXText` class, when used with the
+  ´SEARCH_REGEX´ option.
+
+* The binary gem for Windows was built with FOX version 1.6.28 and
+  FXScintilla version 1.71.
+
+
+## Changes For Version 1.6.11 (April 18, 2007)
+
+* Added `editable` as an alias for
+  `FXTextField#editable?`.
+
+* Added `each_child_recursive` instance
+  method for the `FXWindow` class. This method
+  performs a depth-first traversal of the widget tree starting at the
+  receiver window.
+
+* Corrected some errors in the keyword arguments support for the
+  `FXVec2d`, `FXVec2f`,
+  `FXVec3d`, `FVec3f`,
+  `FXVec4d` and `FXVec4f`
+  classes.
+
+* Corrected an error in the keyword arguments support for the
+  `FXIconDict` class.
+
+* Modified the gem specification so that the RDoc generated during
+  a gem install is consistent with that generated by other methods (see
+  RubyForge
+  Bug #10035).
+
+* Changes to the `iterators` library in version
+  1.6.6 introduced a bug in the `each` method for
+  the `FXFoldingList`,
+  `FXTreeList` and
+  `FXTreeListBox` classes (see RubyForge
+  Bug #10175). This problem has been fixed.
+
+* Applied submitted patches for building FXRuby against Ruby 1.9
+  (see RubyForge
+  Bug #10181). Please note that building FXRuby against the Ruby
+  1.9 code base is still officially unsupported; however, I'm glad to
+  accept patches that will help make this possible.
+
+* The binary gem for Windows was built with FOX version 1.6.25 and
+  FXScintilla version 1.71.
+
+
+## Changes For Version 1.6.9 (April 8, 2007)
+
+* A bug was discovered in the keyword arguments library support
+  for the `FXMenuBar` class (see RubyForge
+  Bug #9927). This problem has been fixed.
+
+* The binary gem for Windows was built with FOX version 1.6.25 and
+  FXScintilla version 1.71.
+
+
+## Changes For Version 1.6.8 (April 5, 2007)
+
+* Due to an internal bookkeeping error, applications like the
+  `glviewer.rb` example program which create multiple
+  `FXGLViewer` instances could cause an assertion
+  to fail. When this assertion fails on Windows, the program simply
+  crashes (see RubyForge
+  Bug #9775). This problem has been fixed.
+
+* The keyword arguments library, introduced in version 1.6.5, is
+  now included automatically when you load FXRuby; it is no longer
+  necessary to explicitly require it.
+
+* The binary gem for Windows was built with FOX version 1.6.25 and
+  FXScintilla version 1.71.
+
+
+## Changes For Version 1.6.7 (March 31, 2007)
+
+* The binary gem for Windows was built with FOX version 1.6.25 and
+  FXScintilla version 1.71.
+
+
+## Changes For Version 1.6.6 (February 10, 2007)
+
+* Somewhere along the way, the RAA browser example program got
+  broken due to changes in the SOAP interface to RAA (see RubyForge
+  Bug #7977). This has been fixed.
+
+* Some debugging code that was meant to detect errors in FXRuby
+  message data conversion was inadvertently causing some user
+  applications to crash when running under Windows (see RubyForge
+  Bug #8049). This debugging code has been changed to avoid the
+  problem.
+
+* Modified the implementations of the each iterator methods for
+  `FXFoldingList`,
+  `FXFoldingItem`,
+  `FXTreeItem`, `FXTreeList`
+  and `FXTreeListBox` (see RubyForge
+  Bug #8090). The new implementation is a bit more robust in
+  terms of modifications (such as deletion) of the iterated-over
+  elements.
+
+* A bug in the new keyword arguments library (introduced in
+  version 1.6.5) caused the `initialize` method
+  for the `FXDCWindow` class to do the wrong thing
+  (see RubyForge
+  Bug #8441). This has been corrected.
+
+* A different bug in the keyword arguments library caused the
+  `initialize` method for the
+  `FXFont` class to do the wrong thing (see RubyForge
+  Bug #8517). This also has been corrected.
+
+* Yet another bug in the keyword arguments library broke the part
+  of the code that used to yield ´self´ to an
+  optional block attached to the call to `new`
+  (see RubyForge
+  Bug #8518). This has been corrected.
+
+* Most of the FXRuby example programs have been updated to use the
+  keyword arguments library.
+
+* Added a new "virtual" keyword argument
+  ´:padding´ that can be used in place of (or in
+  addition to) the ´:padLeft´,
+  ´:padRight´, ´:padTop´ and
+  ´:padBottom´ arguments for a constructor. When a
+  ´:padding´ value is passed in to the arguments
+  hash, that value will be used for any of the four regular padding
+  values that aren't otherwise specified. See the example programs for,
+  you know, examples.
+
+* The binary gem for Windows was built with FOX version 1.6.20 and
+  FXScintilla version 1.71.
+
+
+## Changes For Version 1.6.5 (January 20, 2007)
+
+* Clicking outside of the visible cells for an
+  `FXTable` when there was no current selection
+  caused the code to raise an exception (see RubyForge
+  Bug #5907). This problem has been fixed.
+
+* The `hasTimeout?` method for the
+  `FXApp` class was implemented incorrectly (see
+  RubyForge
+  Bug #7564). This problem has been fixed.
+
+* The `FXFoldingList` and
+  `FXFoldingItem` classes did not have each
+  iterator methods like most of the other list-based widgets (see RubyForge
+  Patch #7978). These have been added.
+
+* The API documentation for `FXMDIClient`
+  claimed that `FXScrollArea` was its base class
+  (see RubyForge
+  Bug #7979). This has been corrected; the base class for
+  `FXMDIClient` is
+  `FXComposite`.
+
+* There was a small typo in the documentation for the
+  `FXFoldingList` class options (see RubyForge
+  Bug #7981). This has been fixed.
+
+* Added preliminary support for keyword-style arguments, as
+  described in the "Differences Between
+  FOX and FXRuby" section of the FXRuby User's Guide.
+
+* The binary gem for Windows was built with FOX version 1.6.20 and
+  FXScintilla version 1.71.
+
+
+## Changes For Version 1.6.4 (November 30, 2006)
+
+* A change made in Ruby 1.8.5 for cyclic requires led to a problem
+  that caused the Ruby interpreter to emit a large number of warnings
+  (see RubyForge
+  Bug #5633). This problem has been fixed.
+
+* The binary gem for Windows was built with FOX version 1.6.16 and
+  FXScintilla version 1.71.
+
+
+## Changes For Version 1.6.3 (October 27, 2006)
+
+* Widgets of some classes (namely
+  `FXTopWindow` and
+  `FXMDIChild`) weren't properly sending a
+  ´SEL_CLOSE´ message to their message targets (see
+  RubyForge
+  Bug #5498). Thanks to a change in FOX version 1.6.16, this
+  problem has been fixed.
+
+* The `getControlFor` method for the
+  `FXComboTableItem` class was coded incorrectly
+  (see RubyForge
+  Bug #5906). This has been fixed.
+
+* There was a minor typo in the API documentation for the
+  `FXTriStateButton` class (see RubyForge Bug #5962). This has been fixed.
+
+* The `each_row` and
+  `each_column` iterator methods for the
+  `FXTable` class were incorrectly coded (see
+  RubyForge
+  Bug #6036). This has been fixed.
+
+* The `new` class methods for
+  `FXColorItem`, `FXDirItem`,
+  `FXFileItem`,
+  `FXFoldingItem`,
+  `FXHeaderItem`,
+  `FXIconItem`, `FXListItem`
+  and `FXTreeItem` were all raising exceptions when
+  a non-´nil´ value was passed in for the last
+  argument (see RubyForge
+  Bug #6197). A similar problem was present for various instance
+  methods in the `FXColorList`,
+  `FXListBox` and
+  `FXMDIClient` classes. These problems have been
+  fixed.
+
+* A few problems were discovered for the
+  `inputs.rb` example program (see RubyForge
+  Bug #6209). These problems have been fixed.
+
+* Several instance methods for the `FXTable`
+  class were not actually present under their documented names (see
+  RubyForge
+  Bug #6211). This has been fixed.
+
+* The build script was not compatible with changes made in the
+  recently-released FXScintilla 1.71 (see RubyForge
+  Bug #6313). This has been fixed.
+
+* The binary gem for Windows was built with FOX version 1.6.16 and
+  FXScintilla version 1.71.
+
+
+## Changes For Version 1.6.2 (September 13, 2006)
+
+* The `expandTree()` and
+  `collapseTree()` methods for the
+  `FXFoldingList` class were incorrectly identified
+  as `expandFolding()` and
+  `collapseFolding()` in the API documentation
+  (see RubyForge
+  Bug #5354). This has been fixed.
+
+* The `FXDockTitle` class was not supported
+  (see RubyForge
+  Bug #5632). This has been fixed.
+
+* The API documentation for the `FXGLCanvas`
+  class claimed it had a `shared?` method, but it
+  didn't (see RubyForge
+  Bug #5591). Now it does.
+
+* The `FXGradientBar` class was not supported
+  (see RubyForge
+  Bug #5746). This has been fixed.
+
+* The binary gem for Windows was built with FOX version 1.6.14 and
+  FXScintilla version 1.67 (from CVS).
+
+
+## Changes For Version 1.4.7 (September 13, 2006)
+
+* The `children` instance method for the
+  `FXWindow` class always returned an array of
+  `FXWindow` instances, even if the actual types
+  should have been instances of subclasses of
+  `FXWindow` (see RubyForge
+  Bug #4342). This has been fixed.
+
+* The `dilbert.rb` example program was broken
+  due to a change in the Dilbert.com web site structure (see RubyForge
+  Bug #4597). This has been fixed.
+
+* The `expandTree()` and
+  `collapseTree()` methods for the
+  `FXFoldingList` class were incorrectly identified
+  as `expandFolding()` and
+  `collapseFolding()` in the API documentation
+  (see RubyForge
+  Bug #5354). This has been fixed.
+
+* The `FXDockTitle` class was not supported
+  (see RubyForge
+  Bug #5632). This has been fixed.
+
+* The API documentation for the `FXGLCanvas`
+  class claimed it had a `shared?` method, but it
+  didn't (see RubyForge
+  Bug #5591). Now it does.
+
+* The `FXGradientBar` class was not supported
+  (see RubyForge
+  Bug #5746). This has been fixed.
+
+* The binary gem for Windows was built with FOX version 1.4.34 and
+  FXScintilla version 1.63.
+
+
+## Changes For Version 1.6.1 (July 21, 2006)
+
+* The message data sent along for the
+  ´SEL_INSERTED´, ´SEL_DELETED´
+  and ´SEL_REPLACED´ messages from an a
+  `FXText` widget to its target was not being
+  converted properly (see RubyForge
+  Bug #4666). This has been fixed.
+
+* The code related to the localization of application messages in
+  FOX wasn't implemented properly in FXRuby, and as a result,
+  constructing certain dialogs (like the color dialog) could cause a
+  program to crash (see RubyForge
+  Bug #5000). This has been fixed.
+
+* The "Stop Spin" button in the gltest.rb example program didn't
+  stop the cubes from spinning after either the "Spin Timer" or "Spin
+  Chore" option was selected (see RubyForge
+  Bug #5001). This was actually a symptom of a larger problem,
+  that FXRuby wasn't properly handling timers and chores. These problems
+  have been fixed.
+
+* Setting the current item for an
+  `FXComboBox` to -1 (to indicate that there's no
+  current item) would cause FXRuby to erroneously raise an
+  `IndexError` (see RubyForge
+  Bug #5007). This has been fixed.
+
+* The documentation for the `reparent`
+  instance method for the `FXWindow` class was
+  incorrect (see RubyForge
+  Bug #5035). This has been fixed.
+
+* The `textedit.rb` example program was not up
+  to date with some of the changes for FOX 1.6. This example has been
+  updated.
+
+* The new `font` method for the
+  `FXFont` class was not documented. This has been
+  fixed.
+
+* The `dilbert.rb` example program has been
+  modified to use the RubyfulSoup HTML library instead of the
+  html-parser library.
+
+* As discussed in various forums (see for example [this
+  post](http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/182827), the `autorequire` directive for
+  RubyGems specifications is now deprecated. As a result, this has been
+  removed from the FXRuby gem specification. This change will break any
+  code that was using a statement like:´require_gem 'fxruby'´as
+  the sole means for loading FXRuby. Such programs should instead
+  use:´require 'fox16'´which will work
+  for either gem based or non-gem based installations.
+
+* The binary gem for Windows was built with FOX version 1.6.8 and
+  FXScintilla version 1.67 (from CVS).
+
+
+## Changes For Version 1.6.0 (May 29, 2006)
+
+* This is the first release of FXRuby compatible with FOX version
+  1.6. One of the most signficant changes for FOX 1.6 has been the
+  addition of Unicode support; all FOX widgets and internal string
+  processing routines are now Unicode aware. For a comprehensive
+  overview of the changes made to FOX since version 1.4 (including those
+  made in the FOX 1.5 development series), please refer to the
+  [News archives](http://www.fox-toolkit.com/news.html) at
+  the FOX web site.
+
+* Added the `allowSide`,
+  `disallowSide` and
+  `allowedSide?` methods for the
+  `FXDockBar` class, as complements to the
+  `allowedSides` accessor methods (see RubyForge
+  Feature Request #2307).
+
+* Added the `visible=` and
+  `visible?` accessor methods for the
+  `FXWindow` class, as complements to the
+  `show`, `hide` and
+  `shown?` methods (see RubyForge
+  Feature Request #3579).
+
+* The `browser.rb` example was making use of a
+  deprecated API (see RubyForge
+  Bug #4325). This has been fixed.
+
+* The `children` instance method for the
+  `FXWindow` class always returned an array of
+  `FXWindow` instances, even if the actual types
+  should have been instances of subclasses of
+  `FXWindow` (see RubyForge
+  Bug #4342). This has been fixed.
+
+* The `dilbert.rb` example program was broken
+  due to a change in the Dilbert.com web site structure (see RubyForge
+  Bug #4597). This has been fixed.
+
+* The binary gem for Windows was built with FOX version 1.6.5 and
+  FXScintilla version 1.67 (from CVS).
+
+
+## Changes For Version 1.4.6 (April 26, 2006)
+
+* FXRuby would not compile properly on some x86-64 systems (see
+  RubyForge
+  Bug #3729). This error has been corrected. Thanks to Javier
+  Goizueta for initially reporting this problem, and especially to
+  Tobias Peters for providing a patch.
+
+* The `FXIconDict` widget was accidentally
+  "lost" in the transition between FXRuby versions 1.2 and 1.4 (see
+  RubyForge
+  Bug #4117). This error has been corrected. Thanks to Manfred
+  Usselmann for reporting this problem.
+
+* The `FXSwitcher` widget was not sending the
+  appropriate message data to its message target for the
+  ´SEL_COMMAND´ message type (see RubyForge
+  Bug #4157). This error has been corrected. Thanks to Manfred
+  Usselmann for reporting this problem.
+
+* The `FXSeparator` class wasn't implemented
+  properly (see RubyForge
+  Bug #4158). This error has been corrected. Thanks to Gerard
+  Menochet for reporting this problem.
+
+* The `findItemByData` method was
+  implemented incorrectly for the `FXComboBox`,
+  `FXFoldingList`,
+  `FXIconList`, `FXList` and
+  `FXListBox` classes (see RubyForge
+  Bug #4172). This error has been corrected. Thanks to Gerard
+  Menochet for reporting this problem.
+
+* The `FXListBox` widget was not sending the
+  appropriate message data to its message target for the
+  ´SEL_COMMAND´ message type (see RubyForge
+  Bug #4255). This error has been corrected. Thanks to Gerard
+  Menochet for reporting this problem.
+
+* The binary gem for Windows was built with FOX version 1.4.29 and
+  FXScintilla version 1.63.
+
+
+## Changes For Version 1.4.5 (April 10, 2006)
+
+* The `FXTextField` class was not properly
+  responding to the ´ID_INSERT_STRING´ command (see
+  RubyForge
+  Bug #3320). This error has been corrected. Thanks to Uwe Hartl
+  for reporting this problem.
+
+* The `text` and
+  `getText` methods for the
+  `FXMenuCaption` class were returning
+  ´nil´ instead of the actual value (see RubyForge
+  Bug #3458). This error has been corrected. Thanks to Meinrad
+  Recheis (Henon) for reporting this problem.
+
+* The API documentation for the `FXMDIChild`
+  class erroneously listed ´SEL_CLOSEALL´ as one of
+  the message types that an MDI child window might send to its message
+  target (see RubyForge
+  Bug #3508). This error has been corrected. Thanks to Meinrad
+  Recheis (Henon) for reporting this problem.
+
+* Calling the `selectRange` method for
+  class `FXTable` would cause a fatal error instead
+  of merely raising an `IndexError` exception (see
+  RubyForge
+  Bug #3615). This error has been corrected. Thanks to Meinrad
+  Recheis (Henon) for reporting this problem.
+
+* Due to an error in the SWIG interface files, the
+  `FXChoiceBox` class was basically unusable (see
+  RubyForge
+  Bug #3676). This error has been corrected. Thanks to Uwe Hartl
+  for reporting this problem.
+
+* The API documentation for the
+  `FXRealSlider` and
+  `FXRealSpinner` classes erroneously claimed that
+  the message data for the ´SEL_COMMAND´ and
+  ´SEL_CHANGED´ messages sent by these widgets to
+  their targets were integers (see RubyForge
+  Bug #3749). Along the same lines, the message data for those
+  widgets wasn't being converted correctly (see RubyForge
+  Bug #3750). Both of these errors have been corrected. Thanks
+  to Meinrad Recheis (Henon) for reporting these problems.
+
+* The API documentation for the Fox module incorrectly listed the
+  names of the `FXSELTYPE` and
+  `FXSELID` methods as
+  `SELTYPE` and `SELID`
+  (see RubyForge
+  Bug #3940). This error has been corrected. Thanks to Joel
+  VanderWerf for reporting this problem.
+
+* The `FXTableItem` constructor was supposed
+  to (optionally) accept a reference to an arbitrary Ruby object as its
+  third argument, but this wasn't working properly (see RubyForge
+  Bug #4005). This error has been corrected. Thanks to Mark
+  Volkman for reporting this problem.
+
+* The binary gem for Windows was built with FOX version 1.4.29 and
+  FXScintilla version 1.63.
+
+
+## Changes For Version 1.4.4 (January 21, 2006)
+
+* The build instructions for Unix platforms had not been updated
+  recently and as such contained some errors (see RubyForge
+  Bug #3014). These errors have been corrected. Thanks to Dave
+  Burns for reporting this problem.
+
+* The `extendSelection` method for the
+  `FXTable` class was raising an exception if an
+  out of bounds row or column index was passed in (see RubyForge
+  Bug #3050). This has been changed so that
+  `extendSelection` instead returns false for out
+  of bounds arguments. Thanks to Leonid Moiseichuk for reporting this
+  problem.
+
+* The `each_child` iterator method for the
+  `FXWindow` class would fail if the child window
+  was destroyed in the block (see RubyForge
+  Bug #3134). Thanks to Liam Irish for reporting this problem
+  and providing a patch.
+
+* The message data for the ´SEL_REPLACED´
+  message sent by the `FXTable` class to its target
+  was not being handled properly (see RubyForge
+  Bug #3244). There were also problems with the message data for
+  the ´SEL_SELECTED´ and
+  ´SEL_DESELECTED´ messages. Furthermore, the
+  ´SEL_REPLACED´ message was not documented in the
+  RDoc documentation for the `FXTable` class. All
+  of these problems have been corrected. Thanks to _blackdog for
+  reporting this problem.
+
+* The binary gem for Windows was built with FOX version 1.4.29 and
+  FXScintilla version 1.63.
+
+
+## Changes For Version 1.4.3 (November 7, 2005)
+
+* The ´TOGGLEBUTTON_KEEPSTATE´ option for the
+  `FXToggleButton` class was not documented (see
+  RubyForge
+  Bug #2286). This oversight has been corrected. Thanks to Tim
+  Smith for reporting this problem.
+
+* The `scintilla.rb` library file was not up to
+  date with the latest FXScintilla release, and as a result it was
+  missing some methods (see RubyForge
+  Bug #2479). This oversight has been corrected. Thanks to Maxim
+  Kulkin for reporting this problem.
+
+* Due to changes in the APIs for timers and chores, the mechanisms
+  for removing chores and timeouts were broken (see RubyForge
+  Bug #2563). This bug has been fixed. Thanks to "moinker" for
+  reporting this problem.
+
+* An error in the test setup caused all of the tests for the
+  `FXList` class to fail (see RubyForge
+  Bug #2564). This bug has been fixed. Thanks to Peter for
+  reporting this problem.
+
+* Due to a bug in the test suite runner script, not all test cases
+  were being exercised (see RubyForge
+  Bug #2565). This bug has been fixed.
+
+* Calling the `getPixel` method for the
+  `FXImage` class when the client-side pixel buffer
+  for the image has already been released would cause a program to crash
+  (see RubyForge
+  Bug #2611). Now, `getPixel` will raise
+  an exception if it's called after the pixel buffer has been released.
+  The documentation for `getPixel` has been
+  updated accordingly. Thanks to Gonzalo Garramuno for reporting this
+  problem.
+
+* The `makePositionVisible` method for the
+  `FXTable` class was raising an exception when
+  passed out-of-bounds values for the row or column index (see RubyForge
+  Bug #2660). This could happen, for example, if you were to
+  click in a table area outside of the regular cells (which indirectly
+  triggers a call to `makePositionVisible`). This
+  was actually inconsistent with standard FOX behavior, which simply
+  ignores out of bounds values for that method's arguments. This bug has
+  been fixed, and the documentation for
+  `makePositionVisible` has been updated
+  accordingly. Thanks to Ralf Jonas for reporting this problem.
+
+* The binary gem for Windows was built with FOX version 1.4.21 and
+  FXScintilla version 1.63.
+
+
+## Changes For Version 1.4.2 (August 22, 2005)
+
+* Due to a bug in the implementation, the
+  `checked?` method for the
+  `FXCheckButton` class always returned
+  ´false´ (see RubyForge
+  Bug #1852). This bug has been fixed. Thanks to Meinrad Recheis
+  for reporting this problem.
+
+* The API documentation for the `FXTable`
+  class listed several obsolete attributes (see RubyForge
+  Bug #1928). Those errors have been corrected. Thanks to Pavel
+  Sokolov for reporting these problems.
+
+* There were a number of bugs in the
+  `textedit.rb` example program (see RubyForge
+  Bug #1979), and those bugs have been fixed. Thanks to Claude
+  Marinier for reporting these problems.
+
+* The API documentation for the `FXTreeList`
+  class' `new` method still showed the number of
+  visible items (´nvis´) as its second argument
+  (see RubyForge
+  Bug #2171). This problem has been corrected. Thanks to Bill
+  Atkins for reporting this problem.
+
+* The API documentation for the `FXTopWindow`
+  class had a number of errors (see RubyForge
+  Bug #2269). This problem has been corrected.
+
+* The API documentation for the `FXTreeList`
+  class still listed the obsolete `reparentItem`
+  method (see RubyForge
+  Bug #2270). This problem has been corrected. Thanks to Jacob
+  Hansen for reporting this problem.
+
+* Due to a bug in how the SWIG typemaps for the
+  ´FXlong´ type were defined, some methods for the
+  `FXFileStream` class were broken (see RubyForge
+  Bug #2275). This problem has been corrected. Thanks to Gonzalo
+  Garramuno for reporting this problem.
+
+* Merged in all of the fixes for FXRuby 1.2.6.
+
+* The binary gem for Windows was built with FOX version 1.4.17 and
+  FXScintilla version 1.63.
+
+
+## Changes For Version 1.4.1 (August 20, 2005)
+
+* This is the second release of FXRuby which is compatible with
+  FOX 1.4, and as such should be considered an "unstable" release. For a
+  history of the changes made during the FOX 1.3 and 1.4 development,
+  see the [News](http://www.fox-toolkit.com/news.html)
+  page at the FOX Web site.
+
+* The unit tests (in the `tests` subdirectory)
+  had not been updated to require the ´fox14´
+  feature, and were still looking at ´fox12´. This
+  has been corrected.
+
+* A number of minor problems were corrected for the Windows build
+  of FXRuby.
+
+* The binary gem for Windows was built with FOX version 1.4.17 and
+  FXScintilla version 1.63.
+
+
+## Changes For Version 1.4.0 (August 19, 2005)
+
+* This is the first release of FXRuby which is compatible with FOX
+  1.4, and as such should be considered an "unstable" release. For a
+  history of the changes made during the FOX 1.3 and 1.4 development,
+  see the [News](http://www.fox-toolkit.com/news.html)
+  page at the FOX Web site.
+
+
+## Changes For Version 1.2.6 (April 15, 2005)
+
+* Some additional problems related to calling the
+  `setTableSize` method for an
+  `FXTable` were discovered (see RubyForge
+  Bug #1597). This problem has been corrected. Thanks to Joel
+  VanderWerf for reporting this problem.
+
+* The `iconlist.rb` example program had a
+  "Sort" pulldown menu filled with a number of commands that didn't
+  really do anything, including sorting the items (see RubyForge
+  Bug #1654). This pulldown menu has been removed from that
+  example.
+
+* The API documentation for the `FXDC` class
+  erroneously referred to the `font` attribute as
+  `textFont` (see RubyForge
+  Bug #1667). This problem has been corrected. Thanks to Meinrad
+  Recheis for reporting this problem.
+
+* The `checked?`,
+  `unchecked?` and
+  `maybe?` methods for the
+  `FXMenuCheck` class were missing (see RubyForge
+  Bug #1677). This problem has been corrected. Thanks to Oliver
+  Smith for reporting this problem.
+
+* The API documentation for the
+  `FXScrollArea` class incorrectly spelled the
+  names of the `horizontalScrollBar` and
+  `verticalScrollBar` methods as
+  `horizontalScrollbar` and
+  `verticalScrollbar` (see RubyForge
+  Bug #1678). The documentation has been corrected. Thanks to
+  Jannis Pohlmann for reporting this mistake.
+
+* Some code in the `groupbox.rb` example
+  program was calling the `getRootWindow` method,
+  but that method has been renamed to `getRoot`
+  (see RubyForge
+  Bug #1692). This problem has been corrected. Thanks to
+  Jaroslav Stika for reporting this problem.
+
+* The `hasChar?` method for the
+  `FXFont` class was spelled without a trailing
+  question mark, but it seems more Ruby-like that it should, so we've
+  added an alias for that (see RubyForge
+  Bug #1714). This method also now accepts a string of size 1
+  (i.e. a single character) as its input, as an alternative to an
+  ordinal value. Thanks to Meinrad Recheis for these suggestions.
+
+* The API documentation for the `FXImage`
+  class mistakenly listed ´IMAGE_ALPHA´ as a valid
+  image rendering hint, but this flag is no longer needed since FOX
+  images now always contain an alpha channel (see RubyForge
+  Bug #1715). The documentation has been corrected. Thanks to
+  Meinrad Recheis for reporting this mistake.
+
+* Due to an error in the SWIG interface files, the
+  `data` method for the
+  `FXSettings` class was not being wrapped
+  properly. As a result, this method was unavailable and in turn led to
+  other dependent methods (like `each_section`)
+  to be unavailable as well (see RubyForge
+  Bug #1771). This error has been corrected. Thanks to Jannis
+  Pohlmann for reporting this problem.
+
+* The binary gem for Windows was built with FOX version 1.2.16 and
+  FXScintilla version 1.62.
+
+
+## Changes For Version 1.2.5 (March 1, 2005)
+
+* The change made for FXRuby version 1.2.4 regarding garbage
+  collection for table items corrected only one of the problems
+  described in RubyForge
+  Bug #1445; There was still a problem related to the
+  "destructive" effects of the `setTableSize`
+  method for the `FXTable` class. This problem has
+  now been corrected as well. Thanks to David Peoples, Jamey Cribbs and
+  Joel VanderWerf for their assistance in helping me to track down this
+  problem.
+
+* The `extractText` and
+  `overlayText` methods for the
+  `FXTable` class were implemented incorrectly and
+  weren't listed in the API documentation. These problems have been
+  corrected.
+
+* The checks for out-of-bounds indices in the
+  `getColumnX`,
+  `setColumnX`, `getRowY`,
+  `setRowY` and
+  `updateRange` methods for the
+  `FXTable` class were incorrect. These have been
+  fixed.
+
+* The `setTableSize` method for the
+  `FXTable` class now raises
+  `ArgError` if either the number of rows or
+  columns passed in as arguments is less than zero.
+
+* A typo in one of the source files was causing the build to fail
+  when compiled against Ruby versions 1.8.1 or earlier (see RubyForge
+  Bug #1551). This error has been corrected. Thanks to Alex
+  McGuire for reporting this problem.
+
+* The `selectItem` method for the
+  `FXTable` class was removed in FOX 1.2, so we've
+  added a convenience method for this that just calls the
+  `selectRange` method under the hood (see RubyForge
+  Bug #1562). Thanks to Joel VanderWerf for this
+  suggestion.
+
+* The binary gem for Windows was built with FOX version 1.2.13 and
+  FXScintilla version 1.62.
+
+
+## Changes For Version 1.2.4 (February 23, 2005)
+
+* Due to a change in some of the internal Ruby C APIs, a
+  compile-time error for FXRuby was introduced in some of the Ruby 1.8.2
+  preview releases (see RubyForge
+  Bug #1039). One should not see any compile-time errors when
+  compiling FXRuby (versions 1.2.3 or later) against the Ruby 1.8.2
+  final release, but I've neverthless made a change to how those
+  internal APIs are used, to avoid any potential problems. Thanks to the
+  many users who pointed out this problem.
+
+* Joel VanderWerf suggested some enhancements to the
+  `image.rb` example program in order to improve its
+  startup time (see RubyForge
+  Bug #1281). Those changes have been incorporated. Thanks to
+  Joel for this suggestion.
+
+* One change for the `FXImage` class between
+  FOX versions 1.0 and 1.2 is the nature of the pixel buffer that's
+  passed to the `FXImage` constructor. Previously,
+  this pixel buffer was expected to be a string of bytes; now it's
+  expected to be an array of ´FXColor´ values. This
+  modification was not implemented correctly for FXRuby versions 1.2.3
+  and earlier (see RubyForge
+  Bug #1427). This bug has been corrected, and the example
+  program (`image.rb`) and test cases have been
+  updated as well. Thanks to Oliver Smith and others for reporting this
+  problem.
+
+* A couple of different problems, reported by Patrick Fernie and
+  David Peoples, exposed a flaw in how FXRuby manages the links between
+  FOX objects and their Ruby peers when the FOX objects are destroyed
+  (see RubyForge
+  Bug #1445). Without going into all the gory details, let's
+  just say that since we have no explicit control over when Ruby's
+  garbage collector decides to "collect" those Ruby peers that point to
+  C++ objects that have been destroyed, we need to take steps to
+  neutralize those Ruby peer objects so that they can't cause your
+  application to crash in the meantime; I've implemented a fix to take
+  care of this situation. Thanks to Patrick and David for reporting
+  these problems.
+
+* The API documentation for FXRuby 1.2 still contained references
+  to the old "spellings" of the `fxparseAccel`
+  and `fxparseHotKey` method names, which were
+  all lowercase (i.e. `fxparseaccel` and
+  `fxparsehotkey`). (see RubyForge
+  Bug #1470). These errors have been corrected.
+
+* Added the `FXScrollArea#scrollCorner`
+  method, which returns a reference to the scroll corner for any window
+  derived from `FXScrollArea` (see RubyForge
+  Feature Request #1226). Thanks to Brian Sheehan for this
+  suggestion.
+
+* Added the `FXMemoryBuffer#to_a` method,
+  which is just an alias for the `data` accessor
+  method that returns a copy of the data buffer as an array (see RubyForge
+  Feature Request #1295). Thanks to Meinrad Recheis for this
+  suggestion.
+
+* Added the `appendRows` and
+  `appendColumns` methods to the
+  `FXTable` class (see RubyForge
+  Feature Request #1295). Thanks to Brett Hallett for this
+  suggestion.
+
+* The binary gem for Windows was built with FOX version 1.2.13 and
+  FXScintilla version 1.62.
+
+
+## Changes For Version 1.2.3 (January 22, 2005)
+
+* Since group boxes containing radio buttons no longer enforce the
+  radio behavior of radio buttons (i.e. keeping only one radio button
+  selected at a time), some of the example programs were no longer
+  working as desired (see RubyForge
+  Bug #751 and RubyForge
+  Bug #1280). This problem has been corrected. Thanks to Yuri
+  Leikind and Barry DeZonia for reporting this problem.
+
+* Bob Sidebotham reported a little typo in the
+  `table.rb` example program (see RubyForge
+  Bug #990). This has been corrected.
+
+* The API documentation for `FXList` did not
+  reflect the changes for FOX 1.2; the
+  `retrieveItem()` has been renamed to
+  `getItem()` and
+  `insertItem()` has been renamed to
+  `setItem()` (see RubyForge
+  Bug #1037 and RubyForge
+  Bug #1257). This has been corrected. Thanks to Remy Drouilhet
+  and Stephan Kamper for reporting this problem.
+
+* The Windows installer was missing some of the documentation
+  files (see RubyForge
+  Bug #1139). This has been corrected. Thanks to Curt Hibbs and
+  Mark Smith for reporting this problem.
+
+* The `browser.rb` example program was broken
+  (see RubyForge
+  Bug #1146). This has been corrected. Thanks to Stefan Lang for
+  reporting this problem.
+
+* The attribute setter for
+  `FXHeaderItem#justification` was defined
+  incorrectly (see RubyForge
+  Bug #1276). This has been corrected. Thanks to Joel VanderWerf
+  for reporting this problem (and providing a patch to fix it).
+
+* The `filenames` alias for the
+  `FXFileDialog#getFilenames()` instance method
+  was missing (see RubyForge
+  Bug #1277). This error has been corrected. Thanks to Barry
+  DeZonia for reporting this problem.
+
+* The API documentation for the
+  `FXFileDialog` class methods
+  `getOpenFilenames()`,
+  `getOpenDirectory()`,
+  `getOpenFilename()` and
+  `getSaveFilename()` was extremely inadequate
+  (see RubyForge
+  Bug #1279). This documentation has been improved. Thanks to
+  Barry DeZonia for reporting this problem.
+
+* Brett Hallett contributed a Ruby port of the "ratio" example
+  program from the regular FOX distribution, for demonstrating the use
+  of the new `FXSpring` layout manager (see RubyForge
+  Bug #1282). Many thanks to Brett for this addition!
+
+* Joel VanderWerf contributed code to simplify how programs
+  interact with modal and non-modal dialog boxes (see RubyForge
+  Bug #1283). See the API documentation for the new
+  `FXDialogBox#execute_modal` and
+  `FXDialogBox#execute_nonmodal` methods for
+  examples of their use.
+
+* The attribute setters for
+  `FXRealSpinner#selBackColor` and
+  `FXSpinner#selBackColor` were defined
+  incorrectly (see RubyForge
+  Bug #1297). These have been corrected. Thanks to Meinrad
+  Recheis for reporting this problem.
+
+* The `tooltipPause` attribute reader for
+  the `FXApp` class was missing (see RubyForge
+  Patch #1306). Thanks to Joel VanderWerf for reporting this
+  omission and providing a patch to fix it.
+
+* The API documentation for the
+  `FXToolBarTab` class was missing (see RubyForge
+  Bug #1322). Thanks to Joel VanderWerf for reporting this
+  omission.
+
+* The attribute accessors for
+  `FXText#visibleRows` and
+  `FXText#visibleColumns` were defined and
+  documented incorrectly (see RubyForge
+  Bug #1325). These have been corrected. Thanks to Karl El-Koura
+  for reporting this problem.
+
+* The binary gem for Windows was built with FOX version 1.2.13 and
+  FXScintilla version 1.62.
+
+
+## Changes For Version 1.2.2 (October 1, 2004)
+
+* In order to avoid versioning problems when dealing with a mix of
+  applications based on either FXRuby 1.0 or 1.2, the feature name for
+  FXRuby has been changed from "fox" to "fox12". For most application
+  developers, this means that you will need to modify the source code
+  for applications targeted at FXRuby 1.2 to begin with the line
+  ´require 'fox12'´Note that no
+  changes should be required for legacy applications targeted at FXRuby
+  1.0.
+
+* Made a number of updates to the documentation, to reflect API
+  changes for FXRuby 1.2.
+
+* The binary gem for Windows was built with FOX version 1.2.9 and
+  FXScintilla version 1.61.
+
+
+## Changes For Version 1.2a2 (July 10, 2004)
+
+* This is the second "alpha" release of FXRuby 1.2. This release
+  should be compatible with any FOX library version 1.2; it is not
+  compatible with any previous FOX library versions. As this is an alpha
+  release, users should expect a certain amount of instability, bugs,
+  etc.
+
+* For this release, all of the FOX 1.2 classes are available with
+  the exception of the `FXBitmapView` class. There
+  is a small problem with how the `FXBitmapView`
+  class is declared in the FOX 1.2 header files, and I'm trying to
+  decide how best to resolve that problem. The goal is to have this
+  problem resolved by the next alpha release of FXRuby.
+
+* For this release, all of the RDoc-based online documentation has
+  been brought up to date with the new APIs.
+
+* Portions of the FXRuby User's Guide were still out of date with
+  respect to the new APIs (see SourceForge Bug #988623). This has been fixed.
+
+* The `mditest.rb` example program was not up
+  to date with the new APIs. This has been fixed.
+
+* The `glviewer.rb` example program was not up
+  to date with the new APIs (see SourceForge Bug #986479). This has been fixed. Thanks to Remy Drouilhet
+  for reporting this problem and suggesting the fixes.
+
+* The `FXGLGroup#bounds` method was defined
+  incorrectly (see SourceForge Bug #986476). This has been fixed. Thanks to Remy Drouilhet
+  for reporting this problem and suggesting the fix.
+
+* The `scintilla-test.rb` example program was
+  not up to date with the new APIs (see SourceForge Bug #986172). This has been fixed. Thanks to Peter Watkins for
+  reporting this problem and submitting a corrected version of the
+  program.
+
+* There was a small typo in the table.rb example program (see
+  SourceForge Bug #988152). This has been fixed. Thanks to Jamey Cribbs for
+  reporting this problem and suggesting the fix.
+
+* Due to an oversight on my part, one of the overloaded
+  constructors for the `FXRegion` class wasn't
+  wrapped properly (see SourceForge Bug #986181). This has been fixed. Thanks to Bil Bas for
+  reporting this problem.
+
+* Removed some obsolete aliases for the old leading and trailing
+  rows and columns for the `FXTable` class (see
+  SourceForge Bug #988038). Thanks to Yuri Leikind for reporting this
+  problem.
+
+* Added `FXTable` instance methods
+  `horizontalGridShown=()` and
+  `verticalGridShown=()` to complement the
+  already available `horizontalGridShown?` and
+  `verticalGridShown?` methods.
+
+* The binary gem for the 1.2a1 release on Windows didn't have PNG
+  or JPEG image support built-in (see SourceForge Bug #986180). This has been fixed. Thanks to Bil Bas for
+  reporting this problem.
+
+* The binary gem for Windows was built with FOX version 1.2.7 and
+  FXScintilla version 1.61.
+
+
+## Changes For Version 1.2a1 (June 28, 2004)
+
+* This is the first "alpha" release of FXRuby 1.2. This release
+  should be compatible with any FOX library version 1.2; it is not
+  compatible with any previous FOX library versions. As this is an alpha
+  release, users should expect a certain amount of instability, bugs,
+  etc.
+  The intent of this first alpha release is twofold. The primary
+  intent is allow application developers who have current projects based
+  on FXRuby 1.0 to begin the process of updating their applications for
+  compatibility with FXRuby 1.2. For this release, all of the classes
+  that existed in FXRuby 1.0 have been updated for compatibility with
+  FOX 1.2, and so developers should at least be able to begin to "port"
+  their applications forward now. Note that there have been a number of
+  changes for FOX 1.2 and FXRuby 1.2, both in terms of API changes and
+  less obvious "behavioral" changes. For a detailed summary of these
+  changes, please see "What's New in FOX 1.2" (also available as a PDF).
+  Note that few, if any, of the new classes introduced in FOX 1.2 are
+  available in this first alpha release of FXRuby 1.2. Support for those
+  new classes should come along quickly in subsequent alpha releases of
+  FXRuby 1.2.
+  The secondary intent of this first alpha release is to introduce
+  the new RubyGems-based packaging
+  of FXRuby and to begin to work out the inevitable kinks in that
+  system.
+
+* The binary gem for Windows was built with FOX version 1.2.4 and
+  FXScintilla version 1.57.
+
diff --git a/History.txt b/History.txt
deleted file mode 100755
index 0a10a0e0..00000000
--- a/History.txt
+++ /dev/null
@@ -1,73 +0,0 @@
-=== 1.6.29 / 2015-02-17
-
-* Add Windows binaries for Ruby-2.1 and 2.2.
-* Use shared libs for Windows binary gems to reduce gem size.
-* Allow non owned assignment of image data to FXImage derivations
-  without copy'ing pixel data.
-* Allow retrival of parts of the pixel data.
-* Fix namespace specifier for FXRGB in kwargs.rb.
-* Change GC'ing of TreeListBox and FXTreeItem. Fixes #10
-* Update to swig version 2.0 or newer. Fixes #13
-
-=== 1.6.28 / 2013-07-05
-
-* Fix build for Ruby-2.0.0-p127+
-* Update libraries for win32 build: libfox-1.6.49
-
-=== 1.6.27 / 2013-04-05
-
-* Add support for Ruby-2.0.
-* Add cross compilation for x64-mingw32 target.
-
-=== 1.6.26 / 2013-02-16
-
-* Mark all text strings retrieved from fox as UTF-8 when running on Ruby 1.9
-* Fix loading error on Ruby 1.8.7 by renaming the C++ extension to fox16_c
-* Update libraries for windows cross compilation
-
-=== 1.6.25 / 2012-06-17
-
-* Windows: Fix slow loading of fox16.so by using a more recent mingw-w64 compiler
-  (reported by Allen Doug and Igor Jorobus)
-* Fix two possible segfaults in conjunction with FXSplashWindow (reported by Igor Jorobus)
-
-=== 1.6.24 / 2012-06-06
-
-* Update libraries for win32 build: libz-1.2.7 libpng-1.5.10 libjpeg-8d libtiff-4.0.1 libfox-1.6.45
-* Avoid Segfauls in lots of methods when called with nil instead of FXApp, FXComposite or FXWindow objects
-
-=== 1.6.23 / 2012-03-08
-
-* Add YARD documentation support
-* Use generated Manifest.txt
-* Support for parallel task execution with drake
-
-=== 1.6.22 / 2012-02-21
-
-* Allow better access to raw pixel data of FXImage and derivatives
-* Build Windows binary gem per cross compiler on Linux
-* Add support for Rubinius (currently requires rubinius from git)
-* Add alias FXApp#modalWindow, as described in rdoc
-* Add quality parameter to FXJPGImage and FXJPGIcon
-* Fix invalid memory access in final GC call when using FXMenuCommand with acckey
-* Fix double referenced foxObj when borrowed object registration is triggered from C++
-* Fix Segfault while GC'ing FXWindows
-* Fix 'object allocation not allowed while garbage collection' bug
-* Fix clipboard handling on windows
-* Add missing namespace qualifier to FXSEL in FXAccelTable
-* Fix GC bug in FXAccelTable
-* Fix double free in FXMemoryStream#giveBuffer
-* Fix invalid memory access in typemap to zero terminated FXchar* (such as fillItems methods)
-* Fix FXApp#addInput for Ruby 1.9 on Linux
-* Fix "ruby_code case not handled: Regexp" issue with newer rubygems
-
-=== 1.6.20 / 2009-03-06
-
-* Integrated the Hoe and rake-compiler extensions into the Rakefile and
-  removed redundant tasks.
-* Did some work to provide support for MinGW builds.
-
-=== 1.6.19 / 2009-03-06
-
-* Please see http://www.fxruby.org/doc/changes.html
-  for a complete list of the changes in this release.
diff --git a/Manifest.txt b/Manifest.txt
deleted file mode 100644
index 94d8f7db..00000000
--- a/Manifest.txt
+++ /dev/null
@@ -1,1214 +0,0 @@
-.gemtest
-.gitignore
-.yardopts
-History.txt
-Manifest.txt
-README.rdoc
-Rakefile
-TODO
-doap.rdf.erb
-examples/RAA.rb
-examples/README
-examples/WhatAQuietStiff.rb
-examples/babelfish.rb
-examples/bounce.rb
-examples/browser.rb
-examples/button.rb
-examples/canvasdemo.rb
-examples/charts.rb
-examples/custom_table_item.rb
-examples/datatarget.rb
-examples/dctest.rb
-examples/dialog.rb
-examples/dilbert.rb
-examples/dirlist.rb
-examples/dragdrop.rb
-examples/dragsource.rb
-examples/dropsite.rb
-examples/foursplit.rb
-examples/gdchart.rb
-examples/gembrowser.rb
-examples/gltest.rb
-examples/glviewer.rb
-examples/groupbox.rb
-examples/header.rb
-examples/hello.rb
-examples/hello2.rb
-examples/iRAA.rb
-examples/iconlist.rb
-examples/icons/AngryGuyInBunnySuit.ico
-examples/icons/FatBot.ico
-examples/icons/FlippedySwitch.ico
-examples/icons/LeGoon.ico
-examples/icons/Net.ico
-examples/icons/RedMacOS.ico
-examples/icons/SawBlade.ico
-examples/icons/backview.png
-examples/icons/big.png
-examples/icons/bigfolder.png
-examples/icons/bigpenguin.png
-examples/icons/bluebullet14x14.gif
-examples/icons/bottomview.png
-examples/icons/camera.png
-examples/icons/capbutt.png
-examples/icons/capnotlast.png
-examples/icons/capproj.png
-examples/icons/capround.png
-examples/icons/colorpal.png
-examples/icons/copy.png
-examples/icons/cut.png
-examples/icons/delimit.png
-examples/icons/dippy.png
-examples/icons/double_dash.png
-examples/icons/filenew.png
-examples/icons/fileopen.png
-examples/icons/filesave.png
-examples/icons/filesaveas.png
-examples/icons/fonts.png
-examples/icons/fox.png
-examples/icons/foxicon.png
-examples/icons/frontview.png
-examples/icons/gem_big.png
-examples/icons/gem_small.png
-examples/icons/hello2.png
-examples/icons/help.png
-examples/icons/indent.png
-examples/icons/jbevel.png
-examples/icons/jmiter.png
-examples/icons/jround.png
-examples/icons/kill.png
-examples/icons/leftview.png
-examples/icons/light.png
-examples/icons/minidoc.png
-examples/icons/minifolder.png
-examples/icons/minifolderopen.png
-examples/icons/newfolder.png
-examples/icons/nolight.png
-examples/icons/onoff_dash.png
-examples/icons/palette.png
-examples/icons/parallel.png
-examples/icons/paste.png
-examples/icons/pattern.png
-examples/icons/penguin.png
-examples/icons/perspective.png
-examples/icons/printicon.png
-examples/icons/prop.png
-examples/icons/redo.png
-examples/icons/rightview.png
-examples/icons/saveas.png
-examples/icons/shutter1.png
-examples/icons/shutter2.png
-examples/icons/small.png
-examples/icons/smoothlight.png
-examples/icons/solid_line.png
-examples/icons/tbuplevel.png
-examples/icons/topview.png
-examples/icons/transpbullet14x14.gif
-examples/icons/undo.png
-examples/icons/winapp.png
-examples/icons/zoom.png
-examples/image.rb
-examples/imageviewer.rb
-examples/inputs.rb
-examples/mditest.rb
-examples/pig.rb
-examples/raabrowser.rb
-examples/ratio.rb
-examples/rmagick.rb
-examples/rulerview.rb
-examples/scintilla-test.rb
-examples/scribble-orig.rb
-examples/scribble.rb
-examples/shutter.rb
-examples/splitter.rb
-examples/styledtext.rb
-examples/tabbook.rb
-examples/table.rb
-examples/textedit/commands.rb
-examples/textedit/helpwindow.rb
-examples/textedit/prefdialog.rb
-examples/textedit/textedit.rb
-examples/unicode.rb
-ext/fox16_c/FXRbApp.cpp
-ext/fox16_c/FXRbDataTarget.cpp
-ext/fox16_c/FXRbGLViewer.cpp
-ext/fox16_c/FXRuby.cpp
-ext/fox16_c/MANIFEST
-ext/fox16_c/extconf.rb
-ext/fox16_c/impl.cpp
-ext/fox16_c/include/FXMemoryBuffer.h
-ext/fox16_c/include/FXRb4Splitter.h
-ext/fox16_c/include/FXRb7Segment.h
-ext/fox16_c/include/FXRbAccelTable.h
-ext/fox16_c/include/FXRbApp.h
-ext/fox16_c/include/FXRbAppVirtuals.h
-ext/fox16_c/include/FXRbArrowButton.h
-ext/fox16_c/include/FXRbBMPIcon.h
-ext/fox16_c/include/FXRbBMPImage.h
-ext/fox16_c/include/FXRbBitmap.h
-ext/fox16_c/include/FXRbBitmapFrame.h
-ext/fox16_c/include/FXRbBitmapView.h
-ext/fox16_c/include/FXRbBitmapVirtuals.h
-ext/fox16_c/include/FXRbButton.h
-ext/fox16_c/include/FXRbCURCursor.h
-ext/fox16_c/include/FXRbCanvas.h
-ext/fox16_c/include/FXRbCheckButton.h
-ext/fox16_c/include/FXRbChoiceBox.h
-ext/fox16_c/include/FXRbColorBar.h
-ext/fox16_c/include/FXRbColorDialog.h
-ext/fox16_c/include/FXRbColorList.h
-ext/fox16_c/include/FXRbColorRing.h
-ext/fox16_c/include/FXRbColorSelector.h
-ext/fox16_c/include/FXRbColorWell.h
-ext/fox16_c/include/FXRbColorWheel.h
-ext/fox16_c/include/FXRbComboBox.h
-ext/fox16_c/include/FXRbCommon.h
-ext/fox16_c/include/FXRbComposite.h
-ext/fox16_c/include/FXRbCursor.h
-ext/fox16_c/include/FXRbCursorVirtuals.h
-ext/fox16_c/include/FXRbDC.h
-ext/fox16_c/include/FXRbDCPrint.h
-ext/fox16_c/include/FXRbDCVirtuals.h
-ext/fox16_c/include/FXRbDCWindow.h
-ext/fox16_c/include/FXRbDataTarget.h
-ext/fox16_c/include/FXRbDebugTarget.h
-ext/fox16_c/include/FXRbDelegator.h
-ext/fox16_c/include/FXRbDial.h
-ext/fox16_c/include/FXRbDialogBox.h
-ext/fox16_c/include/FXRbDialogBoxVirtuals.h
-ext/fox16_c/include/FXRbDict.h
-ext/fox16_c/include/FXRbDirBox.h
-ext/fox16_c/include/FXRbDirDialog.h
-ext/fox16_c/include/FXRbDirList.h
-ext/fox16_c/include/FXRbDirSelector.h
-ext/fox16_c/include/FXRbDockBar.h
-ext/fox16_c/include/FXRbDockBarVirtuals.h
-ext/fox16_c/include/FXRbDockHandler.h
-ext/fox16_c/include/FXRbDockSite.h
-ext/fox16_c/include/FXRbDockSiteVirtuals.h
-ext/fox16_c/include/FXRbDockTitle.h
-ext/fox16_c/include/FXRbDocument.h
-ext/fox16_c/include/FXRbDragCorner.h
-ext/fox16_c/include/FXRbDrawable.h
-ext/fox16_c/include/FXRbDrawableVirtuals.h
-ext/fox16_c/include/FXRbDriveBox.h
-ext/fox16_c/include/FXRbFileDialog.h
-ext/fox16_c/include/FXRbFileDict.h
-ext/fox16_c/include/FXRbFileDictVirtuals.h
-ext/fox16_c/include/FXRbFileList.h
-ext/fox16_c/include/FXRbFileSelector.h
-ext/fox16_c/include/FXRbFoldingItemVirtuals.h
-ext/fox16_c/include/FXRbFoldingList.h
-ext/fox16_c/include/FXRbFoldingListVirtuals.h
-ext/fox16_c/include/FXRbFont.h
-ext/fox16_c/include/FXRbFontDialog.h
-ext/fox16_c/include/FXRbFontSelector.h
-ext/fox16_c/include/FXRbFontVirtuals.h
-ext/fox16_c/include/FXRbFrame.h
-ext/fox16_c/include/FXRbGIFCursor.h
-ext/fox16_c/include/FXRbGIFIcon.h
-ext/fox16_c/include/FXRbGIFImage.h
-ext/fox16_c/include/FXRbGLCanvas.h
-ext/fox16_c/include/FXRbGLCanvasVirtuals.h
-ext/fox16_c/include/FXRbGLContext.h
-ext/fox16_c/include/FXRbGLObject.h
-ext/fox16_c/include/FXRbGLObjectVirtuals.h
-ext/fox16_c/include/FXRbGLShape.h
-ext/fox16_c/include/FXRbGLShapeVirtuals.h
-ext/fox16_c/include/FXRbGLViewer.h
-ext/fox16_c/include/FXRbGLViewerVirtuals.h
-ext/fox16_c/include/FXRbGLVisual.h
-ext/fox16_c/include/FXRbGradientBar.h
-ext/fox16_c/include/FXRbGroupBox.h
-ext/fox16_c/include/FXRbHeader.h
-ext/fox16_c/include/FXRbHeaderItemVirtuals.h
-ext/fox16_c/include/FXRbHorizontalFrame.h
-ext/fox16_c/include/FXRbICOIcon.h
-ext/fox16_c/include/FXRbICOImage.h
-ext/fox16_c/include/FXRbIcon.h
-ext/fox16_c/include/FXRbIconItemVirtuals.h
-ext/fox16_c/include/FXRbIconList.h
-ext/fox16_c/include/FXRbIconListVirtuals.h
-ext/fox16_c/include/FXRbIconSource.h
-ext/fox16_c/include/FXRbIconSourceVirtuals.h
-ext/fox16_c/include/FXRbId.h
-ext/fox16_c/include/FXRbIdVirtuals.h
-ext/fox16_c/include/FXRbImage.h
-ext/fox16_c/include/FXRbImageFrame.h
-ext/fox16_c/include/FXRbImageView.h
-ext/fox16_c/include/FXRbImageVirtuals.h
-ext/fox16_c/include/FXRbInputDialog.h
-ext/fox16_c/include/FXRbJPGIcon.h
-ext/fox16_c/include/FXRbJPGImage.h
-ext/fox16_c/include/FXRbKnob.h
-ext/fox16_c/include/FXRbLabel.h
-ext/fox16_c/include/FXRbList.h
-ext/fox16_c/include/FXRbListBox.h
-ext/fox16_c/include/FXRbListBoxVirtuals.h
-ext/fox16_c/include/FXRbListItemVirtuals.h
-ext/fox16_c/include/FXRbListVirtuals.h
-ext/fox16_c/include/FXRbMDIButton.h
-ext/fox16_c/include/FXRbMDIChild.h
-ext/fox16_c/include/FXRbMDIChildVirtuals.h
-ext/fox16_c/include/FXRbMDIClient.h
-ext/fox16_c/include/FXRbMDIClientVirtuals.h
-ext/fox16_c/include/FXRbMainWindow.h
-ext/fox16_c/include/FXRbMatrix.h
-ext/fox16_c/include/FXRbMenuBar.h
-ext/fox16_c/include/FXRbMenuButton.h
-ext/fox16_c/include/FXRbMenuCaption.h
-ext/fox16_c/include/FXRbMenuCascade.h
-ext/fox16_c/include/FXRbMenuCheck.h
-ext/fox16_c/include/FXRbMenuCommand.h
-ext/fox16_c/include/FXRbMenuPane.h
-ext/fox16_c/include/FXRbMenuRadio.h
-ext/fox16_c/include/FXRbMenuSeparator.h
-ext/fox16_c/include/FXRbMenuTitle.h
-ext/fox16_c/include/FXRbMessageBox.h
-ext/fox16_c/include/FXRbObject.h
-ext/fox16_c/include/FXRbObjectVirtuals.h
-ext/fox16_c/include/FXRbOptionMenu.h
-ext/fox16_c/include/FXRbPCXIcon.h
-ext/fox16_c/include/FXRbPCXImage.h
-ext/fox16_c/include/FXRbPNGIcon.h
-ext/fox16_c/include/FXRbPNGImage.h
-ext/fox16_c/include/FXRbPPMIcon.h
-ext/fox16_c/include/FXRbPPMImage.h
-ext/fox16_c/include/FXRbPacker.h
-ext/fox16_c/include/FXRbPicker.h
-ext/fox16_c/include/FXRbPopup.h
-ext/fox16_c/include/FXRbPopupVirtuals.h
-ext/fox16_c/include/FXRbPrintDialog.h
-ext/fox16_c/include/FXRbProgressBar.h
-ext/fox16_c/include/FXRbProgressDialog.h
-ext/fox16_c/include/FXRbRGBIcon.h
-ext/fox16_c/include/FXRbRGBImage.h
-ext/fox16_c/include/FXRbRadioButton.h
-ext/fox16_c/include/FXRbRealSlider.h
-ext/fox16_c/include/FXRbRealSpinner.h
-ext/fox16_c/include/FXRbRealSpinnerVirtuals.h
-ext/fox16_c/include/FXRbRecentFiles.h
-ext/fox16_c/include/FXRbRegistry.h
-ext/fox16_c/include/FXRbReplaceDialog.h
-ext/fox16_c/include/FXRbRootWindow.h
-ext/fox16_c/include/FXRbRuler.h
-ext/fox16_c/include/FXRbRulerView.h
-ext/fox16_c/include/FXRbScintilla.h
-ext/fox16_c/include/FXRbScrollArea.h
-ext/fox16_c/include/FXRbScrollAreaVirtuals.h
-ext/fox16_c/include/FXRbScrollBar.h
-ext/fox16_c/include/FXRbScrollPane.h
-ext/fox16_c/include/FXRbScrollWindow.h
-ext/fox16_c/include/FXRbSearchDialog.h
-ext/fox16_c/include/FXRbSeparator.h
-ext/fox16_c/include/FXRbSettings.h
-ext/fox16_c/include/FXRbShell.h
-ext/fox16_c/include/FXRbShutter.h
-ext/fox16_c/include/FXRbShutterVirtuals.h
-ext/fox16_c/include/FXRbSlider.h
-ext/fox16_c/include/FXRbSpinner.h
-ext/fox16_c/include/FXRbSpinnerVirtuals.h
-ext/fox16_c/include/FXRbSplashWindow.h
-ext/fox16_c/include/FXRbSplitter.h
-ext/fox16_c/include/FXRbSpring.h
-ext/fox16_c/include/FXRbStatusBar.h
-ext/fox16_c/include/FXRbStatusLine.h
-ext/fox16_c/include/FXRbStream.h
-ext/fox16_c/include/FXRbStreamVirtuals.h
-ext/fox16_c/include/FXRbStringDict.h
-ext/fox16_c/include/FXRbSwitcher.h
-ext/fox16_c/include/FXRbTGAIcon.h
-ext/fox16_c/include/FXRbTGAImage.h
-ext/fox16_c/include/FXRbTIFIcon.h
-ext/fox16_c/include/FXRbTIFImage.h
-ext/fox16_c/include/FXRbTabBar.h
-ext/fox16_c/include/FXRbTabBarVirtuals.h
-ext/fox16_c/include/FXRbTabBook.h
-ext/fox16_c/include/FXRbTabItem.h
-ext/fox16_c/include/FXRbTable.h
-ext/fox16_c/include/FXRbTableItemVirtuals.h
-ext/fox16_c/include/FXRbTableVirtuals.h
-ext/fox16_c/include/FXRbText.h
-ext/fox16_c/include/FXRbTextField.h
-ext/fox16_c/include/FXRbTextVirtuals.h
-ext/fox16_c/include/FXRbToggleButton.h
-ext/fox16_c/include/FXRbToolBar.h
-ext/fox16_c/include/FXRbToolBarGrip.h
-ext/fox16_c/include/FXRbToolBarShell.h
-ext/fox16_c/include/FXRbToolBarTab.h
-ext/fox16_c/include/FXRbToolTip.h
-ext/fox16_c/include/FXRbTopWindow.h
-ext/fox16_c/include/FXRbTopWindowVirtuals.h
-ext/fox16_c/include/FXRbTranslator.h
-ext/fox16_c/include/FXRbTranslatorVirtuals.h
-ext/fox16_c/include/FXRbTreeItemVirtuals.h
-ext/fox16_c/include/FXRbTreeList.h
-ext/fox16_c/include/FXRbTreeListBox.h
-ext/fox16_c/include/FXRbTreeListBoxVirtuals.h
-ext/fox16_c/include/FXRbTreeListVirtuals.h
-ext/fox16_c/include/FXRbTriStateButton.h
-ext/fox16_c/include/FXRbVerticalFrame.h
-ext/fox16_c/include/FXRbVisual.h
-ext/fox16_c/include/FXRbWindow.h
-ext/fox16_c/include/FXRbWindowVirtuals.h
-ext/fox16_c/include/FXRbWizard.h
-ext/fox16_c/include/FXRbXBMIcon.h
-ext/fox16_c/include/FXRbXBMImage.h
-ext/fox16_c/include/FXRbXPMIcon.h
-ext/fox16_c/include/FXRbXPMImage.h
-ext/fox16_c/include/FXRuby.h
-ext/fox16_c/include/impl.h
-ext/fox16_c/make_impl.rb
-ext/fox16_c/markfuncs.cpp
-ext/fox16_c/unregisterOwnedObjects.cpp
-fox-includes/FX4Splitter.h
-fox-includes/FX7Segment.h
-fox-includes/FX885910Codec.h
-fox-includes/FX885911Codec.h
-fox-includes/FX885913Codec.h
-fox-includes/FX885914Codec.h
-fox-includes/FX885915Codec.h
-fox-includes/FX885916Codec.h
-fox-includes/FX88591Codec.h
-fox-includes/FX88592Codec.h
-fox-includes/FX88593Codec.h
-fox-includes/FX88594Codec.h
-fox-includes/FX88595Codec.h
-fox-includes/FX88596Codec.h
-fox-includes/FX88597Codec.h
-fox-includes/FX88598Codec.h
-fox-includes/FX88599Codec.h
-fox-includes/FXAccelTable.h
-fox-includes/FXApp.h
-fox-includes/FXArray.h
-fox-includes/FXArrowButton.h
-fox-includes/FXBMPIcon.h
-fox-includes/FXBMPImage.h
-fox-includes/FXBZFileStream.h
-fox-includes/FXBitmap.h
-fox-includes/FXBitmapFrame.h
-fox-includes/FXBitmapView.h
-fox-includes/FXButton.h
-fox-includes/FXCP1250Codec.h
-fox-includes/FXCP1251Codec.h
-fox-includes/FXCP1252Codec.h
-fox-includes/FXCP1253Codec.h
-fox-includes/FXCP1254Codec.h
-fox-includes/FXCP1255Codec.h
-fox-includes/FXCP1256Codec.h
-fox-includes/FXCP1257Codec.h
-fox-includes/FXCP1258Codec.h
-fox-includes/FXCP437Codec.h
-fox-includes/FXCP850Codec.h
-fox-includes/FXCP852Codec.h
-fox-includes/FXCP855Codec.h
-fox-includes/FXCP856Codec.h
-fox-includes/FXCP857Codec.h
-fox-includes/FXCP860Codec.h
-fox-includes/FXCP861Codec.h
-fox-includes/FXCP862Codec.h
-fox-includes/FXCP863Codec.h
-fox-includes/FXCP864Codec.h
-fox-includes/FXCP865Codec.h
-fox-includes/FXCP866Codec.h
-fox-includes/FXCP869Codec.h
-fox-includes/FXCP874Codec.h
-fox-includes/FXCURCursor.h
-fox-includes/FXCanvas.h
-fox-includes/FXCheckButton.h
-fox-includes/FXChoiceBox.h
-fox-includes/FXColorBar.h
-fox-includes/FXColorDialog.h
-fox-includes/FXColorList.h
-fox-includes/FXColorRing.h
-fox-includes/FXColorSelector.h
-fox-includes/FXColorWell.h
-fox-includes/FXColorWheel.h
-fox-includes/FXComboBox.h
-fox-includes/FXComposeContext.h
-fox-includes/FXComposite.h
-fox-includes/FXCursor.h
-fox-includes/FXDC.h
-fox-includes/FXDCPrint.h
-fox-includes/FXDCWindow.h
-fox-includes/FXDLL.h
-fox-includes/FXDataTarget.h
-fox-includes/FXDate.h
-fox-includes/FXDebugTarget.h
-fox-includes/FXDelegator.h
-fox-includes/FXDial.h
-fox-includes/FXDialogBox.h
-fox-includes/FXDict.h
-fox-includes/FXDir.h
-fox-includes/FXDirBox.h
-fox-includes/FXDirDialog.h
-fox-includes/FXDirList.h
-fox-includes/FXDirSelector.h
-fox-includes/FXDockBar.h
-fox-includes/FXDockHandler.h
-fox-includes/FXDockSite.h
-fox-includes/FXDockTitle.h
-fox-includes/FXDocument.h
-fox-includes/FXDragCorner.h
-fox-includes/FXDrawable.h
-fox-includes/FXDriveBox.h
-fox-includes/FXElement.h
-fox-includes/FXException.h
-fox-includes/FXExpression.h
-fox-includes/FXExtentd.h
-fox-includes/FXExtentf.h
-fox-includes/FXFile.h
-fox-includes/FXFileDialog.h
-fox-includes/FXFileDict.h
-fox-includes/FXFileList.h
-fox-includes/FXFileSelector.h
-fox-includes/FXFileStream.h
-fox-includes/FXFoldingList.h
-fox-includes/FXFont.h
-fox-includes/FXFontDialog.h
-fox-includes/FXFontSelector.h
-fox-includes/FXFrame.h
-fox-includes/FXGIFCursor.h
-fox-includes/FXGIFIcon.h
-fox-includes/FXGIFImage.h
-fox-includes/FXGLCanvas.h
-fox-includes/FXGLCone.h
-fox-includes/FXGLContext.h
-fox-includes/FXGLCube.h
-fox-includes/FXGLCylinder.h
-fox-includes/FXGLObject.h
-fox-includes/FXGLShape.h
-fox-includes/FXGLSphere.h
-fox-includes/FXGLTriangleMesh.h
-fox-includes/FXGLViewer.h
-fox-includes/FXGLVisual.h
-fox-includes/FXGUISignal.h
-fox-includes/FXGZFileStream.h
-fox-includes/FXGradientBar.h
-fox-includes/FXGroupBox.h
-fox-includes/FXHash.h
-fox-includes/FXHeader.h
-fox-includes/FXHorizontalFrame.h
-fox-includes/FXICOIcon.h
-fox-includes/FXICOImage.h
-fox-includes/FXIFFIcon.h
-fox-includes/FXIFFImage.h
-fox-includes/FXIO.h
-fox-includes/FXIcon.h
-fox-includes/FXIconDict.h
-fox-includes/FXIconList.h
-fox-includes/FXIconSource.h
-fox-includes/FXId.h
-fox-includes/FXImage.h
-fox-includes/FXImageFrame.h
-fox-includes/FXImageView.h
-fox-includes/FXInputDialog.h
-fox-includes/FXJPGIcon.h
-fox-includes/FXJPGImage.h
-fox-includes/FXKOI8RCodec.h
-fox-includes/FXKnob.h
-fox-includes/FXLabel.h
-fox-includes/FXList.h
-fox-includes/FXListBox.h
-fox-includes/FXMDIButton.h
-fox-includes/FXMDIChild.h
-fox-includes/FXMDIClient.h
-fox-includes/FXMainWindow.h
-fox-includes/FXMat3d.h
-fox-includes/FXMat3f.h
-fox-includes/FXMat4d.h
-fox-includes/FXMat4f.h
-fox-includes/FXMatrix.h
-fox-includes/FXMemMap.h
-fox-includes/FXMemoryStream.h
-fox-includes/FXMenuBar.h
-fox-includes/FXMenuButton.h
-fox-includes/FXMenuCaption.h
-fox-includes/FXMenuCascade.h
-fox-includes/FXMenuCheck.h
-fox-includes/FXMenuCommand.h
-fox-includes/FXMenuPane.h
-fox-includes/FXMenuRadio.h
-fox-includes/FXMenuSeparator.h
-fox-includes/FXMenuTitle.h
-fox-includes/FXMessageBox.h
-fox-includes/FXObject.h
-fox-includes/FXObjectList.h
-fox-includes/FXOptionMenu.h
-fox-includes/FXPCXIcon.h
-fox-includes/FXPCXImage.h
-fox-includes/FXPNGIcon.h
-fox-includes/FXPNGImage.h
-fox-includes/FXPPMIcon.h
-fox-includes/FXPPMImage.h
-fox-includes/FXPacker.h
-fox-includes/FXPath.h
-fox-includes/FXPicker.h
-fox-includes/FXPipe.h
-fox-includes/FXPoint.h
-fox-includes/FXPopup.h
-fox-includes/FXPrintDialog.h
-fox-includes/FXProgressBar.h
-fox-includes/FXProgressDialog.h
-fox-includes/FXQuatd.h
-fox-includes/FXQuatf.h
-fox-includes/FXRASIcon.h
-fox-includes/FXRASImage.h
-fox-includes/FXRGBIcon.h
-fox-includes/FXRGBImage.h
-fox-includes/FXRadioButton.h
-fox-includes/FXRanged.h
-fox-includes/FXRangef.h
-fox-includes/FXRealSlider.h
-fox-includes/FXRealSpinner.h
-fox-includes/FXRecentFiles.h
-fox-includes/FXRectangle.h
-fox-includes/FXRegion.h
-fox-includes/FXRegistry.h
-fox-includes/FXReplaceDialog.h
-fox-includes/FXRex.h
-fox-includes/FXRootWindow.h
-fox-includes/FXRuler.h
-fox-includes/FXRulerView.h
-fox-includes/FXScrollArea.h
-fox-includes/FXScrollBar.h
-fox-includes/FXScrollPane.h
-fox-includes/FXScrollWindow.h
-fox-includes/FXSearchDialog.h
-fox-includes/FXSeparator.h
-fox-includes/FXSettings.h
-fox-includes/FXShell.h
-fox-includes/FXShutter.h
-fox-includes/FXSize.h
-fox-includes/FXSlider.h
-fox-includes/FXSocket.h
-fox-includes/FXSphered.h
-fox-includes/FXSpheref.h
-fox-includes/FXSpinner.h
-fox-includes/FXSplashWindow.h
-fox-includes/FXSplitter.h
-fox-includes/FXSpring.h
-fox-includes/FXStat.h
-fox-includes/FXStatusBar.h
-fox-includes/FXStatusLine.h
-fox-includes/FXStream.h
-fox-includes/FXString.h
-fox-includes/FXStringDict.h
-fox-includes/FXSwitcher.h
-fox-includes/FXSystem.h
-fox-includes/FXTGAIcon.h
-fox-includes/FXTGAImage.h
-fox-includes/FXTIFIcon.h
-fox-includes/FXTIFImage.h
-fox-includes/FXTabBar.h
-fox-includes/FXTabBook.h
-fox-includes/FXTabItem.h
-fox-includes/FXTable.h
-fox-includes/FXText.h
-fox-includes/FXTextCodec.h
-fox-includes/FXTextField.h
-fox-includes/FXThread.h
-fox-includes/FXToggleButton.h
-fox-includes/FXToolBar.h
-fox-includes/FXToolBarGrip.h
-fox-includes/FXToolBarShell.h
-fox-includes/FXToolBarTab.h
-fox-includes/FXToolTip.h
-fox-includes/FXTopWindow.h
-fox-includes/FXTranslator.h
-fox-includes/FXTreeList.h
-fox-includes/FXTreeListBox.h
-fox-includes/FXTriStateButton.h
-fox-includes/FXURL.h
-fox-includes/FXUTF16Codec.h
-fox-includes/FXUTF32Codec.h
-fox-includes/FXUTF8Codec.h
-fox-includes/FXUndoList.h
-fox-includes/FXVec2d.h
-fox-includes/FXVec2f.h
-fox-includes/FXVec3d.h
-fox-includes/FXVec3f.h
-fox-includes/FXVec4d.h
-fox-includes/FXVec4f.h
-fox-includes/FXVerticalFrame.h
-fox-includes/FXVisual.h
-fox-includes/FXWindow.h
-fox-includes/FXWizard.h
-fox-includes/FXXBMIcon.h
-fox-includes/FXXBMImage.h
-fox-includes/FXXPMIcon.h
-fox-includes/FXXPMImage.h
-fox-includes/README
-fox-includes/fx.h
-fox-includes/fx3d.h
-fox-includes/fxascii.h
-fox-includes/fxdefs.h
-fox-includes/fxkeys.h
-fox-includes/fxunicode.h
-fox-includes/fxver.h
-fox-includes/xincs.h
-index.html
-lib/fox16.rb
-lib/fox16/accel_table.rb
-lib/fox16/aliases.rb
-lib/fox16/bitmapview.rb
-lib/fox16/calendar.rb
-lib/fox16/canvas.rb
-lib/fox16/chore.rb
-lib/fox16/colors.rb
-lib/fox16/core.rb
-lib/fox16/dict.rb
-lib/fox16/exceptions_for_fxerror.rb
-lib/fox16/execute_nonmodal.rb
-lib/fox16/glgroup.rb
-lib/fox16/glshapes.rb
-lib/fox16/input.rb
-lib/fox16/irb.rb
-lib/fox16/iterators.rb
-lib/fox16/keys.rb
-lib/fox16/missingdep.rb
-lib/fox16/pseudokeyboard.rb
-lib/fox16/pseudomouse.rb
-lib/fox16/responder.rb
-lib/fox16/responder2.rb
-lib/fox16/scintilla.rb
-lib/fox16/settings.rb
-lib/fox16/signal.rb
-lib/fox16/splashscreen.rb
-lib/fox16/timeout.rb
-lib/fox16/tkcompat.rb
-lib/fox16/undolist.rb
-lib/fox16/version.rb
-rdoc-sources/FX4Splitter.rb
-rdoc-sources/FX7Segment.rb
-rdoc-sources/FXAccelTable.rb
-rdoc-sources/FXApp.rb
-rdoc-sources/FXArrowButton.rb
-rdoc-sources/FXBMPIcon.rb
-rdoc-sources/FXBMPImage.rb
-rdoc-sources/FXBitmap.rb
-rdoc-sources/FXBitmapFrame.rb
-rdoc-sources/FXBitmapView.rb
-rdoc-sources/FXButton.rb
-rdoc-sources/FXCURCursor.rb
-rdoc-sources/FXCanvas.rb
-rdoc-sources/FXCheckButton.rb
-rdoc-sources/FXChoiceBox.rb
-rdoc-sources/FXColorBar.rb
-rdoc-sources/FXColorDialog.rb
-rdoc-sources/FXColorList.rb
-rdoc-sources/FXColorRing.rb
-rdoc-sources/FXColorSelector.rb
-rdoc-sources/FXColorWell.rb
-rdoc-sources/FXColorWheel.rb
-rdoc-sources/FXComboBox.rb
-rdoc-sources/FXComposite.rb
-rdoc-sources/FXCursor.rb
-rdoc-sources/FXDC.rb
-rdoc-sources/FXDCPrint.rb
-rdoc-sources/FXDCWindow.rb
-rdoc-sources/FXDataTarget.rb
-rdoc-sources/FXDebugTarget.rb
-rdoc-sources/FXDelegator.rb
-rdoc-sources/FXDial.rb
-rdoc-sources/FXDialogBox.rb
-rdoc-sources/FXDict.rb
-rdoc-sources/FXDirBox.rb
-rdoc-sources/FXDirDialog.rb
-rdoc-sources/FXDirList.rb
-rdoc-sources/FXDirSelector.rb
-rdoc-sources/FXDockBar.rb
-rdoc-sources/FXDockHandler.rb
-rdoc-sources/FXDockSite.rb
-rdoc-sources/FXDockTitle.rb
-rdoc-sources/FXDocument.rb
-rdoc-sources/FXDragCorner.rb
-rdoc-sources/FXDrawable.rb
-rdoc-sources/FXDriveBox.rb
-rdoc-sources/FXExtentd.rb
-rdoc-sources/FXExtentf.rb
-rdoc-sources/FXFileDialog.rb
-rdoc-sources/FXFileDict.rb
-rdoc-sources/FXFileList.rb
-rdoc-sources/FXFileSelector.rb
-rdoc-sources/FXFileStream.rb
-rdoc-sources/FXFoldingList.rb
-rdoc-sources/FXFont.rb
-rdoc-sources/FXFontDialog.rb
-rdoc-sources/FXFontSelector.rb
-rdoc-sources/FXFrame.rb
-rdoc-sources/FXGIFCursor.rb
-rdoc-sources/FXGIFIcon.rb
-rdoc-sources/FXGIFImage.rb
-rdoc-sources/FXGLCanvas.rb
-rdoc-sources/FXGLContext.rb
-rdoc-sources/FXGLObject.rb
-rdoc-sources/FXGLShape.rb
-rdoc-sources/FXGLViewer.rb
-rdoc-sources/FXGLVisual.rb
-rdoc-sources/FXGradientBar.rb
-rdoc-sources/FXGroupBox.rb
-rdoc-sources/FXHeader.rb
-rdoc-sources/FXHorizontalFrame.rb
-rdoc-sources/FXICOIcon.rb
-rdoc-sources/FXICOImage.rb
-rdoc-sources/FXIcon.rb
-rdoc-sources/FXIconDict.rb
-rdoc-sources/FXIconList.rb
-rdoc-sources/FXIconSource.rb
-rdoc-sources/FXId.rb
-rdoc-sources/FXImage.rb
-rdoc-sources/FXImageFrame.rb
-rdoc-sources/FXImageView.rb
-rdoc-sources/FXInputDialog.rb
-rdoc-sources/FXJPGIcon.rb
-rdoc-sources/FXJPGImage.rb
-rdoc-sources/FXKnob.rb
-rdoc-sources/FXLabel.rb
-rdoc-sources/FXList.rb
-rdoc-sources/FXListBox.rb
-rdoc-sources/FXMDIButton.rb
-rdoc-sources/FXMDIChild.rb
-rdoc-sources/FXMDIClient.rb
-rdoc-sources/FXMainWindow.rb
-rdoc-sources/FXMatrix.rb
-rdoc-sources/FXMemoryBuffer.rb
-rdoc-sources/FXMemoryStream.rb
-rdoc-sources/FXMenuBar.rb
-rdoc-sources/FXMenuButton.rb
-rdoc-sources/FXMenuCaption.rb
-rdoc-sources/FXMenuCascade.rb
-rdoc-sources/FXMenuCheck.rb
-rdoc-sources/FXMenuCommand.rb
-rdoc-sources/FXMenuPane.rb
-rdoc-sources/FXMenuRadio.rb
-rdoc-sources/FXMenuSeparator.rb
-rdoc-sources/FXMenuTitle.rb
-rdoc-sources/FXMessageBox.rb
-rdoc-sources/FXObject.rb
-rdoc-sources/FXOptionMenu.rb
-rdoc-sources/FXPCXIcon.rb
-rdoc-sources/FXPCXImage.rb
-rdoc-sources/FXPNGIcon.rb
-rdoc-sources/FXPNGImage.rb
-rdoc-sources/FXPPMIcon.rb
-rdoc-sources/FXPPMImage.rb
-rdoc-sources/FXPacker.rb
-rdoc-sources/FXPicker.rb
-rdoc-sources/FXPopup.rb
-rdoc-sources/FXPrintDialog.rb
-rdoc-sources/FXProgressBar.rb
-rdoc-sources/FXProgressDialog.rb
-rdoc-sources/FXQuatd.rb
-rdoc-sources/FXQuatf.rb
-rdoc-sources/FXRGBIcon.rb
-rdoc-sources/FXRGBImage.rb
-rdoc-sources/FXRadioButton.rb
-rdoc-sources/FXRanged.rb
-rdoc-sources/FXRangef.rb
-rdoc-sources/FXRealSlider.rb
-rdoc-sources/FXRealSpinner.rb
-rdoc-sources/FXRecentFiles.rb
-rdoc-sources/FXRectangle.rb
-rdoc-sources/FXRegion.rb
-rdoc-sources/FXRegistry.rb
-rdoc-sources/FXReplaceDialog.rb
-rdoc-sources/FXRootWindow.rb
-rdoc-sources/FXRuler.rb
-rdoc-sources/FXRulerView.rb
-rdoc-sources/FXScintilla.rb
-rdoc-sources/FXScrollArea.rb
-rdoc-sources/FXScrollBar.rb
-rdoc-sources/FXScrollPane.rb
-rdoc-sources/FXScrollWindow.rb
-rdoc-sources/FXSearchDialog.rb
-rdoc-sources/FXSeparator.rb
-rdoc-sources/FXSettings.rb
-rdoc-sources/FXShell.rb
-rdoc-sources/FXShutter.rb
-rdoc-sources/FXSize.rb
-rdoc-sources/FXSlider.rb
-rdoc-sources/FXSphered.rb
-rdoc-sources/FXSpheref.rb
-rdoc-sources/FXSpinner.rb
-rdoc-sources/FXSplashWindow.rb
-rdoc-sources/FXSplitter.rb
-rdoc-sources/FXSpring.rb
-rdoc-sources/FXStatusBar.rb
-rdoc-sources/FXStatusLine.rb
-rdoc-sources/FXStream.rb
-rdoc-sources/FXStringDict.rb
-rdoc-sources/FXSwitcher.rb
-rdoc-sources/FXTGAIcon.rb
-rdoc-sources/FXTGAImage.rb
-rdoc-sources/FXTIFIcon.rb
-rdoc-sources/FXTIFImage.rb
-rdoc-sources/FXTabBar.rb
-rdoc-sources/FXTabBook.rb
-rdoc-sources/FXTabItem.rb
-rdoc-sources/FXTable.rb
-rdoc-sources/FXText.rb
-rdoc-sources/FXTextField.rb
-rdoc-sources/FXToggleButton.rb
-rdoc-sources/FXToolBar.rb
-rdoc-sources/FXToolBarGrip.rb
-rdoc-sources/FXToolBarShell.rb
-rdoc-sources/FXToolBarTab.rb
-rdoc-sources/FXToolTip.rb
-rdoc-sources/FXTopWindow.rb
-rdoc-sources/FXTranslator.rb
-rdoc-sources/FXTreeList.rb
-rdoc-sources/FXTreeListBox.rb
-rdoc-sources/FXTriStateButton.rb
-rdoc-sources/FXVec2d.rb
-rdoc-sources/FXVec2f.rb
-rdoc-sources/FXVec3d.rb
-rdoc-sources/FXVec3f.rb
-rdoc-sources/FXVec4d.rb
-rdoc-sources/FXVec4f.rb
-rdoc-sources/FXVerticalFrame.rb
-rdoc-sources/FXVisual.rb
-rdoc-sources/FXWindow.rb
-rdoc-sources/FXWizard.rb
-rdoc-sources/FXXBMIcon.rb
-rdoc-sources/FXXBMImage.rb
-rdoc-sources/FXXPMIcon.rb
-rdoc-sources/FXXPMImage.rb
-rdoc-sources/Makefile
-rdoc-sources/README.rdoc
-rdoc-sources/fxdefs.rb
-scripts/build-fox.rb
-scripts/generate_kwargs_lib.rb
-scripts/iface.rb
-swig-interfaces/FX4Splitter.i
-swig-interfaces/FX7Segment.i
-swig-interfaces/FXAccelTable.i
-swig-interfaces/FXApp.i
-swig-interfaces/FXArrowButton.i
-swig-interfaces/FXBMPIcon.i
-swig-interfaces/FXBMPImage.i
-swig-interfaces/FXBitmap.i
-swig-interfaces/FXBitmapFrame.i
-swig-interfaces/FXBitmapView.i
-swig-interfaces/FXButton.i
-swig-interfaces/FXCURCursor.i
-swig-interfaces/FXCanvas.i
-swig-interfaces/FXCheckButton.i
-swig-interfaces/FXChoiceBox.i
-swig-interfaces/FXColorBar.i
-swig-interfaces/FXColorDialog.i
-swig-interfaces/FXColorList.i
-swig-interfaces/FXColorRing.i
-swig-interfaces/FXColorSelector.i
-swig-interfaces/FXColorWell.i
-swig-interfaces/FXColorWheel.i
-swig-interfaces/FXComboBox.i
-swig-interfaces/FXComposeContext.i
-swig-interfaces/FXComposite.i
-swig-interfaces/FXCursor.i
-swig-interfaces/FXDC.i
-swig-interfaces/FXDCPrint.i
-swig-interfaces/FXDCWindow.i
-swig-interfaces/FXDataTarget.i
-swig-interfaces/FXDebugTarget.i
-swig-interfaces/FXDelegator.i
-swig-interfaces/FXDial.i
-swig-interfaces/FXDialogBox.i
-swig-interfaces/FXDict.i
-swig-interfaces/FXDirBox.i
-swig-interfaces/FXDirDialog.i
-swig-interfaces/FXDirList.i
-swig-interfaces/FXDirSelector.i
-swig-interfaces/FXDockBar.i
-swig-interfaces/FXDockHandler.i
-swig-interfaces/FXDockSite.i
-swig-interfaces/FXDockTitle.i
-swig-interfaces/FXDocument.i
-swig-interfaces/FXDragCorner.i
-swig-interfaces/FXDrawable.i
-swig-interfaces/FXDriveBox.i
-swig-interfaces/FXExtentd.i
-swig-interfaces/FXExtentf.i
-swig-interfaces/FXFileDialog.i
-swig-interfaces/FXFileDict.i
-swig-interfaces/FXFileList.i
-swig-interfaces/FXFileSelector.i
-swig-interfaces/FXFileStream.i
-swig-interfaces/FXFoldingList.i
-swig-interfaces/FXFont.i
-swig-interfaces/FXFontDialog.i
-swig-interfaces/FXFontSelector.i
-swig-interfaces/FXFrame.i
-swig-interfaces/FXGIFCursor.i
-swig-interfaces/FXGIFIcon.i
-swig-interfaces/FXGIFImage.i
-swig-interfaces/FXGLCanvas.i
-swig-interfaces/FXGLContext.i
-swig-interfaces/FXGLObject.i
-swig-interfaces/FXGLShape.i
-swig-interfaces/FXGLViewer.i
-swig-interfaces/FXGLVisual.i
-swig-interfaces/FXGradientBar.i
-swig-interfaces/FXGroupBox.i
-swig-interfaces/FXHeader.i
-swig-interfaces/FXHorizontalFrame.i
-swig-interfaces/FXICOIcon.i
-swig-interfaces/FXICOImage.i
-swig-interfaces/FXIcon.i
-swig-interfaces/FXIconDict.i
-swig-interfaces/FXIconList.i
-swig-interfaces/FXIconSource.i
-swig-interfaces/FXId.i
-swig-interfaces/FXImage.i
-swig-interfaces/FXImageFrame.i
-swig-interfaces/FXImageView.i
-swig-interfaces/FXInputDialog.i
-swig-interfaces/FXJPGIcon.i
-swig-interfaces/FXJPGImage.i
-swig-interfaces/FXKnob.i
-swig-interfaces/FXLabel.i
-swig-interfaces/FXList.i
-swig-interfaces/FXListBox.i
-swig-interfaces/FXMDIButton.i
-swig-interfaces/FXMDIChild.i
-swig-interfaces/FXMDIClient.i
-swig-interfaces/FXMainWindow.i
-swig-interfaces/FXMat3d.i
-swig-interfaces/FXMat3f.i
-swig-interfaces/FXMat4d.i
-swig-interfaces/FXMat4f.i
-swig-interfaces/FXMatrix.i
-swig-interfaces/FXMemoryBuffer.i
-swig-interfaces/FXMemoryStream.i
-swig-interfaces/FXMenuBar.i
-swig-interfaces/FXMenuButton.i
-swig-interfaces/FXMenuCaption.i
-swig-interfaces/FXMenuCascade.i
-swig-interfaces/FXMenuCheck.i
-swig-interfaces/FXMenuCommand.i
-swig-interfaces/FXMenuPane.i
-swig-interfaces/FXMenuRadio.i
-swig-interfaces/FXMenuSeparator.i
-swig-interfaces/FXMenuTitle.i
-swig-interfaces/FXMessageBox.i
-swig-interfaces/FXObject.i
-swig-interfaces/FXOptionMenu.i
-swig-interfaces/FXPCXIcon.i
-swig-interfaces/FXPCXImage.i
-swig-interfaces/FXPNGIcon.i
-swig-interfaces/FXPNGImage.i
-swig-interfaces/FXPPMIcon.i
-swig-interfaces/FXPPMImage.i
-swig-interfaces/FXPacker.i
-swig-interfaces/FXPicker.i
-swig-interfaces/FXPoint.i
-swig-interfaces/FXPopup.i
-swig-interfaces/FXPrintDialog.i
-swig-interfaces/FXProgressBar.i
-swig-interfaces/FXProgressDialog.i
-swig-interfaces/FXQuatd.i
-swig-interfaces/FXQuatf.i
-swig-interfaces/FXRGBIcon.i
-swig-interfaces/FXRGBImage.i
-swig-interfaces/FXRadioButton.i
-swig-interfaces/FXRanged.i
-swig-interfaces/FXRangef.i
-swig-interfaces/FXRealSlider.i
-swig-interfaces/FXRealSpinner.i
-swig-interfaces/FXRecentFiles.i
-swig-interfaces/FXRectangle.i
-swig-interfaces/FXRegion.i
-swig-interfaces/FXRegistry.i
-swig-interfaces/FXReplaceDialog.i
-swig-interfaces/FXRootWindow.i
-swig-interfaces/FXRuler.i
-swig-interfaces/FXRulerView.i
-swig-interfaces/FXScintilla.i
-swig-interfaces/FXScrollArea.i
-swig-interfaces/FXScrollBar.i
-swig-interfaces/FXScrollPane.i
-swig-interfaces/FXScrollWindow.i
-swig-interfaces/FXSearchDialog.i
-swig-interfaces/FXSeparator.i
-swig-interfaces/FXSettings.i
-swig-interfaces/FXShell.i
-swig-interfaces/FXShutter.i
-swig-interfaces/FXSize.i
-swig-interfaces/FXSlider.i
-swig-interfaces/FXSphered.i
-swig-interfaces/FXSpheref.i
-swig-interfaces/FXSpinner.i
-swig-interfaces/FXSplashWindow.i
-swig-interfaces/FXSplitter.i
-swig-interfaces/FXSpring.i
-swig-interfaces/FXStatusBar.i
-swig-interfaces/FXStatusLine.i
-swig-interfaces/FXStream.i
-swig-interfaces/FXStringDict.i
-swig-interfaces/FXSwitcher.i
-swig-interfaces/FXTGAIcon.i
-swig-interfaces/FXTGAImage.i
-swig-interfaces/FXTIFIcon.i
-swig-interfaces/FXTIFImage.i
-swig-interfaces/FXTabBar.i
-swig-interfaces/FXTabBook.i
-swig-interfaces/FXTabItem.i
-swig-interfaces/FXTable.i
-swig-interfaces/FXText.i
-swig-interfaces/FXTextField.i
-swig-interfaces/FXToggleButton.i
-swig-interfaces/FXToolBar.i
-swig-interfaces/FXToolBarGrip.i
-swig-interfaces/FXToolBarShell.i
-swig-interfaces/FXToolBarTab.i
-swig-interfaces/FXToolTip.i
-swig-interfaces/FXTopWindow.i
-swig-interfaces/FXTranslator.i
-swig-interfaces/FXTreeList.i
-swig-interfaces/FXTreeListBox.i
-swig-interfaces/FXTriStateButton.i
-swig-interfaces/FXURL.i
-swig-interfaces/FXVec2d.i
-swig-interfaces/FXVec2f.i
-swig-interfaces/FXVec3d.i
-swig-interfaces/FXVec3f.i
-swig-interfaces/FXVec4d.i
-swig-interfaces/FXVec4f.i
-swig-interfaces/FXVerticalFrame.i
-swig-interfaces/FXVisual.i
-swig-interfaces/FXWindow.i
-swig-interfaces/FXWizard.i
-swig-interfaces/FXXBMIcon.i
-swig-interfaces/FXXBMImage.i
-swig-interfaces/FXXPMIcon.i
-swig-interfaces/FXXPMImage.i
-swig-interfaces/README
-swig-interfaces/common.i
-swig-interfaces/core.i
-swig-interfaces/dcmodule.i
-swig-interfaces/dialogs.i
-swig-interfaces/exceptions.i
-swig-interfaces/framesmodule.i
-swig-interfaces/freefuncs.i
-swig-interfaces/fx3d.i
-swig-interfaces/fxdefs.i
-swig-interfaces/handlers.i
-swig-interfaces/iconlistmodule.i
-swig-interfaces/icons.i
-swig-interfaces/ignore-message-handlers.rb
-swig-interfaces/image.i
-swig-interfaces/labelmodule.i
-swig-interfaces/layout.i
-swig-interfaces/listmodule.i
-swig-interfaces/macros.i
-swig-interfaces/markfuncs.i
-swig-interfaces/mdi.i
-swig-interfaces/menumodule.i
-swig-interfaces/ruby-typemaps.i
-swig-interfaces/scintilla.i
-swig-interfaces/table-module.i
-swig-interfaces/text-module.i
-swig-interfaces/treelist-module.i
-swig-interfaces/ui.i
-test/README
-test/TC_FXAccelTable.rb
-test/TC_FXApp.rb
-test/TC_FXArc.rb
-test/TC_FXBMPIcon.rb
-test/TC_FXBMPImage.rb
-test/TC_FXButton.rb
-test/TC_FXCheckButton.rb
-test/TC_FXComboBox.rb
-test/TC_FXDC.rb
-test/TC_FXDCPrint.rb
-test/TC_FXDCWindow.rb
-test/TC_FXDataTarget.rb
-test/TC_FXDialogBox.rb
-test/TC_FXDirList.rb
-test/TC_FXExtentd.rb
-test/TC_FXExtentf.rb
-test/TC_FXFileAssoc.rb
-test/TC_FXFileStream.rb
-test/TC_FXFoldingList.rb
-test/TC_FXFont.rb
-test/TC_FXFontDesc.rb
-test/TC_FXGLGroup.rb
-test/TC_FXGLShape.rb
-test/TC_FXGLViewer.rb
-test/TC_FXGradientBar.rb
-test/TC_FXHeader.rb
-test/TC_FXHiliteStyle.rb
-test/TC_FXIconDict.rb
-test/TC_FXIconList.rb
-test/TC_FXId.rb
-test/TC_FXImage.rb
-test/TC_FXLight.rb
-test/TC_FXList.rb
-test/TC_FXListBox.rb
-test/TC_FXMainWindow.rb
-test/TC_FXMat4f.rb
-test/TC_FXMaterial.rb
-test/TC_FXMemoryStream.rb
-test/TC_FXMenuCheck.rb
-test/TC_FXMenuCommand.rb
-test/TC_FXMenuRadio.rb
-test/TC_FXMessageBox.rb
-test/TC_FXPoint.rb
-test/TC_FXQuatf.rb
-test/TC_FXRadioButton.rb
-test/TC_FXRanged.rb
-test/TC_FXRangef.rb
-test/TC_FXRectangle.rb
-test/TC_FXRegion.rb
-test/TC_FXRegistry.rb
-test/TC_FXScrollArea.rb
-test/TC_FXScrollWindow.rb
-test/TC_FXSegment.rb
-test/TC_FXSettings.rb
-test/TC_FXShell.rb
-test/TC_FXSize.rb
-test/TC_FXStream.rb
-test/TC_FXTable.rb
-test/TC_FXTableItem.rb
-test/TC_FXText.rb
-test/TC_FXTopWindow.rb
-test/TC_FXTreeList.rb
-test/TC_FXTreeListBox.rb
-test/TC_FXUndoList.rb
-test/TC_FXVec2d.rb
-test/TC_FXVec2f.rb
-test/TC_FXVec3d.rb
-test/TC_FXVec3f.rb
-test/TC_FXVec4f.rb
-test/TC_FXViewport.rb
-test/TC_FXWindow.rb
-test/TC_FXXBMIcon.rb
-test/TC_FXXBMImage.rb
-test/TC_FXXPMIcon.rb
-test/TC_FXXPMImage.rb
-test/TC_Misc.rb
-test/TC_downcast.rb
-test/TS_All.rb
-test/blankpage.ps
-test/howdypage.ps
-test/stress1.rb
-test/stress2.rb
-test/stress3.rb
-test/testcase.rb
-web/community.html
-web/css/style.css
-web/documentation.html
-web/downloads.html
-web/images/bullet.gif
-web/images/button-bg.jpg
-web/images/comment.gif
-web/images/content.jpg
-web/images/dots.jpg
-web/images/footer.jpg
-web/images/fxruby-book.jpg
-web/images/header.png
-web/images/menu.jpg
-web/images/page.gif
-web/images/quote.gif
-web/images/square-green.png
-web/index.html
diff --git a/README.rdoc b/README.rdoc
index 5c45c224..bbd09bdf 100644
--- a/README.rdoc
+++ b/README.rdoc
@@ -1,7 +1,12 @@
 = FXRuby
 
 * http://github.com/larskanis/fxruby
-* API: http://rubydoc.info/gems/fxruby/frames
+* Full API-description: http://rubydoc.info/gems/fxruby/frames
+* Latest fxruby {<img src="https://badge.fury.io/rb/fxruby.svg" alt="Gem Version" />}[http://badge.fury.io/rb/fxruby]
+* Status on Linux: {<img src="https://travis-ci.org/larskanis/fxruby.svg?branch=1.6" alt="Build Status on Linux" />}[https://travis-ci.org/larskanis/fxruby]
+  on Windows: {<img src="https://ci.appveyor.com/api/projects/status/too7sj4gq643ts8w/branch/1.6?svg=true" alt="Build Status on Windows" />}[https://ci.appveyor.com/project/larskanis/fxruby/branch/1.6]
+
+
 
 == DESCRIPTION:
 
@@ -14,7 +19,7 @@ Ruby programming language that you already know and love, while at the
 same time taking advantage of the performance and functionality of a
 featureful, highly optimized C++ toolkit.
 
-== FEATURES/PROBLEMS:
+== FEATURES:
 
 FXRuby supportes everything of FOX, that is useful in Ruby:
 * MDI/SDI application window layouts, floating toolbars
@@ -22,14 +27,15 @@ FXRuby supportes everything of FOX, that is useful in Ruby:
 * Flexible layout management
 * Image read/write support in many formats
 * Embedded OpenGL graphics
+* Thread support
 
 == INSTALL:
 
-FXRuby runs on Linux, Windows and OS-X. Installation on *nix requires
+FXRuby runs on Linux, Windows and OS-X with Ruby-2.2 or newer. Installation on Unix requires
 FOX development headers and libraries installed:
 * on Debian/Ubuntu: <tt>sudo apt-get install g++ libxrandr-dev libfox-1.6-dev</tt>
 * see also detailed installation instructions in the {https://github.com/lylejohnson/fxruby/wiki Wiki}
-* no preparation needed on Windows - the binary gem can be used
+* on Windows: the binary fxruby gems already contain all required libararies
 
 Then, install the gem:
 * gem install fxruby
diff --git a/Rakefile b/Rakefile
index b9527f06..14382f96 100755
--- a/Rakefile
+++ b/Rakefile
@@ -1,177 +1,271 @@
 require 'rubygems'
-require 'hoe'
 require 'erb'
+require 'date'
 require 'rake/extensiontask'
+require 'bundler'
+require 'bundler/gem_helper'
 require './lib/fox16/version.rb'
 
-# Use forked process for chdir'ed environment, to allow parallel execution with drake
-module FileUtils
-  alias unforked_fileutils_cd cd
-  def cd(dir, options={}, &block)
-    raise "chdir called without block" unless block_given?
-    Process.waitpid(fork{ unforked_fileutils_cd(dir, options, &block) })
+
+class FoxGemHelper < Bundler::GemHelper
+  attr_accessor :cross_platforms
+
+  def install
+    super
+
+    task "release:guard_clean" => ["release:update_history"]
+
+    task "release:update_history" do
+      update_history
+    end
+
+    task "release:rubygem_push" => ["gem:windows"]
+  end
+
+  def hfile
+    "History.md"
+  end
+
+  def headline
+    '([^\w]*)(\d+\.\d+\.\d+(?:\.\w+)?)([^\w]+)([2Y][0Y][0-9Y][0-9Y]-[0-1M][0-9M]-[0-3D][0-9D])([^\w]*|$)'
+  end
+
+  def reldate
+    Time.now.strftime("%Y-%m-%d")
+  end
+
+  def update_history
+    hin = File.read(hfile)
+    hout = hin.sub(/#{headline}/) do
+      raise "#{hfile} isn't up-to-date for version #{version}" unless $2==version.to_s
+      $1 + $2 + $3 + reldate + $5
+    end
+    if hout != hin
+      Bundler.ui.confirm "Updating #{hfile} for release."
+      File.write(hfile, hout)
+      Rake::FileUtilsExt.sh "git", "commit", hfile, "-m", "Update release date in #{hfile}"
+    end
+  end
+
+  def tag_version
+    Bundler.ui.confirm "Tag release with annotation:"
+    m = File.read(hfile).match(/(?<annotation>#{headline}.*?)#{headline}/m) || raise("Unable to find release notes in #{hfile}")
+    Bundler.ui.info(m[:annotation].gsub(/^/, "    "))
+    IO.popen(["git", "tag", "--file=-", version_tag], "w") do |fd|
+      fd.write m[:annotation]
+    end
+    yield if block_given?
+  rescue
+    Bundler.ui.error "Untagging #{version_tag} due to error."
+    sh_with_code "git tag -d #{version_tag}"
+    raise
+  end
+
+  def rubygem_push(path)
+    cross_platforms.each do |ruby_platform|
+      super(path.gsub(/\.gem\z/, "-#{ruby_platform}.gem"))
+    end
+    super(path)
   end
-  module_function :cd
-  alias chdir cd
-  module_function :chdir
 end
 
 # Some constants we'll need
-PKG_VERSION = Fox.fxrubyversion
+LIBFXSCINTILLA_VERSION            = ENV['LIBFXSCINTILLA_VERSION'] || '2.28.0'
+LIBFXSCINTILLA_SOURCE_URI         = "http://download.savannah.gnu.org/releases/fxscintilla/fxscintilla-#{LIBFXSCINTILLA_VERSION}.tar.gz"
 
 SWIG = (RUBY_PLATFORM =~ /mingw/) ? "swig.exe" : "swig"
 SWIGFLAGS = "-c++ -ruby -nodefaultdtor -nodefaultctor -w302 -features compactdefaultargs -I../fox-includes"
-SWIG_LIB = `#{SWIG} -swiglib`.chomp
-SWIG_MODULES = {
-  "core.i" => "core_wrap.cpp",
-  "dcmodule.i" => "dc_wrap.cpp",
-  "dialogs.i" => "dialogs_wrap.cpp",
-  "framesmodule.i" => "frames_wrap.cpp",
-  "iconlistmodule.i" => "iconlist_wrap.cpp",
-  "icons.i" => "icons_wrap.cpp",
-  "image.i" => "image_wrap.cpp",
-  "labelmodule.i" => "label_wrap.cpp",
-  "layout.i" => "layout_wrap.cpp",
-  "listmodule.i" => "list_wrap.cpp",
-  "mdi.i" => "mdi_wrap.cpp",
-  "menumodule.i" => "menu_wrap.cpp",
-  "fx3d.i" => "fx3d_wrap.cpp",
-  "scintilla.i" => "scintilla_wrap.cpp",
-  "table-module.i" => "table_wrap.cpp",
-  "text-module.i" => "text_wrap.cpp",
-  "treelist-module.i" => "treelist_wrap.cpp",
-  "ui.i" => "ui_wrap.cpp"
-}
-
-
-hoe = Hoe.spec "fxruby" do
-  # ... project specific data ...
-  self.blog_categories = %w{FXRuby}
-  self.clean_globs = [".config", "ext/fox16_c/Makefile", "ext/fox16_c/*.o", "ext/fox16_c/*.bundle", "ext/fox16_c/mkmf.log", "ext/fox16_c/conftest.dSYM", "ext/fox16_c/include/swigrubyrun.h", "ext/fox16_c/librb.c", "ext/fox16_c/include/inlinestubs.h", "ext/fox16_c/*_wrap.cpp"]
-  developer("Lyle Johnson", "lyle@lylejohnson.name")
-  developer("Lars Kanis", "kanis@comcard.de")
-  self.extra_rdoc_files = ["rdoc-sources", File.join("rdoc-sources", "README.rdoc")]
-  self.remote_rdoc_dir = "doc/api"
-  self.spec_extras = {
-    :description => "FXRuby is the Ruby binding to the FOX GUI toolkit.",
-    :extensions => ["ext/fox16_c/extconf.rb"],
-    :rdoc_options => ['--main', File.join('rdoc-sources', 'README.rdoc'), '--exclude', 'ext/fox16_c', '--exclude', %r{aliases|kwargs|missingdep|responder}.inspect],
-    :require_paths => ['lib'],
-    :summary => "FXRuby is the Ruby binding to the FOX GUI toolkit."
-  }
-  self.test_globs = ["test/**/TC_*.rb"]
-  self.version = PKG_VERSION
-  self.readme_file = 'README.rdoc'
-  self.extra_rdoc_files << self.readme_file
-
-  spec_extras[:files] = File.read_utf("Manifest.txt").split(/\r?\n\r?/).reject{|f| f=~/^fox-includes|^web/ }
-  spec_extras[:files] += SWIG_MODULES.values.map{|f| File.join("ext/fox16_c", f) }
-  spec_extras[:files] << 'ext/fox16_c/include/inlinestubs.h'
-  spec_extras[:files] << 'ext/fox16_c/swigruby.h'
-  spec_extras[:files] << 'doap.rdf'
-  spec_extras[:files] << 'lib/fox16/kwargs.rb'
-end
+
+CLEAN.include( ".config", "ext/fox16_c/Makefile", "ext/fox16_c/*.o", "ext/fox16_c/*.bundle", "ext/fox16_c/mkmf.log", "ext/fox16_c/conftest.dSYM", "ext/fox16_c/swigruby.h*", "ext/fox16_c/librb.c", "ext/fox16_c/include/inlinestubs.h", "ext/fox16_c/*_wrap.cpp", "tmp", "ports/*.installed", "ports/*mingw32*" )
+
+CLOBBER.include( "pkg" )
 
 # Make sure extension is built before tests are run
-task :test => [:compile]
+task :test => [:compile] do
+  sh "ruby -w -W2 -Ilib test/TS_All.rb -v"
+end
 
-# The "docs" task created by Hoe assumes that we want to run RDoc
-# over everything under the "lib" and "ext" subdirectories.
-# We need to go back and tell it to skip the stuff under ext.
-# rdoc_target = Rake::Task['docs'].prerequisites.first
-# rdoc_files = Rake::Task[rdoc_target].prerequisites
-# rdoc_files.reject! {|x| x == "ext/fox16_c" }
+task :gem => ["ext/fox16_c/extconf.rb", "fxruby:configure", :build]
 
-# Make sure that all of the package contents exist before we try to build the package
-#Rake::Task['package'].prerequisites.unshift("swig:swig", "fxruby:setversions", "fxruby:generate_kwargs_lib")
 
-# ... project specific tasks ...
+gem_spec = Bundler.load_gemspec('fxruby.gemspec')
 
-Rake::ExtensionTask.new("fox16_c", hoe.spec) do |ext|
+ext_task = Rake::ExtensionTask.new("fox16_c", gem_spec) do |ext|
   ext.cross_compile = true
   ext.cross_platform = ['x86-mingw32', 'x64-mingw32']
+  # Enable FXTRACE and FXASSERT for 'rake compile'
+  ext.config_options << "--enable-debug"
 
   ext.cross_config_options += [
       "--enable-win32-cross",
       "--with-fxscintilla",
     ]
+  ext.cross_config_options << "--enable-debug" if ENV['FXRUBY_MINGW_DEBUG']
 
   # Add dependent DLLs to the cross gems
   ext.cross_compiling do |spec|
-    plat = spec.platform
-    dlls = Dir["tmp/#{plat}/#{ext.name}/*/*.dll"].map{|dll| File.basename(dll) }.uniq
-    spec.files += dlls.map{|dll| "lib/#{plat}/#{dll}" }
-
-    directory "tmp/#{plat}/stage/lib/#{plat}/"
-    dlls.each do |dll|
-      ENV['RUBY_CC_VERSION'].to_s.split(':').last.tap do |ruby_version|
-        file "tmp/#{plat}/stage/lib/#{plat}/#{dll}" => ["tmp/#{plat}/stage/lib/#{plat}/", "tmp/#{plat}/#{ext.name}/#{ruby_version}/#{dll}"] do
-          cp "tmp/#{plat}/#{ext.name}/#{ruby_version}/#{dll}", "tmp/#{plat}/stage/lib/#{plat}"
-          sh "x86_64-w64-mingw32-strip", "tmp/#{plat}/stage/lib/#{plat}/#{dll}"
+    # The fat binary gem doesn't depend on the fox package, since it bundles the libraries.
+    spec.metadata.delete('msys2_mingw_dependencies')
+
+    platform_host_map =  {
+      'x86-mingw32' => ['i686-w64-mingw32'],
+      'x64-mingw32' => ['x86_64-w64-mingw32'],
+    }
+
+    gemplat = spec.platform.to_s
+    platform_host_map[gemplat].each do |host|
+
+      gcc_shared_dlls = %w[libwinpthread-1.dll libgcc_s_dw2-1.dll libgcc_s_sjlj-1.dll libgcc_s_seh-1.dll libstdc++-6.dll]
+
+      dlls = gcc_shared_dlls.select{|dll| File.exist?("ports/#{host}/bin/#{dll}") }
+      dlls += [
+          "libfxscintilla-20.dll",
+          "libFOX-1.6-0.dll",
+          "libjpeg-62.dll",
+          "libpng16-16.dll",
+          "libtiff-5.dll",
+          "zlib1.dll",
+      ]
+
+      spec.files += dlls.map{|dll| "ports/#{host}/bin/#{dll}" }
+
+      unless ENV['FXRUBY_MINGW_DEBUG']
+        dlls.each do |dll|
+          task "ports/#{host}/bin/#{dll}" do |t|
+            sh "#{host}-strip", t.name
+          end
         end
       end
-      file "lib/#{plat}/#{dll}" => "tmp/#{plat}/stage/lib/#{plat}/#{dll}"
     end
   end
+
+  FoxGemHelper.install_tasks
+  Bundler::GemHelper.instance.cross_platforms = ext.cross_platform
 end
 
-# To reduce the gem file size strip mingw32 dlls before packaging
-ENV['RUBY_CC_VERSION'].to_s.split(':').each do |ruby_version|
-  task "tmp/x86-mingw32/stage/lib/#{ruby_version[/^\d+\.\d+/]}/fox16_c.so" do |t|
-    sh "i686-w64-mingw32-strip -S tmp/x86-mingw32/stage/lib/#{ruby_version[/^\d+\.\d+/]}/fox16_c.so"
-  end
+namespace :gem do
+  ext_task.cross_platform.each do |plat|
+    desc "Build the windows binary gems"
+    multitask 'windows' => plat
 
-  task "tmp/x64-mingw32/stage/lib/#{ruby_version[/^\d+\.\d+/]}/fox16_c.so" do |t|
-    sh "x86_64-w64-mingw32-strip -S tmp/x64-mingw32/stage/lib/#{ruby_version[/^\d+\.\d+/]}/fox16_c.so"
+    task 'prepare' do
+      require 'rake_compiler_dock'
+      sh "bundle package"
+    end
+
+    task plat => ['gem', 'prepare'] do
+      debug = "FXRUBY_MINGW_DEBUG=#{ENV['FXRUBY_MINGW_DEBUG'].inspect}" if ENV['FXRUBY_MINGW_DEBUG']
+      RakeCompilerDock.sh <<-EOT, platform: plat
+        sudo apt update &&
+        sudo apt install yasm &&
+        bundle --local --without=test &&
+        rake native:#{plat} pkg/#{ext_task.gem_spec.full_name}-#{plat}.gem MAKE=\"nice make V=1 VERBOSE=1 -j `nproc`\" #{debug}
+      EOT
+    end
   end
 end
 
-# Set environment variable SWIG_LIB to
-# c:/ruby-1.8.6-p383-preview2/devkit/msys/1.0.11/usr/local/share/swig/1.3.22
-# before running swig on MinGW.
 namespace :swig do
+  def patch_swigruby(line)
+    # Ruby-2.7+ finally changed callback function signatures from (*)(ANYARGS) to a proper signature, on which the compiler is able to check parameter types.
+    # Unfortunately this requires a bunch of patches to swig's generated code.
+
+    line.gsub! '#include <ruby.h>', <<-EOT
+      #include <ruby.h>
+
+      #if defined(RB_METHOD_DEFINITION_DECL)
+      # define RUBY_VALUE_METHOD_FUNC(func) (func)
+      # define RUBY_INT_METHOD_FUNC(func) (func)
+      # define RUBY_VOID_METHOD_FUNC(func) (func)
+      # define RUBY_VOIDP_METHOD_FUNC(func) (func)
+      #else
+      # define RUBY_VALUE_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
+      # define RUBY_INT_METHOD_FUNC(func) ((int (*)(ANYARGS))(func))
+      # define RUBY_VOID_METHOD_FUNC(func) ((void (*)(ANYARGS))(func))
+      # define RUBY_VOIDP_METHOD_FUNC(func) ((void *(*)(ANYARGS))(func))
+      #endif
+    EOT
+    line.gsub! /rb_define_virtual_variable\((.*?), (\w+), NULL\)/, <<-EOT
+      rb_define_virtual_variable(\\1, RUBY_VALUE_METHOD_FUNC(\\2), RUBY_VOID_METHOD_FUNC((rb_gvar_setter_t*)NULL))
+    EOT
+
+    line.gsub!('static VALUE swig_ruby_trackings_count(ANYARGS)', 'static VALUE swig_ruby_trackings_count(ID id, VALUE *var)')
+    line.gsub!('SWIG_ruby_failed(void)', 'SWIG_ruby_failed(VALUE, VALUE)')
+
+    line.gsub!(/SWIGINTERN VALUE SWIG_AUX_(\w+)\(VALUE \*args\)\s\{/m, 'SWIGINTERN VALUE SWIG_AUX_\\1(VALUE pargs){VALUE *args=(VALUE *)pargs;')
+
+    line.gsub! /static int swig_ruby_internal_iterate_callback\(void\* ptr, VALUE obj, void\(\*meth\)\(void\* ptr, VALUE obj\)\)\s*{\s*\(\*meth\)\(ptr, obj\);/m, <<-EOT
+      static int swig_ruby_internal_iterate_callback(st_data_t ptr, st_data_t obj, st_data_t meth) {
+        ((void(*)(void*, VALUE))meth)((void*)ptr, (VALUE)obj);
+    EOT
+
+    line.gsub!('(int (*)(ANYARGS))&swig_ruby_internal_iterate_callback', 'RUBY_INT_METHOD_FUNC(swig_ruby_internal_iterate_callback)')
+
+    line.gsub! /rb_ensure\(VALUEFUNC\((.*)\), self, VALUEFUNC\((.*)\), self\);/, 'rb_ensure(RUBY_VALUE_METHOD_FUNC(\\1), self, RUBY_VALUE_METHOD_FUNC(\\2), self);'
+    line.gsub! /rb_rescue\(RUBY_METHOD_FUNC\((.*)\), \(VALUE\)a, RUBY_METHOD_FUNC\((.*)\), 0\)/, 'rb_rescue(RUBY_VALUE_METHOD_FUNC(\\1), (VALUE)a, RUBY_VALUE_METHOD_FUNC(\\2), 0)'
+
+    line
+  end
+
   def sed(wrapper_src_file_name)
-    results = []
-    IO.readlines(wrapper_src_file_name).each do |line|
-      line.gsub!(/static VALUE mCore;/, "VALUE mCore;")
-      line.gsub!(/mCore = rb_define_module\("Core"\)/, "mFox = rb_define_module(\"Fox\")")
-      line.gsub!(/mCore/, "mFox")
-      next if line =~ /static VALUE m(Dc|Dialogs|Frames|Iconlist|Icons|Image|Label|Layout|List|Mdi|Menu|Fx3d|Scintilla|Table|Text|Treelist|Ui);/
-      next if line =~ /m(Dc|Dialogs|Frames|Iconlist|Icons|Image|Label|Layout|List|Mdi|Menu|Fx3d|Scintilla|Table|Text|Treelist|Ui) = rb_define_module/
-      next if line =~ /rb_require/
-      line.gsub!(/m(Dc|Dialogs|Frames|Iconlist|Icons|Image|Label|Layout|List|Mdi|Menu|Fx3d|Scintilla|Table|Text|Treelist|Ui),/, "mFox,")
-      results << line
-    end
-    File.open(wrapper_src_file_name, "w") do |io|
-      io.write(results.join)
-    end
+    puts "Update #{wrapper_src_file_name}"
+
+    line = File.read(wrapper_src_file_name)
+    line.gsub!(/static VALUE mCore;/, "VALUE mCore;")
+    line.gsub!(/mCore = rb_define_module\("Core"\)/, "mFox = rb_define_module(\"Fox\")")
+    line.gsub!(/mCore/, "mFox")
+    line.gsub!(/static VALUE m(Dc|Dialogs|Frames|Iconlist|Icons|Image|Label|Layout|List|Mdi|Menu|Fx3d|Scintilla|Table|Text|Treelist|Ui);/, '')
+    line.gsub!(/m(Dc|Dialogs|Frames|Iconlist|Icons|Image|Label|Layout|List|Mdi|Menu|Fx3d|Scintilla|Table|Text|Treelist|Ui) = rb_define_module.*/, '')
+    line.gsub!(/rb_require.*/, '')
+    line.gsub!(/m(Dc|Dialogs|Frames|Iconlist|Icons|Image|Label|Layout|List|Mdi|Menu|Fx3d|Scintilla|Table|Text|Treelist|Ui),/, "mFox,")
+
+    line = patch_swigruby(line)
+
+    File.write(wrapper_src_file_name, line)
+  end
+
+  def add_with_fxscintilla_cond(file)
+    puts "Update #{file} for fxscintilla"
+    content = File.binread(file)
+    content = "#ifdef WITH_FXSCINTILLA\n" + content + "#endif /* WITH_FXSCINTILLA */\n"
+    File.binwrite(file, content)
   end
 
   def swig(swig_interface_file_name, wrapper_src_file_name)
     cmd = "#{SWIG} #{SWIGFLAGS} -o #{wrapper_src_file_name} #{swig_interface_file_name}"
     puts cmd
     system cmd
+
+    # Do our own wrapper file modifications:
     sed wrapper_src_file_name
+    add_with_fxscintilla_cond(wrapper_src_file_name) if ["scintilla_wrap.cpp"].include?(File.basename(wrapper_src_file_name))
   end
 
   task :swigruby_h => ["ext/fox16_c/swigruby.h"]
-  file "ext/fox16_c/swigruby.h" do |task|
+  file "ext/fox16_c/swigruby.h.orig" do |task|
     puts "generate #{task.name}"
     system "#{SWIG} -ruby -external-runtime #{task.name}"
   end
 
+  file "ext/fox16_c/swigruby.h"=>["ext/fox16_c/swigruby.h.orig"] do |task|
+    puts "generate #{task.name}"
+    text = File.read(task.prerequisites[0])
+    text = patch_swigruby(text)
+    File.write(task.name, text)
+  end
+
   desc "Run SWIG to generate the wrapper files."
-  task :swig => [:swigruby_h] + SWIG_MODULES.map{|ifile, cppfile| File.join("ext/fox16_c", cppfile) }
+  multitask :swig => [:swigruby_h] + SWIG_MODULES.map{|ifile, cppfile| File.join("ext/fox16_c", cppfile) }
+end
 
-  # add dependencies for compile *.i to *_wrap.cpp
-  SWIG_MODULES.each do |ifile, cppfile|
-    cppfile_path = File.join("ext/fox16_c", cppfile)
+# add dependencies for compile *.i to *_wrap.cpp
+SWIG_MODULES.each do |ifile, cppfile|
+  cppfile_path = File.join("ext/fox16_c", cppfile)
 
-    file cppfile_path => [ifile, 'macros.i', 'common.i', 'fxdefs.i', 'ruby-typemaps.i',
-                          'markfuncs.i', 'exceptions.i', 'freefuncs.i', 'macros.i', 'handlers.i'
-                         ].map{|f| File.join("swig-interfaces", f) } do |task|
-      swig(File.join("swig-interfaces", ifile), cppfile_path)
-    end
+  file cppfile_path => [ifile, 'macros.i', 'common.i', 'fxdefs.i', 'ruby-typemaps.i',
+                        'markfuncs.i', 'exceptions.i', 'freefuncs.i', 'macros.i', 'handlers.i'
+                       ].map{|f| File.join("swig-interfaces", f) } do |task|
+    swig(File.join("swig-interfaces", ifile), cppfile_path)
   end
 end
 
@@ -221,8 +315,13 @@ namespace :fxruby do
     make_impl
   end
 
-  file "ext/fox16_c/extconf.rb" => ['ext/fox16_c/swigruby.h', 'ext/fox16_c/impl.cpp', 'ext/fox16_c/include/inlinestubs.h'] +
-      SWIG_MODULES.map{|ifile, cppfile| File.join("ext/fox16_c", cppfile) }
+  file "ext/fox16_c/extconf.rb" => ['ext/fox16_c/impl.cpp', 'ext/fox16_c/include/inlinestubs.h', 'swig:swig']
+
+
+  directory "ports/archives"
+  file "ports/archives/fxscintilla-2.28.0.tar.gz" => ["ports/archives"] do |t|
+    sh "wget #{LIBFXSCINTILLA_SOURCE_URI} -O #{t.name}"
+  end
 
   directory "tmp/fxscintilla"
   task "tmp/fxscintilla/fxscintilla-2.28.0/include/Scintilla.iface" => ["tmp/fxscintilla", "ports/archives/fxscintilla-2.28.0.tar.gz"] do
diff --git a/appveyor.yml b/appveyor.yml
new file mode 100644
index 00000000..f0a1da71
--- /dev/null
+++ b/appveyor.yml
@@ -0,0 +1,33 @@
+init:
+  - SET PATH=c:/Ruby%ruby_version%/bin;c:/msys64/%MSYSTEM%/bin;%PATH%
+  - SET RAKEOPT=-rdevkit
+install:
+  - ps: |
+      if ($env:ruby_version -like "*head*") {
+        $(new-object net.webclient).DownloadFile("https://github.com/oneclick/rubyinstaller2/releases/download/rubyinstaller-head/rubyinstaller-$env:ruby_version.exe", "$pwd/ruby-setup.exe")
+        cmd /c ruby-setup.exe /verysilent /dir=C:/Ruby$env:ruby_version
+      }
+  - ruby --version
+  - gem --version
+  - ridk version
+  # Remove gcc-ada and gcc-objc, since they are no longer supported by msys2 and therefore cause a dependency issue
+  - c:/msys64/usr/bin/bash -lc "pacman --noconfirm --remove mingw-w64-i686-gcc-ada mingw-w64-i686-gcc-objc mingw-w64-x86_64-gcc-ada mingw-w64-x86_64-gcc-objc"
+  - c:/msys64/usr/bin/bash -lc "pacman -Syu --noconfirm --ask 20"
+  - c:/msys64/usr/bin/bash -lc "pacman -Su --noconfirm"
+  - c:/msys64/usr/bin/bash -lc "pacman -S --noconfirm --needed ${MINGW_PACKAGE_PREFIX}-fox ${MINGW_PACKAGE_PREFIX}-swig"
+  - swig -version
+  - gem install bundler --conservative
+  - bundle config set force_ruby_platform true
+  - bundle install
+build_script:
+  - bundle exec rake compile
+test_script:
+  - bundle exec rake test
+environment:
+  matrix:
+    - ruby_version: "head-x64"
+      MINGW_PACKAGE_PREFIX: "mingw-w64-x86_64"
+      MSYSTEM: "MINGW64"
+    - ruby_version: "24"
+      MINGW_PACKAGE_PREFIX: "mingw-w64-i686"
+      MSYSTEM: "MINGW32"
diff --git a/doap.rdf b/doap.rdf
new file mode 100644
index 00000000..d64aaad0
--- /dev/null
+++ b/doap.rdf
@@ -0,0 +1,87 @@
+<?xml version="1.0" encoding="iso-8859-15"?>
+<rdf:RDF
+  xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+  xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
+  xmlns:doap="http://usefulinc.com/ns/doap#"
+  xmlns:foaf="http://xmlns.com/foaf/0.1/">
+  <doap:Project>
+    <doap:name>FXRuby</doap:name>
+    <doap:shortname>FXRuby</doap:shortname>
+    <doap:homepage rdf:resource="http://github.com/larskanis/fxruby"/>
+    <doap:old-homepage rdf:resource="http://fxruby.sourceforge.net"/>
+    <doap:created>2001-01-01</doap:created>
+    <doap:description>FXRuby is an extension module for Ruby that provides an interface to the FOX GUI toolkit.</doap:description>
+    <doap:shortdesc>FXRuby is a Ruby interface to the FOX GUI toolkit.</doap:shortdesc>
+    <doap:wiki rdf:resource="http://fxruby.rubyforge.org/wiki/wiki.pl"/>
+    <doap:bug-database rdf:resource="http://rubyforge.org/tracker/?atid=1223&amp;group_id=300&amp;func=browse"/>
+    <doap:mailing-list rdf:resource="http://rubyforge.org/mailman/listinfo/fxruby-users"/>
+    <doap:screenshots rdf:resource="http://www.fxruby.org/doc/examples.html"/>
+    <doap:programming-language>Ruby</doap:programming-language>
+    <doap:license rdf:resource="http://usefulinc.com/doap/licenses/lgpl"/>
+    <doap:download-page rdf:resource="http://rubyforge.org/frs/?group_id=300"/>
+
+    <doap:maintainer>
+      <foaf:Person>
+        <foaf:name>Lyle Johnson</foaf:name>
+        <foaf:nick>lyle</foaf:nick>
+        <foaf:mbox_sha1sum>6a53ac5fe72eaa9e17d14207ed0bbdaa2fb8aed9</foaf:mbox_sha1sum>
+        <rdfs:seeAlso rdf:resource="http://lylejohnson.name/foaf.rdf"/>
+      </foaf:Person>
+    </doap:maintainer>
+
+    <doap:repository>
+      <doap:CVSRepository>
+        <doap:anon-root>:pserver:anonymous@rubyforge.org:/var/cvs/fxruby</doap:anon-root>
+        <doap:module>FXRuby</doap:module>
+        <doap:browse rdf:resource="http://rubyforge.org/cgi-bin/viewcvs/cgi/viewcvs.cgi/?cvsroot=fxruby"/>
+      </doap:CVSRepository>
+    </doap:repository>
+
+    <!-- Software Development :: Libraries :: Ruby Modules -->
+    <doap:category rdf:resource="http://freshmeat.net/browse/955/"/>
+
+    <!-- Software Development :: User Interfaces -->
+    <doap:category rdf:resource="http://freshmeat.net/browse/909/"/>
+
+    <!-- Software Development :: Widget Sets -->
+    <doap:category rdf:resource="http://freshmeat.net/browse/851/"/>
+
+    <!-- current fox release -->
+    <doap:release>
+      <doap:Version>
+        <doap:branch>fox</doap:branch>
+        <doap:created>2004-06-16</doap:created>
+        <doap:revision>1.0.29</doap:revision>
+      </doap:Version>
+    </doap:release>
+
+    <!-- current fox12 release -->
+    <doap:release>
+      <doap:Version>
+        <doap:branch>fox12</doap:branch>
+        <doap:created>2005-04-15</doap:created>
+        <doap:revision>1.2.6</doap:revision>
+      </doap:Version>
+    </doap:release>
+
+    <!-- current fox14 release -->
+    <doap:release>
+      <doap:Version>
+        <doap:branch>fox14</doap:branch>
+        <doap:created>2006-09-13</doap:created>
+        <doap:revision>1.4.7</doap:revision>
+      </doap:Version>
+    </doap:release>
+
+    <!-- current fox16 release -->
+    <doap:release>
+      <doap:Version>
+        <doap:branch>fox16</doap:branch>
+        <doap:created>2017-06-15</doap:created>
+        <doap:revision>1.6.37-rc1</doap:revision>
+      </doap:Version>
+    </doap:release>
+
+  </doap:Project>
+</rdf:RDF>
+
diff --git a/doap.rdf.erb b/doap.rdf.erb
index 1833e9ef..ed079a52 100755
--- a/doap.rdf.erb
+++ b/doap.rdf.erb
@@ -78,7 +78,7 @@
       <doap:Version>
         <doap:branch>fox16</doap:branch>
         <doap:created><%= Date.today %></doap:created>
-        <doap:revision><%= PKG_VERSION %></doap:revision>
+        <doap:revision><%= Fox.fxrubyversion %></doap:revision>
       </doap:Version>
     </doap:release>
 
diff --git a/examples/WhatAQuietStiff.rb b/examples/WhatAQuietStiff.rb
index d87da665..5b0318dd 100755
--- a/examples/WhatAQuietStiff.rb
+++ b/examples/WhatAQuietStiff.rb
@@ -134,7 +134,7 @@ class WhatAQuietWindow < FXMainWindow
     saveDialog = FXFileDialog.new(self, "Save Image")
     saveDialog.filename = @itemList.getItemText(@itemList.currentItem)
     if saveDialog.execute != 0
-      if File.exists? saveDialog.filename
+      if File.exist? saveDialog.filename
         if MBOX_CLICKED_NO == FXMessageBox.question(self, MBOX_YES_NO,
           "Overwrite Image", "Overwrite existing image?")
           return 1
diff --git a/examples/gltest.rb b/examples/gltest.rb
index bcc3baeb..fdb8f4ae 100755
--- a/examples/gltest.rb
+++ b/examples/gltest.rb
@@ -312,13 +312,6 @@ if __FILE__ == $0
   # Construct the application
   application = FXApp.new("GLTest", "FoxTest")
 
-  # To ensure that the chores-based spin will run as fast as possible,
-  # we can disable the chore in FXRuby's event loop that tries to schedule
-  # other threads. This is OK for this program because there aren't any
-  # other Ruby threads running.
-
-  application.disableThreads
-
   # Construct the main window
   GLTestWindow.new(application)
 
diff --git a/examples/groupbox.rb b/examples/groupbox.rb
index 26a99b7a..6076d99a 100755
--- a/examples/groupbox.rb
+++ b/examples/groupbox.rb
@@ -361,12 +361,14 @@ class GroupWindow < FXMainWindow
     show(PLACEMENT_SCREEN)
 
     # Create a thread to update the clock
-    @clockThread = Thread.new(@clockLabel) { |clockLabel|
+    @clockThread = Thread.new(@clockLabel) do |clockLabel|
       while true
-        clockLabel.text = Time.now.strftime("%I:%M:%S %p")
+        runOnUiThread do
+          clockLabel.text = Time.now.strftime("%I:%M:%S %p")
+        end
         sleep(1)
       end
-    }
+    end
   end
 end
 
diff --git a/examples/imageviewer.rb b/examples/imageviewer.rb
index 85ece9b3..3961e7f3 100755
--- a/examples/imageviewer.rb
+++ b/examples/imageviewer.rb
@@ -326,7 +326,7 @@ class ImageWindow < FXMainWindow
   def onCmdSave(sender, sel, ptr)
     saveDialog = FXFileDialog.new(self, "Save Image")
     if saveDialog.execute != 0
-      if File.exists? saveDialog.filename
+      if File.exist? saveDialog.filename
         if MBOX_CLICKED_NO == FXMessageBox.question(self, MBOX_YES_NO,
           "Overwrite Image", "Overwrite existing image?")
           return 1
diff --git a/examples/inputs.rb b/examples/inputs.rb
index af64aa3a..2e15e419 100755
--- a/examples/inputs.rb
+++ b/examples/inputs.rb
@@ -21,6 +21,7 @@ class InputHandlerWindow < FXMainWindow
 
     # Output will be displayed in a multiline text area
     @cmdOutput = FXText.new(textFrame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y)
+    @cmdInput.text = "ping rubyinstaller.org"
 
     # Initialize the pipe
     @pipe = nil
@@ -30,6 +31,7 @@ class InputHandlerWindow < FXMainWindow
   def create
     super
     show(PLACEMENT_SCREEN)
+    @cmdInput.setFocus
   end
 
   # Remove previous input (if any)
@@ -54,11 +56,14 @@ class InputHandlerWindow < FXMainWindow
     getApp().addInput(@pipe, INPUT_READ|INPUT_EXCEPT) do |sender, sel, ptr|
       case FXSELTYPE(sel)
       when SEL_IO_READ
-        text = @pipe.read_nonblock(256)
-        if text && text.length > 0
-          @cmdOutput.appendText(text)
-        else
+        begin
+          text = @pipe.read_nonblock(256)
+        rescue IO::WaitReadable
+        rescue EOFError
+          @cmdOutput.appendText("[EOF]")
           closePipe
+        else
+          @cmdOutput.appendText(text)
         end
       when SEL_IO_EXCEPT
         #         puts 'onPipeExcept'
diff --git a/examples/pig.rb b/examples/pig.rb
index 32c92b96..6bcbbcaa 100755
--- a/examples/pig.rb
+++ b/examples/pig.rb
@@ -47,9 +47,8 @@ class PigBox < FXMainWindow
       theLabel.layoutHints = LAYOUT_FILL_X
     end
 
-    FXTextField.new(top, 20, @text, FXDataTarget::ID_VALUE) do |theTextField|
+    @theTextField = FXTextField.new(top, 20, @text, FXDataTarget::ID_VALUE) do |theTextField|
       theTextField.layoutHints = LAYOUT_FILL_X
-      theTextField.setFocus()
     end
 
     FXButton.new(top, 'Pig It') do |pigButton|
@@ -66,6 +65,7 @@ class PigBox < FXMainWindow
   def create
     super
     show(PLACEMENT_SCREEN)
+    @theTextField.setFocus
   end
 end
 
diff --git a/examples/textedit/textedit.rb b/examples/textedit/textedit.rb
index 75cf6345..f503a41a 100755
--- a/examples/textedit/textedit.rb
+++ b/examples/textedit/textedit.rb
@@ -1025,7 +1025,7 @@ class TextWindow < FXMainWindow
           return false if (savedialog.execute == 0)
           setCurrentPattern(savedialog.currentPattern)
           file = savedialog.filename
-          if File.exists?(file)
+          if File.exist?(file)
             if MBOX_CLICKED_NO == FXMessageBox.question(self, MBOX_YES_NO,
               "Overwrite Document", "Overwrite existing document: #{file}?")
               return false
@@ -1092,7 +1092,7 @@ class TextWindow < FXMainWindow
     if savedialog.execute != 0
       setCurrentPattern(savedialog.currentPattern)
       file = savedialog.filename
-      if File.exists?(file)
+      if File.exist?(file)
         if MBOX_CLICKED_NO == FXMessageBox.question(self, MBOX_YES_NO,
           "Overwrite Document", "Overwrite existing document: #{file}?")
           return 1
@@ -1134,24 +1134,24 @@ class TextWindow < FXMainWindow
       # Attempt to extract the file name from various forms
       if    string =~ /#include \".*\"/
         file = File.expand_path(name, dir)
-        if !File.exists?(file)
+        if !File.exist?(file)
           Find.find(@searchpath) { |f| file = f if (f == name) }
         end
       elsif string =~ /#include <.*>/
         file = File.expand_path(name, dir)
-        if !File.exists?(file)
+        if !File.exist?(file)
           Find.find(@searchpath) { |f| file = f if (f == name) }
         end
       elsif string =~ /.*:.*:.*/
         file = File.expand_path(name, dir)
-        if !File.exists?(file)
+        if !File.exist?(file)
           Find.find(@searchpath) { |f| file = f if (f == name) }
         end
       else
         file = File.expand_path(string, dir)
       end
 
-      if File.exists?(file)
+      if File.exist?(file)
         # Different from current file?
         if file != @filename
           # Save old file first
@@ -1213,7 +1213,7 @@ class TextWindow < FXMainWindow
     if savedialog.execute != 0
       setCurrentPattern(savedialog.currentPattern)
       file = savedialog.filename
-      if File.exists?(file)
+      if File.exist?(file)
         if MBOX_CLICKED_NO == FXMessageBox.question(self, MBOX_YES_NO,
           "Overwrite Document", "Overwrite existing document: #{file}?")
           return 1
@@ -1690,7 +1690,7 @@ class TextWindow < FXMainWindow
 
   # Update box for readonly display
   def onCheckFile(sender, sel, ptr)
-    mtime = File.exists?(@filename) ? File.mtime(@filename) : nil
+    mtime = File.exist?(@filename) ? File.mtime(@filename) : nil
     if @filetime && mtime && mtime != @filetime
       @filetime = mtime
       if MBOX_CLICKED_OK == FXMessageBox.warning(self, MBOX_OK_CANCEL,
diff --git a/examples/thread.rb b/examples/thread.rb
new file mode 100644
index 00000000..02459def
--- /dev/null
+++ b/examples/thread.rb
@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+require 'fox16'
+
+class ThreadedWindow < Fox::FXMainWindow
+  include Fox
+
+  def initialize(app)
+    # Call the base class initializer first
+    super(app, "Threaded Widget Test", :opts => DECOR_ALL, width: 200, height: 500)
+
+    @vframe = FXVerticalFrame.new(self,
+      FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL, :padding => 0) do |frame|
+      FXButton.new(frame, "Click to add", opts: FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_X) do |button|
+        button.connect(SEL_COMMAND, method(:on_button_clicked))
+      end
+    end
+  end
+
+  def on_button_clicked(sender, sel, ptr)
+    FXHorizontalFrame.new(@vframe,
+      FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL, :padding => 10) do |frame|
+
+      label = FXLabel.new frame, "..."
+
+      Thread.new do
+        50.times do |seconds|
+          runOnUiThread do
+            label.text = "#{(50 - seconds)/10.0} seconds to remove"
+          end
+          sleep 0.1
+        end
+
+        runOnUiThread do
+          @vframe.removeChild(frame)
+          @vframe.create; @vframe.show; @vframe.recalc
+        end
+      end
+    end
+    @vframe.create; @vframe.show; @vframe.recalc
+  end
+
+  # Create and show this window
+  def create
+    super
+    show(PLACEMENT_SCREEN)
+  end
+end
+
+if __FILE__ == $0
+  application = Fox::FXApp.new("ThreadApp", "FoxTest")
+  ThreadedWindow.new(application)
+  application.create
+  application.run
+end
diff --git a/examples/unicode.rb b/examples/unicode.rb
index e899cb7e..a87d13fa 100755
--- a/examples/unicode.rb
+++ b/examples/unicode.rb
@@ -1,36 +1,15 @@
 #!/usr/bin/env ruby
+# -*- encoding: UTF-8 -*-
 
 require 'fox16'
-require 'jcode'
-
-$KCODE = 'UTF8'
-
-class UString < String
-  # Show u-prefix as in Python
-  def inspect; "u#{ super }" end
-
-  # Count multibyte characters
-  def length; self.scan(/./).length end
-
-  # Reverse the string
-  def reverse; self.scan(/./).reverse.join end
-end
-
-module Kernel
-  def u( str )
-    UString.new str.gsub(/U\+([0-9a-fA-F]{4,4})/u){["#$1".hex ].pack('U*')}
-  end
-end
-
-include Fox
 
 # Pass UTF-8 encoded Unicode strings to FXRuby.
-label = u"Les enfants vont U+00E0 l'U+00E9cole.\nLa boulangU+00E8re vend-elle le pain en aoU+00FBt?"
+label = "Les enfants vont \u00E0 l'\u00E9cole.\nLa boulang\u00E8re vend-elle le pain en ao\u00FBt?"
 
-FXApp.new("Unicode Example", "FoxTest") do |app|
-  main = FXMainWindow.new(app, "Unicode Text", nil, nil, DECOR_ALL)
-  FXLabel.new(main, label)
+Fox::FXApp.new("Unicode Example", "FoxTest") do |app|
+  main = Fox::FXMainWindow.new(app, "Unicode Text", nil, nil, Fox::DECOR_ALL)
+  Fox::FXLabel.new(main, label)
   app.create
-  main.show(PLACEMENT_SCREEN)
+  main.show(Fox::PLACEMENT_SCREEN)
   app.run
 end
diff --git a/ext/fox16_c/FXRbApp.cpp b/ext/fox16_c/FXRbApp.cpp
index 11d8bb5a..397aeea6 100644
--- a/ext/fox16_c/FXRbApp.cpp
+++ b/ext/fox16_c/FXRbApp.cpp
@@ -26,29 +26,36 @@
 
 #include "FXRbCommon.h"
 
-#if defined(RUBY_1_8)
-extern "C" {
-#include "rubysig.h" /* For CHECK_INTS */
-}
-#endif
-
 #ifdef HAVE_SYS_TIME_H
 #include <sys/time.h> /* For struct timeval */
 #endif
 
+#ifndef WIN32
+  #include <unistd.h>
+  #include <fcntl.h>
+#endif
+
 // Message map
 FXDEFMAP(FXRbApp) FXRbAppMap[]={
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
+  FXMAPFUNC(SEL_IO_READ,FXRbApp::ID_CHORE_THREADS,FXRbApp::onChoreThreads),
+#else
   FXMAPFUNC(SEL_CHORE,FXRbApp::ID_CHORE_THREADS,FXRbApp::onChoreThreads),
+#endif
   };
 
 // Class implementation
 FXRbIMPLEMENT(FXRbApp,FXApp,FXRbAppMap,ARRAYNUMBER(FXRbAppMap))
 
+#ifdef WIN32
+WSAEVENT FXRbApp::interrupt_event = NULL;
+#else
+int FXRbApp::interrupt_fds[2] = {-1, -1};
+#endif
+
 // Constructor
-FXRbApp::FXRbApp(const FXchar* appname,const FXchar* vendor) : FXApp(appname,vendor),m_bThreadsEnabled(TRUE),sleepTime(100){
-  if(m_bThreadsEnabled){
-    addChore(this,ID_CHORE_THREADS);
-    }
+FXRbApp::FXRbApp(const FXchar* appname,const FXchar* vendor) : FXApp(appname,vendor),m_bThreadsEnabled(FALSE),sleepTime(100){
+  setThreadsEnabled(TRUE);
   }
 
 
@@ -67,12 +74,34 @@ void FXRbApp::setThreadsEnabled(FXbool enabled){
   if(enabled){
     if(!m_bThreadsEnabled){
       m_bThreadsEnabled=TRUE;
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
+#ifdef WIN32
+      interrupt_event = CreateEvent(NULL, TRUE, FALSE, NULL);
+      addInput(interrupt_event,INPUT_READ,this,ID_CHORE_THREADS);
+#else
+      if(pipe(interrupt_fds) == -1) rb_fatal("failed to allocate pipe for interrupt events");
+      fcntl(interrupt_fds[0], F_SETFL, O_NONBLOCK);
+      addInput(interrupt_fds[0],INPUT_READ,this,ID_CHORE_THREADS);
+#endif
+#else
       addChore(this,ID_CHORE_THREADS);
+#endif
       }
     }
   else{
     m_bThreadsEnabled=FALSE;
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
+#ifdef WIN32
+    removeInput(interrupt_event,INPUT_READ);
+    CloseHandle(interrupt_event); interrupt_event = NULL;
+#else
+    removeInput(interrupt_fds[0],INPUT_READ);
+    close(interrupt_fds[0]); interrupt_fds[0] = -1;
+    close(interrupt_fds[1]); interrupt_fds[1] = -1;
+#endif
+#else
     removeChore(this,ID_CHORE_THREADS);
+#endif
     }
   }
 
@@ -88,36 +117,57 @@ FXuint FXRbApp::getSleepTime() const {
   return sleepTime;
   }
 
+long FXRbApp::onChoreThreads(FXObject *obj,FXSelector sel,void *p){
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
+#ifdef WIN32
+  ResetEvent(interrupt_event);
+#else
+  char byte;
+  // clear the pipe
+  if(read(interrupt_fds[0], &byte, 1) != 1) rb_fatal("failed to read from pipe for interrupt events");
+#endif
+#endif
+  return FXRbApp_onChoreThreads(this, obj, sel, p);
+  }
+
+long FXRbApp_onChoreThreads_gvlcb(FXRbApp *self,FXObject *obj,FXSelector sel,void *p){
+  return self->onChoreThreads_gvlcb(obj, sel, p);
+  }
 
 // Process threads
-long FXRbApp::onChoreThreads(FXObject*,FXSelector,void*){
+long FXRbApp::onChoreThreads_gvlcb(FXObject*,FXSelector,void*){
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
+#else
   // Pause for 'sleepTime' millseconds
   struct timeval wait;
   wait.tv_sec=0;
   wait.tv_usec=100*sleepTime;
 
-  // Confirm that this thread can be interrupted, then go to sleep
-#if defined(RUBY_1_8)
-  CHECK_INTS;
-  if(!rb_thread_critical)
-    rb_thread_wait_for(wait);
-#else
-  // if(!rb_thread_critical) rb_thread_wait_for(wait);
   rb_thread_wait_for(wait);
-#endif /* RUBY_1_8 */
 
   // Re-register this chore for next time
   addChore(this,ID_CHORE_THREADS);
+#endif
 
   // Back to work...
   return 1;
   }
 
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
+void fxrb_wakeup_fox(void *){
+#ifdef WIN32
+  SetEvent(FXRbApp::interrupt_event);
+#else
+  if(write(FXRbApp::interrupt_fds[1], "X", 1) != 1) rb_fatal("failed to write to pipe for interrupt events");
+#endif
+  }
+#endif
 
 // Destructor
 FXRbApp::~FXRbApp(){
   FXTRACE((100,"FXRbApp::~FXRbApp()\n"));
   VALUE myRegistry;
+  setThreadsEnabled(FALSE);
   FXRbDestroyAppSensitiveObjects();
   myRegistry=FXRbGetRubyObj(&(reg()),true);
   if(!NIL_P(myRegistry)){
diff --git a/ext/fox16_c/FXRbObjRegistry.cpp b/ext/fox16_c/FXRbObjRegistry.cpp
new file mode 100644
index 00000000..953adcb3
--- /dev/null
+++ b/ext/fox16_c/FXRbObjRegistry.cpp
@@ -0,0 +1,169 @@
+/***********************************************************************
+ * FXRuby -- the Ruby language bindings for the FOX GUI toolkit.
+ * Copyright (c) 2017-2017 by Lyle Johnson. All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * For further information please contact the author by e-mail
+ * at "lars@greiz-reinsdorf.de".
+ ***********************************************************************/
+
+#include "FXRbCommon.h"
+#include "FXRbObjRegistry.h"
+#include "swigruby.h"
+
+FXRbObjRegistry::FXRbObjRegistry(){
+  FXRuby_Objects=st_init_numtable();
+}
+
+const char * FXRbObjRegistry::safe_rb_obj_classname(VALUE obj)
+{
+  int tdata = TYPE(obj)==T_DATA;
+  if( (tdata && IsInGC(DATA_PTR(obj)))
+#ifdef HAVE_RB_DURING_GC
+      || rb_during_gc()
+#endif
+  ){
+    /* It's not safe to call rb_obj_classname() during GC.
+    * Return dummy value in this case. */
+    return "during GC";
+  } else if (tdata) {
+    return rb_obj_classname(obj);
+  } else {
+    return "no T_DATA";
+  }
+}
+
+VALUE FXRbObjRegistry::NewBorrowedObj(void *ptr,swig_type_info* ty){
+  if(ptr!=0){
+    FXASSERT(ty!=0);
+    ObjDesc *desc;
+
+    if(FXMALLOC(&desc,ObjDesc,1)){
+      VALUE obj = SWIG_Ruby_NewPointerObj(ptr,ty,1);
+      FXTRACE((1,"FXRbNewPointerObj(foxObj=%p) => rubyObj=%p (%s)\n",ptr,(void *)obj,safe_rb_obj_classname(obj)));
+      desc->obj = obj;
+      desc->type = borrowed;
+      desc->in_gc = false;
+      int overwritten = st_insert(FXRuby_Objects,reinterpret_cast<st_data_t>(ptr),reinterpret_cast<st_data_t>(desc));
+      FXASSERT(!overwritten);
+      return obj;
+    } else {
+      FXASSERT(FALSE);
+      return Qnil;
+    }
+  }
+  else{
+    return Qnil;
+  }
+}
+
+void FXRbObjRegistry::RegisterRubyObj(VALUE rubyObj,const void* foxObj) {
+  FXASSERT(!NIL_P(rubyObj));
+  FXASSERT(foxObj!=0);
+  ObjDesc* desc;
+  FXTRACE((1,"FXRbRegisterRubyObj(rubyObj=%p (%s),foxObj=%p)\n",(void *)rubyObj,safe_rb_obj_classname(rubyObj),foxObj));
+  if(st_lookup(FXRuby_Objects,reinterpret_cast<st_data_t>(const_cast<void*>(foxObj)),reinterpret_cast<st_data_t *>(&desc))!=0){
+    FXASSERT(desc->type == borrowed);
+    /* There is already a Ruby object registered for this foxObj.
+     * This can happen, if libfox calls methods out of the C++ object constructor,
+     * that can be overwritten in Ruby (like changeFocus) with the object as
+     * parameter. FXFileSelector is one example.
+     * To avoid double references to the same foxObj from different Ruby objects,
+     * we decouple the foxObj from previoius ruby object and point to the new one.
+     */
+    DATA_PTR(desc->obj) = 0;
+    desc->obj = rubyObj;
+    desc->type = own;
+  } else {
+    if(FXMALLOC(&desc,ObjDesc,1)){
+      desc->obj = rubyObj;
+      desc->type = own;
+      desc->in_gc = false;
+      int overwritten = st_insert(FXRuby_Objects,reinterpret_cast<st_data_t>(const_cast<void*>(foxObj)),reinterpret_cast<st_data_t>(desc));
+      FXASSERT(!overwritten);
+    } else {
+      FXASSERT(FALSE);
+    }
+  }
+  FXASSERT(GetRubyObj(foxObj,false)==rubyObj);
+}
+
+void FXRbObjRegistry::UnregisterRubyObj(const void* foxObj, bool alsoOwned){
+  if(foxObj!=0){
+    ObjDesc* desc;
+    if(st_lookup(FXRuby_Objects,reinterpret_cast<st_data_t>(const_cast<void*>(foxObj)),reinterpret_cast<st_data_t *>(&desc))!=0){
+      if( !alsoOwned && desc->type!=borrowed ) return;
+      FXTRACE((1,"FXRbUnregisterRubyObj(rubyObj=%p (%s),foxObj=%p)\n",(void *)desc->obj,safe_rb_obj_classname(desc->obj),foxObj));
+      DATA_PTR(desc->obj)=0;
+      FXFREE(&desc);
+      st_delete(FXRuby_Objects,reinterpret_cast<st_data_t *>(const_cast<void**>(&foxObj)),reinterpret_cast<st_data_t *>(0));
+      FXASSERT(st_lookup(FXRuby_Objects,reinterpret_cast<st_data_t>(const_cast<void*>(foxObj)),reinterpret_cast<st_data_t *>(0))==0);
+    }
+  }
+}
+
+
+VALUE FXRbObjRegistry::GetRubyObj(const void *foxObj,bool alsoBorrowed, bool in_gc_mark){
+  ObjDesc* desc;
+  if(foxObj!=0 && st_lookup(FXRuby_Objects,reinterpret_cast<st_data_t>(const_cast<void*>(foxObj)),reinterpret_cast<st_data_t *>(&desc))!=0){
+    FXASSERT(desc!=0);
+    if(alsoBorrowed || desc->type!=borrowed){
+      const char *classname = in_gc_mark ? "in GC" : safe_rb_obj_classname(desc->obj);
+      FXTRACE((2,"%s(foxObj=%p) => rubyObj=%p (%s)\n", in_gc_mark ? "FXRbGcMark" : "FXRbGetRubyObj", foxObj, (void *)desc->obj, classname));
+      return desc->obj;
+    }
+  }
+  return Qnil;
+}
+
+
+bool FXRbObjRegistry::IsBorrowed(void* ptr){
+  FXASSERT(ptr!=0);
+  ObjDesc *desc;
+  if(st_lookup(FXRuby_Objects,reinterpret_cast<st_data_t>(ptr),reinterpret_cast<st_data_t *>(&desc))!=0){
+    return desc->type == borrowed;
+  }
+  else{
+    return true;
+  }
+}
+
+bool FXRbObjRegistry::SetInGC(const void* ptr, bool enabled){
+  FXASSERT(ptr!=0);
+  ObjDesc *desc;
+  if(st_lookup(FXRuby_Objects,reinterpret_cast<st_data_t>(ptr),reinterpret_cast<st_data_t *>(&desc))!=0){
+    desc->in_gc=enabled;
+    return enabled;
+  }
+  return false;
+}
+
+bool FXRbObjRegistry::IsInGC(const void* ptr){
+  FXASSERT(ptr!=0);
+  ObjDesc *desc;
+
+#ifdef HAVE_RB_DURING_GC
+  if( rb_during_gc() ){
+    return true;
+  }
+#endif
+  if(st_lookup(FXRuby_Objects,reinterpret_cast<st_data_t>(ptr),reinterpret_cast<st_data_t *>(&desc))!=0){
+    return desc->in_gc;
+  }
+  return false;
+}
+
+FXRbObjRegistry FXRbObjRegistry::main;
diff --git a/ext/fox16_c/FXRuby.cpp b/ext/fox16_c/FXRuby.cpp
index 61f1715b..5e138962 100644
--- a/ext/fox16_c/FXRuby.cpp
+++ b/ext/fox16_c/FXRuby.cpp
@@ -29,6 +29,7 @@
 #endif
 
 #include "FXRbCommon.h"
+#include "FXRbObjRegistry.h"
 #include "impl.h"
 
 // SWIG runtime functions we need
@@ -42,24 +43,18 @@
 #include <signal.h>	// for definitions of SIGINT, etc.
 #endif
 
-#if defined(RUBY_1_8)
-
-extern "C" {
-#include "st.h"
-#include "rubyio.h"     // for GetOpenFile(), etc.
-}
-
-#else
-
 #include "ruby/io.h"
 #include "ruby/st.h"
 
-#endif /* RUBY_1_8 */
-
 
 // Opaque type declaration from SWIG runtime
 struct swig_type_info;
 
+static int FXSWIG_ConvertPtr(VALUE obj, void **ptr, swig_type_info *ty, int flags){
+  return SWIG_ConvertPtr(obj, ptr, ty, flags);
+}
+
+
 // Wrapper around SWIG_TypeQuery() that caches results for performance
 swig_type_info *FXRbTypeQuery(const char *desc){
   FXASSERT(desc!=0);
@@ -74,64 +69,13 @@ swig_type_info *FXRbTypeQuery(const char *desc){
   }
 
 
-/**
- * The FXRuby_Objects hash table basically maps C++ objects to Ruby instances.
- * Each key in the table is a pointer to a C++ object we've seen before, and
- * the corresponding value is an FXRubyObjDesc struct (see below) that tells
- * us which Ruby instance corresponds to that C++ object.
- */
-
-static st_table * FXRuby_Objects;
-
-/**
- * Each value in the FXRuby_Objects hash table is an instance of this
- * struct. It identifies the Ruby instance associated with a C++ object.
- * It also indicates whether this is merely a "borrowed" reference to
- * some C++ object (i.e. it's not one we need to destroy later).
- *
- * in_gc is set for FXWindows that are in garbage collection and must
- * not call ruby code anymore.
- */
-
-struct FXRubyObjDesc {
-  VALUE obj;
-  bool borrowed;
-  bool in_gc;
-  };
-
-
-/**
- * FXRbNewPointerObj() is a wrapper around SWIG_Ruby_NewPointerObj() that also
- * registers this C++ object & Ruby instance pair in our FXRuby_Objects
- * hash table. This function should only get called for methods that return
- * a reference to an already-existing C++ object (i.e. one that FOX "owns")
- * and for that reason we mark these objects as "borrowed".
- */
-
 VALUE FXRbNewPointerObj(void *ptr,swig_type_info* ty){
-  if(ptr!=0){
-    FXASSERT(ty!=0);
-    VALUE obj;
-    FXRubyObjDesc *desc;
-    if(FXMALLOC(&desc,FXRubyObjDesc,1)){
-      obj=SWIG_Ruby_NewPointerObj(ptr,ty,1);
-      FXTRACE((1,"FXRbNewPointerObj(rubyObj=%d,foxObj=%p)\n",static_cast<int>(obj),ptr));
-      desc->obj=obj;
-      desc->borrowed=true;
-      desc->in_gc=false;
-      int overwritten = st_insert(FXRuby_Objects,reinterpret_cast<st_data_t>(ptr),reinterpret_cast<st_data_t>(desc));
-      FXASSERT(!overwritten);
-      return obj;
-      }
-    else{
-      FXASSERT(FALSE);
-      return Qnil;
-      }
-    }
-  else{
-    return Qnil;
-    }
-  }
+  return FXRbObjRegistry::main.NewBorrowedObj(ptr,ty);
+}
+
+VALUE FXRbNewPointerObjCb(void *ptr,swig_type_info* ty){
+  return SWIG_Ruby_NewPointerObj(ptr, ty, 1);
+}
 
 
 /**
@@ -140,205 +84,136 @@ VALUE FXRbNewPointerObj(void *ptr,swig_type_info* ty){
  */
 
 bool FXRbIsBorrowed(void* ptr){
-  FXASSERT(ptr!=0);
-  FXRubyObjDesc *desc;
-  if(st_lookup(FXRuby_Objects,reinterpret_cast<st_data_t>(ptr),reinterpret_cast<st_data_t *>(&desc))!=0){
-    return desc->borrowed;
-    }
-  else{
-    return true;
-    }
-  }
+  return FXRbObjRegistry::main.IsBorrowed(ptr);
+}
 
 bool FXRbSetInGC(const void* ptr, bool enabled){
-  FXASSERT(ptr!=0);
-  FXRubyObjDesc *desc;
-  if(st_lookup(FXRuby_Objects,reinterpret_cast<st_data_t>(ptr),reinterpret_cast<st_data_t *>(&desc))!=0){
-    desc->in_gc=enabled;
-    return enabled;
-    }
-  return false;
-  }
+  return FXRbObjRegistry::main.SetInGC(ptr, enabled);
+}
 
 bool FXRbIsInGC(const void* ptr){
-  FXASSERT(ptr!=0);
-  FXRubyObjDesc *desc;
-  if(st_lookup(FXRuby_Objects,reinterpret_cast<st_data_t>(ptr),reinterpret_cast<st_data_t *>(&desc))!=0){
-    return desc->in_gc;
-    }
-  return false;
-  }
-
-
-/**
- * FXRbConvertPtr() is just a wrapper around SWIG_ConvertPtr().
- */
-
-void* FXRbConvertPtr(VALUE obj,swig_type_info* ty){
-  void *ptr;
-  SWIG_ConvertPtr(obj,&ptr,ty,1);
-  return ptr;
-  }
-
-
-// Should we catch exceptions thrown by message handlers?
-FXbool FXRbCatchExceptions=FALSE;
-
-// Returns an FXInputHandle for this Ruby file object
-FXInputHandle FXRbGetReadFileHandle(VALUE obj) {
-  int fd;
-  fd = FIX2INT(rb_funcall(obj, rb_intern("fileno"), 0));
-#ifdef WIN32
-#ifdef __CYGWIN__
-  return (FXInputHandle) get_osfhandle(fd);
-#else
-  return (FXInputHandle) _get_osfhandle(fd);
-#endif
-#else
-  return (FXInputHandle) fd;
-#endif
-  }
-
-
-// Returns an FXInputHandle for this Ruby file object
-FXInputHandle FXRbGetWriteFileHandle(VALUE obj) {
-  int fd;
-#if defined(RUBINIUS)
-  VALUE vwrite = rb_intern("@write");
-  if(rb_ivar_defined(obj, vwrite)) obj = rb_ivar_get(obj, vwrite);
-  fd = FIX2INT(rb_funcall(obj, rb_intern("fileno"), 0));
-#elif defined(RUBY_1_8)
-  OpenFile *fptr;
-  GetOpenFile(obj, fptr);
-  FILE *fpw=GetWriteFile(fptr);
-  fd = fileno(fpw);
-#else
-  rb_io_t *fptr;
-  GetOpenFile(obj, fptr);
-  VALUE wrio = fptr->tied_io_for_writing;
-  if(wrio) obj = wrio;
-  fd = FIX2INT(rb_funcall(obj, rb_intern("fileno"), 0));
-#endif
-#ifdef WIN32
-#ifdef __CYGWIN__
-  return (FXInputHandle) get_osfhandle(fd);
-#else
-  return (FXInputHandle) _get_osfhandle(fd);
-#endif
-#else
-  return (FXInputHandle) fd;
-#endif
-  }
+  return FXRbObjRegistry::main.IsInGC(ptr);
+}
 
 
 // Register this Ruby class instance
 void FXRbRegisterRubyObj(VALUE rubyObj,const void* foxObj) {
-  FXASSERT(!NIL_P(rubyObj));
-  FXASSERT(foxObj!=0);
-  FXRubyObjDesc* desc;
-  FXTRACE((1,"FXRbRegisterRubyObj(rubyObj=%d,foxObj=%p)\n",static_cast<int>(rubyObj),foxObj));
-  if(st_lookup(FXRuby_Objects,reinterpret_cast<st_data_t>(const_cast<void*>(foxObj)),reinterpret_cast<st_data_t *>(&desc))!=0){
-    FXASSERT(desc->borrowed);
-    /* There is already a Ruby object registered for this foxObj.
-     * This can happen, if libfox calls methods out of the C++ object constructor,
-     * that can be overwritten in Ruby (like changeFocus) with the object as
-     * parameter. FXFileSelector is one example.
-     * To avoid double references to the same foxObj from different Ruby objects,
-     * we decouple the foxObj from previoius ruby object and point to the new one.
-     */
-    DATA_PTR(desc->obj) = 0;
-    desc->obj=rubyObj;
-    desc->borrowed=false;
-    }
-  else{
-    if(FXMALLOC(&desc,FXRubyObjDesc,1)){
-      desc->obj=rubyObj;
-      desc->borrowed=false;
-      desc->in_gc=false;
-      int overwritten = st_insert(FXRuby_Objects,reinterpret_cast<st_data_t>(const_cast<void*>(foxObj)),reinterpret_cast<st_data_t>(desc));
-      FXASSERT(!overwritten);
-      }
-    else{
-      FXASSERT(FALSE);
-      }
-    }
-  FXASSERT(FXRbGetRubyObj(foxObj,false)==rubyObj);
-  }
+  return FXRbObjRegistry::main.RegisterRubyObj(rubyObj, foxObj);
+}
+
+static void FXRbUnregisterRubyObj2(const void* foxObj, bool alsoOwned){
+  return FXRbObjRegistry::main.UnregisterRubyObj(foxObj, alsoOwned);
+}
 
 /**
  * Remove this mapping between a Ruby instance and a C++ object
  */
 void FXRbUnregisterRubyObj(const void* foxObj){
-  if(foxObj!=0){
-    FXRubyObjDesc* desc;
-    if(st_lookup(FXRuby_Objects,reinterpret_cast<st_data_t>(const_cast<void*>(foxObj)),reinterpret_cast<st_data_t *>(&desc))!=0){
-      FXTRACE((1,"FXRbUnregisterRubyObj(rubyObj=%d,foxObj=%p)\n",static_cast<int>(desc->obj),foxObj));
-      DATA_PTR(desc->obj)=0;
-      FXFREE(&desc);
-      st_delete(FXRuby_Objects,reinterpret_cast<st_data_t *>(const_cast<void**>(&foxObj)),reinterpret_cast<st_data_t *>(0));
-      FXASSERT(st_lookup(FXRuby_Objects,reinterpret_cast<st_data_t>(const_cast<void*>(foxObj)),reinterpret_cast<st_data_t *>(0))==0);
-      }
-    }
-  }
+  FXRbUnregisterRubyObj2(foxObj, true);
+}
 
 
-VALUE to_ruby(const FXObject* obj){
-  if(obj!=0){
-    FXString className=obj->getClassName();
-    if(className.length()>3){
-      if(className.left(4)=="FXRb"){ className.replace(0,4,"FX"); }
-      }
-    FXString desc=className+" *";
-    return FXRbGetRubyObj(obj,desc.text());
-    }
-  return Qnil;
-  }
-
+/* We now have 3 types of FXObject wrappers:
+ *
+ * Own objects :
+ * These objects are allocated by FXRuby on the heap.
+ * They are free'd when the FXRuby wrapper is GC'ed and no other reference to the object exists.
+ * They are registered in FXRbObjRegistry as owned object.
+ * They are built per FXRbRegisterRubyObj().
+ *
+ * Borrowed objects :
+ * These objects are allocated by libfox on the heap.
+ * They are free'd by libfox when the owning fox object gets destroyed.
+ * Only the ruby wrapper is GC'ed.
+ * They are registered in FXRbObjRegistry as borrowed object.
+ * They are built per FXGetRubyObj().
+ *
+ * Callback objects :
+ * This is the new type.
+ * These objects are allocated by libfox on the heap or on the stack.
+ * They are wrapped for the time of one callback only, because stack memory is free'd afterwards.
+ * They are not registered in FXRbObjRegistry, but stored on the stack only.
+ * Therefore callback objects aren't re-used, but newly wrapped for each call.
+ * The same goes for arguments to ruby blocks.
+ * They are built per FXGetRubyObjCb().
+ */
 
 /**
  * Return the registered Ruby class instance associated with this
  * FOX object, or Qnil if not found.
  */
-VALUE FXRbGetRubyObj(const void *foxObj,bool searchBoth){
-  FXRubyObjDesc* desc;
-  if(foxObj!=0 && st_lookup(FXRuby_Objects,reinterpret_cast<st_data_t>(const_cast<void*>(foxObj)),reinterpret_cast<st_data_t *>(&desc))!=0){
-    FXASSERT(desc!=0);
-    if(searchBoth){
-      return desc->obj;
-      }
-    else{
-      return desc->borrowed ? Qnil : desc->obj;
-      }
-    }
-  else{
-    return Qnil;
-    }
-  }
+VALUE FXRbGetRubyObj(const void *foxObj,bool alsoBorrowed, bool in_gc_mark){
+  return FXRbObjRegistry::main.GetRubyObj(foxObj, alsoBorrowed, in_gc_mark);
+}
 
 /**
  * Return the registered Ruby class instance associated with this
- * FOX object, or a new registered instance if not found.
+ * FOX object, or a new registered instance of a borrowed object if not found.
+ *
+ * This is suitable for objects on the heap, but not suitable for callbacks,
+ * because callback values might be on the stack.
+ * These stack objects should not be registered, because they are temporary only.
  */
 VALUE FXRbGetRubyObj(const void *foxObj,swig_type_info* ty){
   if(foxObj!=0){
     VALUE rbObj=FXRbGetRubyObj(foxObj,true);
-    return NIL_P(rbObj) ? FXRbNewPointerObj(const_cast<void*>(foxObj),ty) : rbObj;
+    if( NIL_P(rbObj) ){
+      return FXRbNewPointerObj(const_cast<void*>(foxObj),ty);
+    }else{
+      // The requested type should match the registered class.
+      FXASSERT(SWIG_CheckConvert(rbObj, ty));
+      return rbObj;
     }
-  else{
+  }else{
     return Qnil;
-    }
   }
+}
 
 VALUE FXRbGetRubyObj(const void *foxObj,const char *type){
+  return FXRbGetRubyObj(foxObj, FXRbTypeQuery(type));
+}
+
+/* Get an already registered object or wrap a new one for use in a callback.
+ *
+ * This is suitable for objects on the heap or on the stack.
+ * If an object is already registered per FXRbGetRubyObj(), this instance is returned.
+ * If it is not registered, a new wrapping object is built and returned, but is not registered.
+ */
+VALUE FXRbGetRubyObjCb(const void *foxObj,swig_type_info* ty){
   if(foxObj!=0){
-    FXASSERT(type!=0);
-    VALUE rbObj=FXRbGetRubyObj(foxObj,true);
-    return NIL_P(rbObj) ? FXRbNewPointerObj(const_cast<void*>(foxObj),FXRbTypeQuery(type)) : rbObj;
+    VALUE rbObj=FXRbGetRubyObj(foxObj, true);
+    if( NIL_P(rbObj) ){
+      return FXRbNewPointerObjCb(const_cast<void*>(foxObj), ty);
+    }else{
+      // The requested type should match the registered class.
+      FXASSERT(SWIG_CheckConvert(rbObj, ty));
+      return rbObj;
     }
-  else{
+  }else{
     return Qnil;
+  }
+}
+
+static VALUE to_ruby_obj(const FXObject* obj, VALUE (*get_value)(const void*, swig_type_info*)){
+  if(obj){
+    FXString className = obj->getClassName();
+    if(className.length() > 3){
+      if(className.left(4)=="FXRb"){ className.replace(0,4,"FX"); }
     }
+    FXString desc = className+" *";
+    return get_value(obj, FXRbTypeQuery(desc.text()));
   }
+  return Qnil;
+}
+
+VALUE to_ruby(const FXObject* obj){
+  return to_ruby_obj(obj, FXRbGetRubyObj);
+}
+
+VALUE to_ruby_cb(const FXObject* obj){
+  return to_ruby_obj(obj, FXRbGetRubyObjCb);
+}
+
 
 /**
  * Look up the Ruby instance associated with this C++ object, if any, and mark
@@ -362,7 +237,7 @@ void FXRbGcMark(void *obj){
      * example program works if you invoke the GC in ShutterWindow#create;
      * make sure that the shutter items' contents don't get blown away!
      */
-    VALUE value=FXRbGetRubyObj(obj,true);
+    VALUE value=FXRbGetRubyObj(obj, true, true);
     if(!NIL_P(value)){
       rb_gc_mark(value);
       }
@@ -415,7 +290,7 @@ VALUE FXRbMakeArray(const FXchar* dashpattern,FXuint dashlength){
 VALUE FXRbMakeArray(const FXArc* arcs,FXuint narcs){
   VALUE result=rb_ary_new();
   for(FXuint i=0; i<narcs; i++)
-    rb_ary_push(result,FXRbGetRubyObj(&arcs[i],"FXArc *"));
+    rb_ary_push(result, FXRbNewPointerObjCb(const_cast<FXArc*>(&arcs[i]), FXRbTypeQuery("FXArc *")));
   return result;
   }
 
@@ -423,7 +298,7 @@ VALUE FXRbMakeArray(const FXArc* arcs,FXuint narcs){
 VALUE FXRbMakeArray(const FXPoint* points,FXuint npoints){
   VALUE result=rb_ary_new();
   for(FXuint i=0; i<npoints; i++)
-    rb_ary_push(result,FXRbGetRubyObj(&points[i],"FXPoint *"));
+    rb_ary_push(result,FXRbNewPointerObjCb(const_cast<FXPoint*>(&points[i]), FXRbTypeQuery("FXPoint *")));
   return result;
   }
 
@@ -431,7 +306,7 @@ VALUE FXRbMakeArray(const FXPoint* points,FXuint npoints){
 VALUE FXRbMakeArray(const FXRectangle* rectangles,FXuint nrectangles){
   VALUE result=rb_ary_new();
   for(FXuint i=0; i<nrectangles; i++)
-    rb_ary_push(result,FXRbGetRubyObj(&rectangles[i],"FXRectangle *"));
+    rb_ary_push(result,FXRbNewPointerObjCb(const_cast<FXRectangle*>(&rectangles[i]), FXRbTypeQuery("FXRectangle *")));
   return result;
   }
 
@@ -439,14 +314,14 @@ VALUE FXRbMakeArray(const FXRectangle* rectangles,FXuint nrectangles){
 VALUE FXRbMakeArray(const FXSegment* segments,FXuint nsegments){
   VALUE result=rb_ary_new();
   for(FXuint i=0; i<nsegments; i++)
-    rb_ary_push(result,FXRbGetRubyObj(&segments[i],"FXSegment *"));
+    rb_ary_push(result,FXRbNewPointerObjCb(const_cast<FXSegment*>(&segments[i]), FXRbTypeQuery("FXSegment *")));
   return result;
   }
 
 // Returns a Ruby array of FXColor values
 VALUE FXRbMakeColorArray(const FXColor* colors,FXint w,FXint h){
   VALUE result=rb_ary_new();
-  FXint size=w*h;
+  FXuint size=w*h;
   for(FXuint i=0; i<size; i++)
     rb_ary_push(result,to_ruby(colors[i]));
   return result;
@@ -499,7 +374,6 @@ FXColor *FXRbConvertToFXColors(VALUE string_or_ary, FXuint *opts){
  */
 static VALUE FXRbConvertMessageData(FXObject* sender,FXObject* recv,FXSelector sel,void* ptr){
   FXTRACE((1,"FXRbConvertMessageData(%s(%p),FXSEL(%s,%d),%p)\n",sender->getClassName(),sender,FXDebugTarget::messageTypeName[FXSELTYPE(sel)],FXSELID(sel),ptr));
-  FXInputHandle fff;
   FXushort type=FXSELTYPE(sel);
   FXushort id=FXSELID(sel);
 
@@ -555,22 +429,17 @@ static VALUE FXRbConvertMessageData(FXObject* sender,FXObject* recv,FXSelector s
      type==SEL_PICKED ||
      type==SEL_SESSION_NOTIFY ||
      type==SEL_SESSION_CLOSED) {
-    return to_ruby(reinterpret_cast<FXEvent*>(ptr));
+    return to_ruby_cb(reinterpret_cast<FXEvent*>(ptr));
     }
   else if(type==SEL_DRAGGED && !sender->isMemberOf(FXMETACLASS(FXGLViewer))){
-    return to_ruby(reinterpret_cast<FXEvent*>(ptr));
+    return to_ruby_cb(reinterpret_cast<FXEvent*>(ptr));
     }
   else if(type==SEL_SIGNAL){
-    return to_ruby(static_cast<int>(reinterpret_cast<FXuval>(ptr)));
+    return to_ruby_cb(static_cast<int>(reinterpret_cast<FXuval>(ptr)));
     }
   else if(type==SEL_IO_READ ||
           type==SEL_IO_WRITE ||
 	  type==SEL_IO_EXCEPT){
-#ifdef WIN32
-    fff=reinterpret_cast<FXInputHandle>(ptr);
-#else
-    fff=static_cast<FXInputHandle>(reinterpret_cast<long>(ptr));
-#endif
     return Qnil;
     }
   else if(type==SEL_CLOSE ||
@@ -588,37 +457,37 @@ static VALUE FXRbConvertMessageData(FXObject* sender,FXObject* recv,FXSelector s
     if(type==SEL_CHANGED||type==SEL_COMMAND) return Qnil;
     }
   else if(sender->isMemberOf(FXMETACLASS(FXArrowButton))){
-    if(type==SEL_COMMAND) return to_ruby(static_cast<FXuint>(reinterpret_cast<FXuval>(ptr)));
+    if(type==SEL_COMMAND) return to_ruby_cb(static_cast<FXuint>(reinterpret_cast<FXuval>(ptr)));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXPicker))){
-    if(type==SEL_COMMAND || type==SEL_CHANGED) return to_ruby(reinterpret_cast<FXPoint*>(ptr));
+    if(type==SEL_COMMAND || type==SEL_CHANGED) return to_ruby_cb(reinterpret_cast<FXPoint*>(ptr));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXButton))){
     if(type==SEL_CLICKED ||
        type==SEL_DOUBLECLICKED ||
        type==SEL_TRIPLECLICKED ||
-       type==SEL_COMMAND) return to_ruby(static_cast<FXuint>(reinterpret_cast<FXuval>(ptr)));
+       type==SEL_COMMAND) return to_ruby_cb(static_cast<FXuint>(reinterpret_cast<FXuval>(ptr)));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXCheckButton))){
-    if(type==SEL_COMMAND) return to_ruby(static_cast<FXuchar>(reinterpret_cast<FXuval>(ptr)));
+    if(type==SEL_COMMAND) return to_ruby_cb(static_cast<FXuchar>(reinterpret_cast<FXuval>(ptr)));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXColorBar))){
     if(type==SEL_CHANGED || type==SEL_COMMAND){
       FXfloat* hsv=reinterpret_cast<FXfloat*>(ptr);
-      return rb_ary_new3(3,to_ruby(hsv[0]),to_ruby(hsv[1]),to_ruby(hsv[2]));
+      return rb_ary_new3(3,to_ruby_cb(hsv[0]),to_ruby_cb(hsv[1]),to_ruby_cb(hsv[2]));
       }
     }
   else if(sender->isMemberOf(FXMETACLASS(FXColorDialog))){
-    if(type==SEL_CHANGED || type==SEL_COMMAND) return to_ruby(static_cast<FXColor>(reinterpret_cast<FXuval>(ptr)));
+    if(type==SEL_CHANGED || type==SEL_COMMAND) return to_ruby_cb(static_cast<FXColor>(reinterpret_cast<FXuval>(ptr)));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXColorRing))){
     if(type==SEL_CHANGED || type==SEL_COMMAND){
       FXfloat* hsv=reinterpret_cast<FXfloat*>(ptr);
-      return rb_ary_new3(3,to_ruby(hsv[0]),to_ruby(hsv[1]),to_ruby(hsv[2]));
+      return rb_ary_new3(3,to_ruby_cb(hsv[0]),to_ruby_cb(hsv[1]),to_ruby_cb(hsv[2]));
       }
     }
   else if(sender->isMemberOf(FXMETACLASS(FXColorSelector))){
-    if(type==SEL_CHANGED || type==SEL_COMMAND) return to_ruby(static_cast<FXColor>(reinterpret_cast<FXuval>(ptr)));
+    if(type==SEL_CHANGED || type==SEL_COMMAND) return to_ruby_cb(static_cast<FXColor>(reinterpret_cast<FXuval>(ptr)));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXColorWell))){
     if(type==SEL_CHANGED ||
@@ -626,29 +495,29 @@ static VALUE FXRbConvertMessageData(FXObject* sender,FXObject* recv,FXSelector s
        type==SEL_CLICKED ||
        type==SEL_DOUBLECLICKED ||
        type==SEL_TRIPLECLICKED) {
-	       VALUE v=to_ruby(static_cast<FXColor>(reinterpret_cast<FXuval>(ptr)));
+	       VALUE v=to_ruby_cb(static_cast<FXColor>(reinterpret_cast<FXuval>(ptr)));
 	       return v;
     }
     }
   else if(sender->isMemberOf(FXMETACLASS(FXColorWheel))){
     if(type==SEL_CHANGED || type==SEL_COMMAND){
       FXfloat* hsv=reinterpret_cast<FXfloat*>(ptr);
-      return rb_ary_new3(3,to_ruby(hsv[0]),to_ruby(hsv[1]),to_ruby(hsv[2]));
+      return rb_ary_new3(3,to_ruby_cb(hsv[0]),to_ruby_cb(hsv[1]),to_ruby_cb(hsv[2]));
       }
     }
   else if(sender->isMemberOf(FXMETACLASS(FXComboBox))){
-    if(type==SEL_CHANGED || type==SEL_COMMAND) return to_ruby(reinterpret_cast<FXchar*>(ptr));
+    if(type==SEL_CHANGED || type==SEL_COMMAND) return to_ruby_cb(reinterpret_cast<FXchar*>(ptr));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXDataTarget))){
     if(type==SEL_COMMAND || type==SEL_CHANGED){
       if(recv->isMemberOf(FXMETACLASS(FXWindow))){
         switch(id){
           case FXWindow::ID_SETINTVALUE:
-            return to_ruby(*reinterpret_cast<FXint*>(ptr));
+            return to_ruby_cb(*reinterpret_cast<FXint*>(ptr));
           case FXWindow::ID_SETREALVALUE:
-            return to_ruby(*reinterpret_cast<FXdouble*>(ptr));
+            return to_ruby_cb(*reinterpret_cast<FXdouble*>(ptr));
           case FXWindow::ID_SETSTRINGVALUE:
-            return to_ruby(*reinterpret_cast<FXString*>(ptr));
+            return to_ruby_cb(*reinterpret_cast<FXString*>(ptr));
           case FXWindow::ID_GETINTVALUE:
           case FXWindow::ID_GETREALVALUE:
           case FXWindow::ID_GETSTRINGVALUE:
@@ -666,20 +535,20 @@ static VALUE FXRbConvertMessageData(FXObject* sender,FXObject* recv,FXSelector s
       }
     }
   else if(sender->isMemberOf(FXMETACLASS(FXDial))){
-    if(type==SEL_CHANGED || type==SEL_COMMAND) return to_ruby(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
+    if(type==SEL_CHANGED || type==SEL_COMMAND) return to_ruby_cb(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXDirBox))){
-    if(type==SEL_CHANGED || type==SEL_COMMAND) return to_ruby(reinterpret_cast<FXchar*>(ptr));
+    if(type==SEL_CHANGED || type==SEL_COMMAND) return to_ruby_cb(reinterpret_cast<FXchar*>(ptr));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXDockBar))){
-    if(type==SEL_DOCKED || type==SEL_FLOATED) return FXRbGetRubyObj(ptr,FXRbTypeQuery("FXDockSite *"));
+    if(type==SEL_DOCKED || type==SEL_FLOATED) return FXRbGetRubyObjCb(ptr,FXRbTypeQuery("FXDockSite *"));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXFileList))){
     if (type==SEL_CHANGED ||
         type==SEL_CLICKED ||
         type==SEL_DOUBLECLICKED ||
         type==SEL_TRIPLECLICKED ||
-        type==SEL_COMMAND) return to_ruby(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
+        type==SEL_COMMAND) return to_ruby_cb(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXFoldingList))){
     if(type==SEL_COLLAPSED ||
@@ -695,7 +564,7 @@ static VALUE FXRbConvertMessageData(FXObject* sender,FXObject* recv,FXSelector s
        type==SEL_DESELECTED ||
        type==SEL_INSERTED ||
        type==SEL_DELETED){
-      return FXRbGetRubyObj(ptr,FXRbTypeQuery("FXFoldingItem *"));
+      return FXRbGetRubyObjCb(ptr,FXRbTypeQuery("FXFoldingItem *"));
       }
     }
   else if(sender->isMemberOf(FXMETACLASS(FXGLViewer))){
@@ -704,13 +573,13 @@ static VALUE FXRbConvertMessageData(FXObject* sender,FXObject* recv,FXSelector s
        type==SEL_DOUBLECLICKED ||
        type==SEL_TRIPLECLICKED ||
        type==SEL_DRAGGED){
-      return FXRbGetRubyObj(ptr,FXRbTypeQuery("FXGLObject *"));
+      return FXRbGetRubyObjCb(ptr,FXRbTypeQuery("FXGLObject *"));
       }
     else if(type==SEL_COMMAND){
       if(id==FXWindow::ID_QUERY_MENU)
-        return to_ruby(reinterpret_cast<FXEvent*>(ptr));
+        return to_ruby_cb(reinterpret_cast<FXEvent*>(ptr));
       else
-        return FXRbGetRubyObj(ptr,FXRbTypeQuery("FXGLObject *"));
+        return FXRbGetRubyObjCb(ptr,FXRbTypeQuery("FXGLObject *"));
       }
     else if(type==SEL_LASSOED ||
             type==SEL_INSERTED ||
@@ -725,7 +594,7 @@ static VALUE FXRbConvertMessageData(FXObject* sender,FXObject* recv,FXSelector s
     }
   else if(sender->isMemberOf(FXMETACLASS(FXGradientBar))){
     if(type==SEL_CHANGED){
-      return to_ruby(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
+      return to_ruby_cb(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
       }
     else if(type==SEL_SELECTED || type==SEL_DESELECTED){
       return Qnil;
@@ -737,7 +606,7 @@ static VALUE FXRbConvertMessageData(FXObject* sender,FXObject* recv,FXSelector s
        type==SEL_CLICKED ||
        type==SEL_REPLACED ||
        type==SEL_INSERTED ||
-       type==SEL_DELETED) return to_ruby(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
+       type==SEL_DELETED) return to_ruby_cb(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXIconList))){
     if(type==SEL_CHANGED ||
@@ -749,10 +618,10 @@ static VALUE FXRbConvertMessageData(FXObject* sender,FXObject* recv,FXSelector s
        type==SEL_DESELECTED ||
        type==SEL_REPLACED ||
        type==SEL_INSERTED ||
-       type==SEL_DELETED) return to_ruby(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
+       type==SEL_DELETED) return to_ruby_cb(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXKnob))){
-    if(type==SEL_CHANGED || type==SEL_COMMAND) return to_ruby(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
+    if(type==SEL_CHANGED || type==SEL_COMMAND) return to_ruby_cb(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXList))){
     if(type==SEL_CHANGED ||
@@ -764,10 +633,10 @@ static VALUE FXRbConvertMessageData(FXObject* sender,FXObject* recv,FXSelector s
        type==SEL_REPLACED ||
        type==SEL_INSERTED ||
        type==SEL_DELETED ||
-       type==SEL_COMMAND) return to_ruby(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
+       type==SEL_COMMAND) return to_ruby_cb(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXListBox))){
-    if(type==SEL_COMMAND) return to_ruby(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
+    if(type==SEL_COMMAND) return to_ruby_cb(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
     else if(type==SEL_CHANGED) return Qnil;
     }
   else if(sender->isMemberOf(FXMETACLASS(FXMDIChild))){
@@ -779,66 +648,66 @@ static VALUE FXRbConvertMessageData(FXObject* sender,FXObject* recv,FXSelector s
       }
     else if(type==SEL_SELECTED ||
             type==SEL_DESELECTED){
-      return FXRbGetRubyObj(ptr,FXRbTypeQuery("FXMDIChild *"));
+      return FXRbGetRubyObjCb(ptr,FXRbTypeQuery("FXMDIChild *"));
       }
     }
   else if(sender->isMemberOf(FXMETACLASS(FXMDIClient))){
-    if(type==SEL_CHANGED) return FXRbGetRubyObj(ptr,FXRbTypeQuery("FXMDIChild *"));
+    if(type==SEL_CHANGED) return FXRbGetRubyObjCb(ptr,FXRbTypeQuery("FXMDIChild *"));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXMenuCheck))){
-    if(type==SEL_COMMAND) return to_ruby(reinterpret_cast<FXuval>(ptr));
+    if(type==SEL_COMMAND) return to_ruby_cb(reinterpret_cast<FXuval>(ptr));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXMenuRadio))){
-    if(type==SEL_COMMAND) return to_ruby(reinterpret_cast<FXuval>(ptr));
+    if(type==SEL_COMMAND) return to_ruby_cb(reinterpret_cast<FXuval>(ptr));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXMenuCommand))){
-    if(type==SEL_COMMAND) return to_ruby(true);
+    if(type==SEL_COMMAND) return to_ruby_cb(true);
     }
   else if(sender->isMemberOf(FXMETACLASS(FXOption))){
-    if(type==SEL_COMMAND) return to_ruby(reinterpret_cast<FXEvent*>(ptr));
+    if(type==SEL_COMMAND) return to_ruby_cb(reinterpret_cast<FXEvent*>(ptr));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXOptionMenu))){
-    if(type==SEL_COMMAND) return to_ruby(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
+    if(type==SEL_COMMAND) return to_ruby_cb(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXRadioButton))){
-    if(type==SEL_COMMAND) return to_ruby(static_cast<FXuchar>(reinterpret_cast<FXuval>(ptr)));
+    if(type==SEL_COMMAND) return to_ruby_cb(static_cast<FXuchar>(reinterpret_cast<FXuval>(ptr)));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXRealSlider))){
     if(type==SEL_CHANGED || type==SEL_COMMAND)
-      return to_ruby(*(reinterpret_cast<FXdouble *>(ptr)));
+      return to_ruby_cb(*(reinterpret_cast<FXdouble *>(ptr)));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXRealSpinner))){
-    if(type==SEL_COMMAND || type==SEL_CHANGED) return to_ruby(*(reinterpret_cast<FXdouble *>(ptr)));
+    if(type==SEL_COMMAND || type==SEL_CHANGED) return to_ruby_cb(*(reinterpret_cast<FXdouble *>(ptr)));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXRecentFiles))){
-    if(type==SEL_COMMAND) return to_ruby(reinterpret_cast<FXchar*>(ptr));
+    if(type==SEL_COMMAND) return to_ruby_cb(reinterpret_cast<FXchar*>(ptr));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXRuler))){
     if(type==SEL_CHANGED) return Qnil;
     }
   else if(sender->isMemberOf(FXMETACLASS(FXScrollBar))){
-    if(type==SEL_CHANGED || type==SEL_COMMAND) return to_ruby(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
+    if(type==SEL_CHANGED || type==SEL_COMMAND) return to_ruby_cb(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXShutter))){
-    if(type==SEL_COMMAND) return to_ruby(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
+    if(type==SEL_COMMAND) return to_ruby_cb(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXSlider))){
     if(type==SEL_CHANGED || type==SEL_COMMAND)
-      return to_ruby(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
+      return to_ruby_cb(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXSpinner))){
     if(type==SEL_CHANGED || type==SEL_COMMAND)
-      return to_ruby(static_cast<FXint>(reinterpret_cast<FXuval>(ptr)));
+      return to_ruby_cb(static_cast<FXint>(reinterpret_cast<FXuval>(ptr)));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXSplitter))){
     if(type==SEL_CHANGED || type==SEL_COMMAND)
-      return to_ruby(reinterpret_cast<FXWindow *>(ptr));
+      return to_ruby_cb(reinterpret_cast<FXWindow *>(ptr));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXSwitcher))){
-    if(type==SEL_COMMAND) return to_ruby(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
+    if(type==SEL_COMMAND) return to_ruby_cb(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXTabBar))){
-    if(type==SEL_COMMAND) return to_ruby(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
+    if(type==SEL_COMMAND) return to_ruby_cb(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXTable))){
     if(type==SEL_CLICKED ||
@@ -847,11 +716,11 @@ static VALUE FXRbConvertMessageData(FXObject* sender,FXObject* recv,FXSelector s
        type==SEL_CHANGED ||
        type==SEL_COMMAND ||
        type==SEL_SELECTED ||
-       type == SEL_DESELECTED) return to_ruby(reinterpret_cast<FXTablePos*>(ptr));
+       type == SEL_DESELECTED) return to_ruby_cb(reinterpret_cast<FXTablePos*>(ptr));
     else if(type == SEL_INSERTED ||
             type == SEL_DELETED ||
             type == SEL_REPLACED){
-	      return to_ruby(reinterpret_cast<FXTableRange*>(ptr));
+	      return to_ruby_cb(reinterpret_cast<FXTableRange*>(ptr));
 	      }
     }
   else if(sender->isMemberOf(FXMETACLASS(FXText))){
@@ -868,31 +737,31 @@ static VALUE FXRbConvertMessageData(FXObject* sender,FXObject* recv,FXSelector s
         }
       }
     else if(type==SEL_CHANGED){
-      return to_ruby(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
+      return to_ruby_cb(static_cast<FXint>(reinterpret_cast<FXival>(ptr)));
       }
     else if(type==SEL_SELECTED ||
             type == SEL_DESELECTED) {
       FXint* what=reinterpret_cast<FXint*>(ptr);
       FXASSERT(what!=0);
       VALUE ary=rb_ary_new();
-      rb_ary_push(ary,to_ruby(what[0])); // start position of text
-      rb_ary_push(ary,to_ruby(what[1])); // length of text
+      rb_ary_push(ary,to_ruby_cb(what[0])); // start position of text
+      rb_ary_push(ary,to_ruby_cb(what[1])); // length of text
       return ary;
       }
     else if(type==SEL_INSERTED || type==SEL_DELETED || type==SEL_REPLACED) {
-      return to_ruby(reinterpret_cast<FXTextChange*>(ptr));
+      return to_ruby_cb(reinterpret_cast<FXTextChange*>(ptr));
       }
     }
   else if(sender->isMemberOf(FXMETACLASS(FXTextField))){
     if(type==SEL_CHANGED ||
        type==SEL_COMMAND ||
-       type==SEL_VERIFY) return to_ruby(reinterpret_cast<FXchar*>(ptr));
+       type==SEL_VERIFY) return to_ruby_cb(reinterpret_cast<FXchar*>(ptr));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXToggleButton))){
-    if(type==SEL_COMMAND) return to_ruby(static_cast<FXuchar>(reinterpret_cast<FXuval>(ptr)));
+    if(type==SEL_COMMAND) return to_ruby_cb(static_cast<FXuchar>(reinterpret_cast<FXuval>(ptr)));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXToolBarTab))){
-    if (type==SEL_COMMAND) return to_ruby(static_cast<FXbool>(reinterpret_cast<FXuval>(ptr)));
+    if (type==SEL_COMMAND) return to_ruby_cb(static_cast<FXbool>(reinterpret_cast<FXuval>(ptr)));
     }
   else if(sender->isMemberOf(FXMETACLASS(FXTopWindow))){
     if(type==SEL_MINIMIZE ||
@@ -903,7 +772,7 @@ static VALUE FXRbConvertMessageData(FXObject* sender,FXObject* recv,FXSelector s
       }
     else if (type==SEL_SESSION_NOTIFY ||
              type==SEL_SESSION_CLOSED) {
-      return to_ruby(reinterpret_cast<FXEvent*>(ptr));
+      return to_ruby_cb(reinterpret_cast<FXEvent*>(ptr));
       }
     }
   else if(sender->isMemberOf(FXMETACLASS(FXTreeList))){
@@ -920,17 +789,17 @@ static VALUE FXRbConvertMessageData(FXObject* sender,FXObject* recv,FXSelector s
        type==SEL_DESELECTED ||
        type==SEL_INSERTED ||
        type==SEL_DELETED){
-      return FXRbGetRubyObj(ptr,FXRbTypeQuery("FXTreeItem *"));
+      return FXRbGetRubyObjCb(ptr,FXRbTypeQuery("FXTreeItem *"));
       }
     }
   else if(sender->isMemberOf(FXMETACLASS(FXTreeListBox))){
     if(type==SEL_CHANGED || type==SEL_COMMAND)
-      return FXRbGetRubyObj(ptr,FXRbTypeQuery("FXTreeItem *"));
+      return FXRbGetRubyObjCb(ptr,FXRbTypeQuery("FXTreeItem *"));
     }
 #ifdef WITH_FXSCINTILLA
   else if(sender->isMemberOf(FXMETACLASS(FXScintilla))){
     if(type==SEL_COMMAND){
-      return FXRbGetRubyObj(ptr,FXRbTypeQuery("SCNotification *"));
+      return FXRbGetRubyObjCb(ptr,FXRbTypeQuery("SCNotification *"));
       }
     }
 #endif
@@ -1049,7 +918,6 @@ void* FXRbGetExpectedData(VALUE recv,FXSelector key,VALUE value){
     case SEL_CLICKED:
     case SEL_DOUBLECLICKED:
     case SEL_TRIPLECLICKED:
-    case SEL_CHANGED:
     case SEL_DESELECTED:
     case SEL_SELECTED:
     case SEL_INSERTED:
@@ -1165,7 +1033,7 @@ void* FXRbGetExpectedData(VALUE recv,FXSelector key,VALUE value){
           return NULL;
         case FXWindow::ID_HSCROLLED:
         case FXWindow::ID_VSCROLLED:
-          return reinterpret_cast<void*>(static_cast<unsigned long>(NUM2UINT(value)));
+          return reinterpret_cast<void*>(static_cast<long>(NUM2INT(value)));
         case FXWindow::ID_SETINTVALUE:
           if(obj->isMemberOf(FXMETACLASS(FXColorWell))){
             colorValue=NUM2UINT(value);
@@ -1206,9 +1074,16 @@ void* FXRbGetExpectedData(VALUE recv,FXSelector key,VALUE value){
 	  if(obj->isMemberOf(FXMETACLASS(FXPicker))){
 			SWIG_ConvertPtr(value,&ptr,FXRbTypeQuery("FXPoint *"),1);
 			return ptr;
-	    }
-		return 0;
     }
+    if(obj->isMemberOf(FXMETACLASS(FXWindow))){
+      switch(id){
+        case FXWindow::ID_HSCROLLED:
+        case FXWindow::ID_VSCROLLED:
+          return reinterpret_cast<void*>(static_cast<long>(NUM2INT(value)));
+      }
+    }
+    return 0;
+  }
 
 	if(type==SEL_DRAGGED){
 	    SWIG_ConvertPtr(value,&ptr,FXRbTypeQuery("FXEvent *"),1);
@@ -1229,7 +1104,7 @@ static ID id_assocs;
  * or return zero if the designated receiver doesn't handle this
  * message.
  */
-ID FXRbLookupHandler(FXObject* recv,FXSelector key){
+ID FXRbLookupHandler_gvlcb(FXObject* recv,FXSelector key){
   FXTRACE((100,"FXRbLookupHandler(recv=%p(%s),FXSEL(%d,%d))\n",recv,recv->getClassName(),FXSELTYPE(key),FXSELID(key)));
   ID id=0;
   VALUE rubyObj=to_ruby(recv);
@@ -1276,26 +1151,32 @@ static ID id_backtrace;
 static VALUE handle_rescue(VALUE args,VALUE error){
   VALUE info=rb_gv_get("$!");
   VALUE errat=rb_funcall(info,id_backtrace,0);
-  VALUE mesg=RARRAY_PTR(errat)[0];
+  VALUE mesg=rb_ary_entry(errat, 0);
+  VALUE info_str=rb_obj_as_string(info);
   fprintf(stderr,"%s: %s (%s)\n",
-    StringValuePtr(mesg),
-    RSTRING_PTR(rb_obj_as_string(info)),
+    StringValueCStr(mesg),
+    StringValueCStr(info_str),
     rb_class2name(CLASS_OF(info)));
   for(int i=1;i<RARRAY_LEN(errat);i++){
-    if(TYPE(RARRAY_PTR(errat)[i])==T_STRING){
-      fprintf(stderr,"\tfrom %s\n",StringValuePtr(RARRAY_PTR(errat)[i]));
+    VALUE entry = rb_ary_entry(errat, i);
+    if(TYPE(entry)==T_STRING){
+      fprintf(stderr,"\tfrom %s\n",StringValueCStr(entry));
       }
     }
   return Qnil;
   }
 
 
+// Should we catch exceptions thrown by message handlers?
+FXbool FXRbCatchExceptions=FALSE;
+
+
 // Call the designated function and return its result (which should be a long).
-long FXRbHandleMessage(FXObject* recv,ID func,FXObject* sender,FXSelector key,void* ptr){
+long FXRbHandleMessage_gvlcb(FXObject* recv,ID func,FXObject* sender,FXSelector key,void* ptr){
   FXRbHandleArgs hArgs;
-  hArgs.recv=to_ruby(recv);
-  hArgs.sender=to_ruby(sender);
-  hArgs.key=to_ruby(key);
+  hArgs.recv=to_ruby_cb(recv);
+  hArgs.sender=to_ruby_cb(sender);
+  hArgs.key=to_ruby_cb(key);
   hArgs.data=FXRbConvertMessageData(sender,recv,key,ptr);
   hArgs.id=func;
   hArgs.nargs=3;
@@ -1304,8 +1185,8 @@ long FXRbHandleMessage(FXObject* recv,ID func,FXObject* sender,FXSelector key,vo
   FXTRACE((100,"FXRbHandleMessage(recv=%p(%s),FXSEL(%s,%d)\n",recv,recv->getClassName(),FXDebugTarget::messageTypeName[FXSELTYPE(key)],FXSELID(key)));
 
   if(FXRbCatchExceptions){
-    retval=rb_rescue2((VALUE(*)(ANYARGS)) handle_body, reinterpret_cast<VALUE>(&hArgs),
-                      (VALUE(*)(ANYARGS)) handle_rescue, Qnil,
+    retval=rb_rescue2(RUBY_VALUE_METHOD_FUNC(handle_body), reinterpret_cast<VALUE>(&hArgs),
+                      RUBY_VALUE_METHOD_FUNC(handle_rescue), Qnil,
                       rb_eStandardError, rb_eNameError, 0);
     }
   else{
@@ -1351,9 +1232,9 @@ void FXRbRange2LoHi(VALUE range,FXint& lo,FXint& hi){
     rb_raise(rb_eTypeError,"wrong argument type %s (expected %s)",rb_class2name(CLASS_OF(range)),rb_class2name(rb_cRange));
     }
   else{
-    VALUE beg=rb_funcall(range,id_begin,0,NULL);
-    VALUE end=rb_funcall(range,id_end,0,NULL);
-    VALUE excl=rb_funcall(range,id_exclude_endp,0,NULL);
+    VALUE beg=rb_funcall(range,id_begin,0);
+    VALUE end=rb_funcall(range,id_end,0);
+    VALUE excl=rb_funcall(range,id_exclude_endp,0);
     lo=NUM2INT(beg);
     hi=NUM2INT(end);
     if(excl==Qtrue){
@@ -1367,9 +1248,9 @@ void FXRbRange2LoHi(VALUE range,FXdouble& lo,FXdouble& hi){
     rb_raise(rb_eTypeError,"wrong argument type %s (expected %s)",rb_class2name(CLASS_OF(range)),rb_class2name(rb_cRange));
     }
   else{
-    VALUE beg=rb_funcall(range,id_begin,0,NULL);
-    VALUE end=rb_funcall(range,id_end,0,NULL);
-    VALUE excl=rb_funcall(range,id_exclude_endp,0,NULL);
+    VALUE beg=rb_funcall(range,id_begin,0);
+    VALUE end=rb_funcall(range,id_end,0);
+    VALUE excl=rb_funcall(range,id_exclude_endp,0);
     lo=NUM2DBL(beg);
     hi=NUM2DBL(end);
     if(excl==Qtrue){
@@ -1380,70 +1261,70 @@ void FXRbRange2LoHi(VALUE range,FXdouble& lo,FXdouble& hi){
 
 //----------------------------------------------------------------------
 
-void FXRbCallVoidMethod(FXObject* recv, ID func) {
+void FXRbCallVoidMethod_gvlcb(FXObject* recv, const char *func) {
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
   FXASSERT(!FXRbIsInGC(recv));
-  rb_funcall(obj,func,0,NULL);
+  rb_funcall(obj,rb_intern(func),0);
   }
 
-void FXRbCallVoidMethod(FXDC* recv,ID func) {
+void FXRbCallVoidMethod_gvlcb(FXDC* recv,const char *func) {
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  rb_funcall(obj,func,0,NULL);
+  rb_funcall(obj,rb_intern(func),0);
   }
 
 //----------------------------------------------------------------------
 
-bool FXRbCallBoolMethod(const FXObject* recv,ID func){
+bool FXRbCallBoolMethod_gvlcb(const FXObject* recv,const char *func){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE v=rb_funcall(obj,func,0,NULL);
+  VALUE v=rb_funcall(obj,rb_intern(func),0);
   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){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE result=rb_funcall(obj,func,0,NULL);
+  VALUE result=rb_funcall(obj,rb_intern(func),0);
   return static_cast<FXint>(NUM2INT(result));
   }
 
 //----------------------------------------------------------------------
 
 // Call function with "FXGLObject*" return value
-FXGLObject* FXRbCallGLObjectMethod(FXGLObject* recv,ID func){
+FXGLObject* FXRbCallGLObjectMethod_gvlcb(FXGLObject* recv,const char *func){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE result=rb_funcall(obj,func,0,NULL);
+  VALUE result=rb_funcall(obj,rb_intern(func),0);
   return NIL_P(result) ? 0 : reinterpret_cast<FXGLObject*>(DATA_PTR(result));
   }
 
-FXGLObject* FXRbCallGLObjectMethod(FXGLViewer* recv,ID func,FXint x,FXint y){
+FXGLObject* FXRbCallGLObjectMethod_gvlcb(FXGLViewer* recv,const char *func,FXint x,FXint y){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE result=rb_funcall(obj,func,2,INT2NUM(x),INT2NUM(y));
+  VALUE result=rb_funcall(obj,rb_intern(func),2,INT2NUM(x),INT2NUM(y));
   return NIL_P(result) ? 0 : reinterpret_cast<FXGLObject*>(DATA_PTR(result));
   }
 
-FXGLObject* FXRbCallGLObjectMethod(FXGLObject* recv,ID func,FXuint* path,FXint n){
+FXGLObject* FXRbCallGLObjectMethod_gvlcb(FXGLObject* recv,const char *func,FXuint* path,FXint n){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE result=rb_funcall(obj,func,1,FXRbMakeArray(path,n));
+  VALUE result=rb_funcall(obj,rb_intern(func),1,FXRbMakeArray(path,n));
   return NIL_P(result) ? 0 : reinterpret_cast<FXGLObject*>(DATA_PTR(result));
   }
 
 //----------------------------------------------------------------------
 
 // Call function 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){
   FXGLObject** objects=NULL;
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE result=rb_funcall(obj,func,4,INT2NUM(x),INT2NUM(y),INT2NUM(w),INT2NUM(h));
+  VALUE result=rb_funcall(obj,rb_intern(func),4,INT2NUM(x),INT2NUM(y),INT2NUM(w),INT2NUM(h));
   if(!NIL_P(result)){
     Check_Type(result,T_ARRAY);
     if(FXMALLOC(&objects,FXGLObject*,RARRAY_LEN(result)+1)){
@@ -1458,55 +1339,55 @@ FXGLObject** FXRbCallGLObjectArrayMethod(FXGLViewer* recv,ID func,FXint x,FXint
 
 //----------------------------------------------------------------------
 
-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){
   VALUE itemData=(ptr==0)?Qnil:reinterpret_cast<VALUE>(ptr);
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE result=rb_funcall(obj,func,3,to_ruby(text),to_ruby(icon),itemData);
+  VALUE result=rb_funcall(obj,rb_intern(func),3,to_ruby(text),to_ruby_cb(icon),itemData);
   return NIL_P(result)?0:reinterpret_cast<FXTableItem*>(DATA_PTR(result));
   }
 
-FXTableItem* FXRbCallTableItemMethod(FXTable* recv,ID func,FXint row,FXint col,FXbool notify){
+FXTableItem* FXRbCallTableItemMethod_gvlcb(FXTable* recv,const char *func,FXint row,FXint col,FXbool notify){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE result=rb_funcall(obj,func,3,to_ruby(row),to_ruby(col),to_ruby(notify));
+  VALUE result=rb_funcall(obj,rb_intern(func),3,to_ruby(row),to_ruby(col),to_ruby(notify));
   return NIL_P(result)?0:reinterpret_cast<FXTableItem*>(DATA_PTR(result));
   }
 
 //----------------------------------------------------------------------
 
-FXTreeItem* FXRbCallTreeItemMethod(const FXTreeList* recv,ID func,FXint x,FXint y){
+FXTreeItem* FXRbCallTreeItemMethod_gvlcb(const FXTreeList* recv,const char *func,FXint x,FXint y){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE result=rb_funcall(obj,func,2,INT2NUM(x),INT2NUM(y));
+  VALUE result=rb_funcall(obj,rb_intern(func),2,INT2NUM(x),INT2NUM(y));
   return NIL_P(result) ? 0 : reinterpret_cast<FXTreeItem*>(DATA_PTR(result));
   }
 
 //----------------------------------------------------------------------
 
-FXFoldingItem* FXRbCallFoldingItemMethod(const FXFoldingList* recv,ID func,FXint x,FXint y){
+FXFoldingItem* FXRbCallFoldingItemMethod_gvlcb(const FXFoldingList* recv,const char *func,FXint x,FXint y){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE result=rb_funcall(obj,func,2,INT2NUM(x),INT2NUM(y));
+  VALUE result=rb_funcall(obj,rb_intern(func),2,INT2NUM(x),INT2NUM(y));
   return NIL_P(result) ? 0 : reinterpret_cast<FXFoldingItem*>(DATA_PTR(result));
   }
 
 //----------------------------------------------------------------------
 
-FXFileAssoc* FXRbCallFileAssocMethod(const FXFileDict* recv,ID func,const FXchar* pathname){
+FXFileAssoc* FXRbCallFileAssocMethod_gvlcb(const FXFileDict* recv,const char *func,const FXchar* pathname){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE result=rb_funcall(obj,func,1,to_ruby(pathname));
+  VALUE result=rb_funcall(obj,rb_intern(func),1,to_ruby(pathname));
   return NIL_P(result) ? 0 : reinterpret_cast<FXFileAssoc*>(DATA_PTR(result));
   }
 
 //----------------------------------------------------------------------
 
-FXIcon* FXRbCallIconMethod(const FXTableItem* recv,ID func){
+FXIcon* FXRbCallIconMethod_gvlcb(const FXTableItem* recv,const char *func){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
 	if(!NIL_P(obj)){
-	  VALUE result=rb_funcall(obj,func,0,NULL);
+	  VALUE result=rb_funcall(obj,rb_intern(func),0);
 	  return NIL_P(result) ? 0 : reinterpret_cast<FXIcon*>(DATA_PTR(result));
 		}
 	else{
@@ -1516,60 +1397,72 @@ FXIcon* FXRbCallIconMethod(const FXTableItem* recv,ID func){
 
 //----------------------------------------------------------------------
 
-FXWindow* FXRbCallWindowMethod(const FXTableItem* recv,ID func,FXTable* table){
+FXWindow* FXRbCallWindowMethod_gvlcb(const FXTableItem* recv,const char *func,FXTable* table){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE result=rb_funcall(obj,func,1,to_ruby(table));
+  VALUE result=rb_funcall(obj,rb_intern(func),1,to_ruby_cb(table));
   return NIL_P(result) ? 0 : reinterpret_cast<FXWindow*>(DATA_PTR(result));
   }
 
 //----------------------------------------------------------------------
 
 // Call function with "FXRange" return value
-FXRangef FXRbCallRangeMethod(FXObject* recv,ID func){
+FXRangef FXRbCallRangeMethod_gvlcb(FXObject* recv,const char *func){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE result=rb_funcall(obj,func,0,NULL);
+  VALUE result=rb_funcall(obj,rb_intern(func),0);
   return *reinterpret_cast<FXRangef*>(DATA_PTR(result));
   }
 
 //----------------------------------------------------------------------
 
 // Call functions with FXString return value
-FXString FXRbCallStringMethod(const FXObject* recv, ID func){
+FXString FXRbCallStringMethod_gvlcb(const FXObject* recv, const char *func){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE result=rb_funcall(obj,func,0,NULL);
+  VALUE result=rb_funcall(obj,rb_intern(func),0);
   return FXString(StringValuePtr(result));
   }
 
 //----------------------------------------------------------------------
 
 // Call functions with const FXchar* return value
-const FXchar* FXRbCallCStringMethod(const FXObject* recv, ID func, const FXchar* message, const FXchar* hint){
+const FXchar* FXRbCallCStringMethod_gvlcb(const FXObject* recv, const char *func, const FXchar* message, const FXchar* hint){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE result=rb_funcall(obj,func,2,to_ruby(message),to_ruby(hint));
+  VALUE result=rb_funcall(obj,rb_intern(func),2,to_ruby(message),to_ruby(hint));
   return NIL_P(result) ? 0 : StringValuePtr(result);
   }
 
 // Call functions with const FXchar* return value
-const FXchar* FXRbCallCStringMethod(const FXObject* recv, ID func, const FXchar* context, const FXchar* message, const FXchar* hint){
+const FXchar* FXRbCallCStringMethod_gvlcb(const FXObject* recv, const char *func, const FXchar* context, const FXchar* message, const FXchar* hint){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE result=rb_funcall(obj,func,3,to_ruby(context),to_ruby(message),to_ruby(hint));
+  VALUE result=rb_funcall(obj,rb_intern(func),3,to_ruby(context),to_ruby(message),to_ruby(hint));
   return NIL_P(result) ? 0 : StringValuePtr(result);
   }
 //----------------------------------------------------------------------
 
 // Call functions with FXwchar return value
-FXwchar FXRbCallWCharMethod(const FXObject* recv, ID func){
+FXwchar FXRbCallWCharMethod_gvlcb(const FXObject* recv, const char *func){
   VALUE obj=FXRbGetRubyObj(recv,false);
   FXASSERT(!NIL_P(obj));
-  VALUE result=rb_funcall(obj,func,0,NULL);
+  VALUE result=rb_funcall(obj,rb_intern(func),0);
   return static_cast<FXwchar>(NUM2ULONG(result));
   }
 
+void FXRbCallSetDashes_gvlcb(FXDC* recv,const char *func,FXuint dashoffset,const FXchar *dashpattern,FXuint dashlength){
+  rb_funcall(FXRbGetRubyObj(recv,false),rb_intern(func),2,to_ruby(dashoffset),FXRbMakeArray(dashpattern,dashlength));
+  }
+
+void FXRbCallDCDrawMethod_gvlcb(FXDC* recv, const char * func, FXint x,FXint y,const FXString& string){
+  rb_funcall(FXRbGetRubyObj(recv,false),rb_intern(func),3,to_ruby(x),to_ruby(y),to_ruby(string)); \
+  }
+
+void FXRbCallDCDrawMethod_gvlcb(FXDC* recv, const char * func, FXint x,FXint y,const FXchar* string,FXuint length){
+  rb_funcall(FXRbGetRubyObj(recv,false),rb_intern(func),3,to_ruby(x),to_ruby(y),to_ruby(string,length)); \
+  }
+
 //----------------------------------------------------------------------
 
 // Special destructors to handle order dependencies
@@ -1585,7 +1478,7 @@ FXRbMenuCommand::~FXRbMenuCommand(){
         }
       }
     }
-  acckey=(FXHotKey)NULL;
+  acckey=(FXHotKey)0;
   FXRbUnregisterRubyObj(this);
   }
 
@@ -1601,7 +1494,7 @@ FXRbMenuCheck::~FXRbMenuCheck(){
         }
       }
     }
-  acckey=(FXHotKey)NULL;
+  acckey=(FXHotKey)0;
   FXRbUnregisterRubyObj(this);
   }
 
@@ -1617,7 +1510,7 @@ FXRbMenuRadio::~FXRbMenuRadio(){
         }
       }
     }
-  acckey=(FXHotKey)NULL;
+  acckey=(FXHotKey)0;
   FXRbUnregisterRubyObj(this);
   }
 
@@ -1684,64 +1577,113 @@ void FXRbFoldingList::enumerateItems(FXFoldingItem* fm,FXFoldingItem* to,FXObjec
 
 static ID id_cmp;
 
-// Sort function stand-in for FXComboBox
-FXint FXRbComboBox::sortFunc(const FXListItem* a,const FXListItem* b){
-  VALUE itemA = FXRbGetRubyObj(const_cast<FXListItem*>(a), "FXListItem *");
-  VALUE itemB = FXRbGetRubyObj(const_cast<FXListItem*>(b), "FXListItem *");
-  VALUE result=rb_funcall(itemA,id_cmp,1,itemB);
-  return static_cast<FXint>(NUM2INT(result));
+#define SORTFUNC(list, item) \
+FXint list::sortFunc(const item* a,const item* b){ \
+  return list##_sortFunc(a, b); \
+  } \
+FXint list##_sortFunc_gvlcb(const item* a,const item* b){ \
+  VALUE itemA = FXRbGetRubyObj(const_cast<item*>(a), #item " *"); \
+  VALUE itemB = FXRbGetRubyObj(const_cast<item*>(b), #item " *"); \
+  VALUE result=rb_funcall(itemA,id_cmp,1,itemB); \
+  return static_cast<FXint>(NUM2INT(result)); \
   }
 
+SORTFUNC( FXRbComboBox, FXListItem )
+SORTFUNC( FXRbFoldingList, FXFoldingItem )
+SORTFUNC( FXRbIconList, FXIconItem )
+SORTFUNC( FXRbList, FXListItem )
+SORTFUNC( FXRbListBox, FXListItem )
+SORTFUNC( FXRbTreeList, FXTreeItem )
 
-// Sort function stand-in for FXFoldingList
-FXint FXRbFoldingList::sortFunc(const FXFoldingItem* a,const FXFoldingItem* b){
-  VALUE itemA = FXRbGetRubyObj(const_cast<FXFoldingItem*>(a), "FXFoldingItem *");
-  VALUE itemB = FXRbGetRubyObj(const_cast<FXFoldingItem*>(b), "FXFoldingItem *");
-  VALUE result=rb_funcall(itemA,id_cmp,1,itemB);
-  return static_cast<FXint>(NUM2INT(result));
-  }
+#undef SORTFUNC
 
-
-// Sort function stand-in for FXIconList
-FXint FXRbIconList::sortFunc(const FXIconItem* a,const FXIconItem* b){
-  VALUE itemA = FXRbGetRubyObj(const_cast<FXIconItem*>(a), "FXIconItem *");
-  VALUE itemB = FXRbGetRubyObj(const_cast<FXIconItem*>(b), "FXIconItem *");
-  VALUE result = rb_funcall(itemA,id_cmp,1,itemB);
-  return static_cast<FXint>(NUM2INT(result));
+// Feedback buffer sort routine stand-in for FXGLViewer
+FXbool FXRbGLViewer::sortProc(FXfloat*& buffer,FXint& used,FXint& size){
+  return TRUE;
   }
 
+/**
+ * FXRbConvertPtr() is just a wrapper around SWIG_ConvertPtr().
+ */
 
-// Sort function stand-in for FXList
-FXint FXRbList::sortFunc(const FXListItem* a,const FXListItem* b){
-  VALUE itemA = FXRbGetRubyObj(const_cast<FXListItem*>(a), "FXListItem *");
-  VALUE itemB = FXRbGetRubyObj(const_cast<FXListItem*>(b), "FXListItem *");
-  VALUE result=rb_funcall(itemA,id_cmp,1,itemB);
-  return static_cast<FXint>(NUM2INT(result));
+void* FXRbConvertPtr(VALUE obj,swig_type_info* ty){
+  void *ptr;
+  SWIG_ConvertPtr(obj,&ptr,ty,1);
+  return ptr;
   }
 
 
-// Sort function stand-in for FXListBox
-FXint FXRbListBox::sortFunc(const FXListItem* a,const FXListItem* b){
-  VALUE itemA = FXRbGetRubyObj(const_cast<FXListItem*>(a), "FXListItem *");
-  VALUE itemB = FXRbGetRubyObj(const_cast<FXListItem*>(b), "FXListItem *");
-  VALUE result=rb_funcall(itemA,id_cmp,1,itemB);
-  return static_cast<FXint>(NUM2INT(result));
+// Returns an FXInputHandle for this Ruby file object
+FXInputHandle FXRbGetReadFileHandle(VALUE obj,FXuint mode) {
+  int fd;
+  fd = FIX2INT(rb_funcall(obj, rb_intern("fileno"), 0));
+#ifdef WIN32
+#ifdef __CYGWIN__
+  return (FXInputHandle) get_osfhandle(fd);
+#else
+  WSAEVENT hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+  long events = 0;
+  if(mode&INPUT_READ) events |= FD_READ|FD_ACCEPT|FD_OOB;
+  if(mode&INPUT_EXCEPT) events |= FD_CLOSE|FD_QOS|FD_GROUP_QOS|FD_ROUTING_INTERFACE_CHANGE|FD_ADDRESS_LIST_CHANGE;
+  if ( WSAEventSelect(_get_osfhandle(fd), hEvent, events) == SOCKET_ERROR ) {
+    WSACloseEvent( hEvent );
+    rb_raise( rb_eRuntimeError, "WSAEventSelect sockett error: %d", WSAGetLastError() );
+  }
+  rb_iv_set(obj, "FXRuby::FXRbGetReadFileHandle", ULL2NUM((intptr_t)hEvent));
+  return (FXInputHandle) hEvent;
+#endif
+#else
+  return (FXInputHandle) fd;
+#endif
   }
 
+void FXRbRemoveReadFileHandle(VALUE obj,FXuint mode) {
+#ifdef WIN32
+  WSAEVENT hEvent = (HANDLE)NUM2ULL(rb_iv_get(obj, "FXRuby::FXRbGetReadFileHandle"));
+  CloseHandle( hEvent );
+#endif
+}
 
-// Sort function stand-in for FXTreeList
-FXint FXRbTreeList::sortFunc(const FXTreeItem* a,const FXTreeItem* b){
-  VALUE itemA = FXRbGetRubyObj(const_cast<FXTreeItem*>(a), "FXTreeItem *");
-  VALUE itemB = FXRbGetRubyObj(const_cast<FXTreeItem*>(b), "FXTreeItem *");
-  VALUE result=rb_funcall(itemA,id_cmp,1,itemB);
-  return static_cast<FXint>(NUM2INT(result));
+// Returns an FXInputHandle for this Ruby file object
+FXInputHandle FXRbGetWriteFileHandle(VALUE obj,FXuint mode) {
+  int fd;
+#if defined(RUBINIUS)
+  VALUE vwrite = rb_intern("@write");
+  if(rb_ivar_defined(obj, vwrite)) obj = rb_ivar_get(obj, vwrite);
+  fd = FIX2INT(rb_funcall(obj, rb_intern("fileno"), 0));
+#else
+  rb_io_t *fptr;
+  GetOpenFile(obj, fptr);
+  VALUE wrio = fptr->tied_io_for_writing;
+  if(wrio) obj = wrio;
+  fd = FIX2INT(rb_funcall(obj, rb_intern("fileno"), 0));
+#endif
+#ifdef WIN32
+#ifdef __CYGWIN__
+  return (FXInputHandle) get_osfhandle(fd);
+#else
+  WSAEVENT hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+  long events = 0;
+  if(mode&INPUT_WRITE) events |= FD_WRITE|FD_CONNECT;
+  if(mode&INPUT_EXCEPT) events |= FD_CLOSE|FD_QOS|FD_GROUP_QOS|FD_ROUTING_INTERFACE_CHANGE|FD_ADDRESS_LIST_CHANGE;
+  if ( WSAEventSelect(_get_osfhandle(fd), hEvent, events) == SOCKET_ERROR ) {
+    WSACloseEvent( hEvent );
+    rb_raise( rb_eRuntimeError, "WSAEventSelect sockettt error: %d", WSAGetLastError() );
+  }
+  rb_iv_set(obj, "FXRuby::FXRbGetWriteFileHandle", ULL2NUM((intptr_t)hEvent));
+  return (FXInputHandle) hEvent;
+#endif
+#else
+  return (FXInputHandle) fd;
+#endif
   }
 
-
-// Feedback buffer sort routine stand-in for FXGLViewer
-FXbool FXRbGLViewer::sortProc(FXfloat*& buffer,FXint& used,FXint& size){
-  return TRUE;
-  }
+void FXRbRemoveWriteFileHandle(VALUE obj,FXuint mode) {
+#ifdef WIN32
+  WSAEVENT hEvent = (HANDLE)NUM2ULL(rb_iv_get(obj, "FXRuby::FXRbGetWriteFileHandle"));
+  CloseHandle( hEvent );
+#endif
+}
 
 //----------------------------------------------------------------------
 
@@ -1945,7 +1887,7 @@ void FXRbUnregisterAppSensitiveObject(FXDC* dc){
   FXASSERT(st_lookup(appSensitiveDCs,reinterpret_cast<st_data_t>(dc),reinterpret_cast<st_data_t *>(0))==0);
   }
 
-static int st_cbfunc_obj(st_data_t key,st_data_t,st_data_t arg,int){
+static int st_cbfunc_obj(st_data_t key,st_data_t,st_data_t arg){
   FXASSERT(key!=0);
   FXASSERT(arg!=0);
   FXObjectListOf<FXObject> *pObjectList=reinterpret_cast<FXObjectListOf<FXObject>*>(arg);
@@ -1954,7 +1896,7 @@ static int st_cbfunc_obj(st_data_t key,st_data_t,st_data_t arg,int){
   return 0;
   }
 
-static int st_cbfunc_dc(st_data_t key,st_data_t,st_data_t arg,int){
+static int st_cbfunc_dc(st_data_t key,st_data_t,st_data_t arg){
   FXASSERT(key!=0);
   FXASSERT(arg!=0);
   FXArray<FXDC*> *pDCArray=reinterpret_cast<FXArray<FXDC*>*>(arg);
@@ -1967,7 +1909,7 @@ void FXRbDestroyAppSensitiveObjects(){
   FXTRACE((100,"%s:%d: Begin destroying objects that hold references to the FXApp...\n",__FILE__,__LINE__));
 
   FXObjectListOf<FXObject> objs;
-  st_foreach(appSensitiveObjs,reinterpret_cast<int (*)(ANYARGS)>(st_cbfunc_obj),reinterpret_cast<st_data_t>(&objs));
+  st_foreach(appSensitiveObjs,RUBY_INT_METHOD_FUNC(st_cbfunc_obj),reinterpret_cast<st_data_t>(&objs));
   for(FXint i=0;i<objs.no();i++){
     if(objs[i]->isMemberOf(FXMETACLASS(FXRbCursor))){
       if(dynamic_cast<FXRbCursor*>(objs[i])->ownedByApp)
@@ -1997,7 +1939,7 @@ void FXRbDestroyAppSensitiveObjects(){
     }
 
   FXArray<FXDC*> dcs;
-  st_foreach(appSensitiveDCs,reinterpret_cast<int (*)(ANYARGS)>(st_cbfunc_dc),reinterpret_cast<st_data_t>(&dcs));
+  st_foreach(appSensitiveDCs,RUBY_INT_METHOD_FUNC(st_cbfunc_dc),reinterpret_cast<st_data_t>(&dcs));
   for(FXint j=0;j<dcs.no();j++){
     delete dcs[j];
     }
@@ -2066,7 +2008,6 @@ Init_fox16_c(void) {
   utf8_enc_idx = rb_enc_find_index("UTF-8");
 #endif
 
-  FXRuby_Objects=st_init_numtable();
   appSensitiveObjs=st_init_numtable();
   appSensitiveDCs=st_init_numtable();
   }
diff --git a/ext/fox16_c/core_wrap.cpp b/ext/fox16_c/core_wrap.cpp
new file mode 100644
index 00000000..12061ce1
--- /dev/null
+++ b/ext/fox16_c/core_wrap.cpp
@@ -0,0 +1,44884 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 3.0.12
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+
+#ifndef SWIGRUBY
+#define SWIGRUBY
+#endif
+
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
+};
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic C API SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "4"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/*  Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN           0x1
+
+
+/*
+   Flags/methods for returning states.
+
+   The SWIG conversion methods, as ConvertPtr, return an integer
+   that tells if the conversion was successful or not. And if not,
+   an error code can be returned (see swigerrors.swg for the codes).
+
+   Use the following macros/flags to set or process the returning
+   states.
+
+   In old versions of SWIG, code such as the following was usually written:
+
+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+       // success code
+     } else {
+       //fail code
+     }
+
+   Now you can be more explicit:
+
+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+    } else {
+      // fail code
+    }
+
+   which is the same really, but now you can also do
+
+    Type *ptr;
+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+      if (SWIG_IsNewObj(res) {
+        ...
+	delete *ptr;
+      } else {
+        ...
+      }
+    } else {
+      // fail code
+    }
+
+   I.e., now SWIG_ConvertPtr can return new objects and you can
+   identify the case and take care of the deallocation. Of course that
+   also requires SWIG_ConvertPtr to return new result values, such as
+
+      int SWIG_ConvertPtr(obj, ptr,...) {
+        if (<obj is ok>) {
+          if (<need new object>) {
+            *ptr = <ptr to new allocated object>;
+            return SWIG_NEWOBJ;
+          } else {
+            *ptr = <ptr to old object>;
+            return SWIG_OLDOBJ;
+          }
+        } else {
+          return SWIG_BADOBJ;
+        }
+      }
+
+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+   SWIG errors code.
+
+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+   allows to return the 'cast rank', for example, if you have this
+
+       int food(double)
+       int fooi(int);
+
+   and you call
+
+      food(1)   // cast rank '1'  (1 -> 1.0)
+      fooi(1)   // cast rank '0'
+
+   just use the SWIG_AddCast()/SWIG_CheckState()
+*/
+
+#define SWIG_OK                    (0)
+#define SWIG_ERROR                 (-1)
+#define SWIG_IsOK(r)               (r >= 0)
+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT         (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ                (SWIG_ERROR)
+#define SWIG_OLDOBJ                (SWIG_OK)
+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+#  ifndef SWIG_TypeRank
+#    define SWIG_TypeRank             unsigned long
+#  endif
+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
+#    define SWIG_MAXCASTRANK          (2)
+#  endif
+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+#  define SWIG_AddCast(r) (r)
+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *, int *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store information on one type */
+typedef struct swig_type_info {
+  const char             *name;			/* mangled name of this type */
+  const char             *str;			/* human readable name of this type */
+  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
+  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
+  void                   *clientdata;		/* language specific type data */
+  int                    owndata;		/* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
+  swig_converter_func     converter;		/* function to cast the void pointers */
+  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
+  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
+  size_t                 size;		        /* Number of types in this module */
+  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
+  swig_type_info         **type_initial;	/* Array of initially generated type structures */
+  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
+  void                    *clientdata;		/* Language specific module data */
+} swig_module_info;
+
+/*
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+  }
+  return (int)((l1 - f1) - (l2 - f2));
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCmp(const char *nb, const char *tb) {
+  int equiv = 1;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (equiv != 0 && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
+}
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
+}
+
+/*
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+  swig_type_info *lastty = ty;
+  if (!ty || !ty->dcast) return ty;
+  while (ty && (ty->dcast)) {
+    ty = (*ty->dcast)(ptr);
+    if (ty) lastty = ty;
+  }
+  return lastty;
+}
+
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+  return ty->name;
+}
+
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (!type) return NULL;
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
+  }
+  else
+    return type->name;
+}
+
+/*
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+  swig_cast_info *cast = ti->cast;
+  /* if (ti->clientdata == clientdata) return; */
+  ti->clientdata = clientdata;
+
+  while (cast) {
+    if (!cast->converter) {
+      swig_type_info *tc = cast->type;
+      if (!tc->clientdata) {
+	SWIG_TypeClientData(tc, clientdata);
+      }
+    }
+    cast = cast->next;
+  }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientData(ti, clientdata);
+  ti->owndata = 1;
+}
+
+/*
+  Search for a swig_type_info structure only by mangled name
+  Search is a O(log #types)
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+                            swig_module_info *end,
+		            const char *name) {
+  swig_module_info *iter = start;
+  do {
+    if (iter->size) {
+      size_t l = 0;
+      size_t r = iter->size - 1;
+      do {
+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
+	size_t i = (l + r) >> 1;
+	const char *iname = iter->types[i]->name;
+	if (iname) {
+	  int compare = strcmp(name, iname);
+	  if (compare == 0) {
+	    return iter->types[i];
+	  } else if (compare < 0) {
+	    if (i) {
+	      r = i - 1;
+	    } else {
+	      break;
+	    }
+	  } else if (compare > 0) {
+	    l = i + 1;
+	  }
+	} else {
+	  break; /* should never happen */
+	}
+      } while (l <= r);
+    }
+    iter = iter->next;
+  } while (iter != end);
+  return 0;
+}
+
+/*
+  Search for a swig_type_info structure for either a mangled name or a human readable name.
+  It first searches the mangled names of the types, which is a O(log #types)
+  If a type is not found it then searches the human readable names, which is O(#types).
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+                     swig_module_info *end,
+		     const char *name) {
+  /* STEP 1: Search the name field using binary search */
+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+  if (ret) {
+    return ret;
+  } else {
+    /* STEP 2: If the type hasn't been found, do a complete search
+       of the str field (the human readable name) */
+    swig_module_info *iter = start;
+    do {
+      size_t i = 0;
+      for (; i < iter->size; ++i) {
+	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+	  return iter->types[i];
+      }
+      iter = iter->next;
+    } while (iter != end);
+  }
+
+  /* neither found a match */
+  return 0;
+}
+
+/*
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+
+/*
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = (unsigned char)((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = (unsigned char)((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (unsigned char)(d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (unsigned char)(d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/*
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/*  Errors in SWIG */
+#define  SWIG_UnknownError    	   -1
+#define  SWIG_IOError        	   -2
+#define  SWIG_RuntimeError   	   -3
+#define  SWIG_IndexError     	   -4
+#define  SWIG_TypeError      	   -5
+#define  SWIG_DivisionByZero 	   -6
+#define  SWIG_OverflowError  	   -7
+#define  SWIG_SyntaxError    	   -8
+#define  SWIG_ValueError     	   -9
+#define  SWIG_SystemError    	   -10
+#define  SWIG_AttributeError 	   -11
+#define  SWIG_MemoryError    	   -12
+#define  SWIG_NullReferenceError   -13
+
+
+
+      #include <ruby.h>
+
+      #if defined(RB_METHOD_DEFINITION_DECL)
+      # define RUBY_VALUE_METHOD_FUNC(func) (func)
+      # define RUBY_INT_METHOD_FUNC(func) (func)
+      # define RUBY_VOID_METHOD_FUNC(func) (func)
+      # define RUBY_VOIDP_METHOD_FUNC(func) (func)
+      #else
+      # define RUBY_VALUE_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
+      # define RUBY_INT_METHOD_FUNC(func) ((int (*)(ANYARGS))(func))
+      # define RUBY_VOID_METHOD_FUNC(func) ((void (*)(ANYARGS))(func))
+      # define RUBY_VOIDP_METHOD_FUNC(func) ((void *(*)(ANYARGS))(func))
+      #endif
+
+
+/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
+ * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
+ * issue for now by disabling this.
+ * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
+ */
+#ifdef rb_intern
+# undef rb_intern
+#endif
+
+/* Remove global macros defined in Ruby's win32.h */
+#ifdef write
+# undef write
+#endif
+#ifdef read
+# undef read
+#endif
+#ifdef bind
+# undef bind
+#endif
+#ifdef close
+# undef close
+#endif
+#ifdef connect
+# undef connect
+#endif
+
+
+/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
+#ifndef NUM2LL
+#define NUM2LL(x) NUM2LONG((x))
+#endif
+#ifndef LL2NUM
+#define LL2NUM(x) INT2NUM((long) (x))
+#endif
+#ifndef ULL2NUM
+#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
+#endif
+
+/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
+#ifndef NUM2ULL
+#ifdef HAVE_LONG_LONG
+#define NUM2ULL(x) rb_num2ull((x))
+#else
+#define NUM2ULL(x) NUM2ULONG(x)
+#endif
+#endif
+
+/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
+/* Define these for older versions so we can just write code the new way */
+#ifndef RSTRING_LEN
+# define RSTRING_LEN(x) RSTRING(x)->len
+#endif
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(x) RSTRING(x)->ptr
+#endif
+#ifndef RSTRING_END
+# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
+#endif
+#ifndef RARRAY_LEN
+# define RARRAY_LEN(x) RARRAY(x)->len
+#endif
+#ifndef RARRAY_PTR
+# define RARRAY_PTR(x) RARRAY(x)->ptr
+#endif
+#ifndef RFLOAT_VALUE
+# define RFLOAT_VALUE(x) RFLOAT(x)->value
+#endif
+#ifndef DOUBLE2NUM
+# define DOUBLE2NUM(x) rb_float_new(x)
+#endif
+#ifndef RHASH_TBL
+# define RHASH_TBL(x) (RHASH(x)->tbl)
+#endif
+#ifndef RHASH_ITER_LEV
+# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
+#endif
+#ifndef RHASH_IFNONE
+# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
+#endif
+#ifndef RHASH_SIZE
+# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
+#endif
+#ifndef RHASH_EMPTY_P
+# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
+#endif
+#ifndef RSTRUCT_LEN
+# define RSTRUCT_LEN(x) RSTRUCT(x)->len
+#endif
+#ifndef RSTRUCT_PTR
+# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
+#endif
+
+
+
+/*
+ * Need to be very careful about how these macros are defined, especially
+ * when compiling C++ code or C code with an ANSI C compiler.
+ *
+ * VALUEFUNC(f) is a macro used to typecast a C function that implements
+ * a Ruby method so that it can be passed as an argument to API functions
+ * like rb_define_method() and rb_define_singleton_method().
+ *
+ * VOIDFUNC(f) is a macro used to typecast a C function that implements
+ * either the "mark" or "free" stuff for a Ruby Data object, so that it
+ * can be passed as an argument to API functions like Data_Wrap_Struct()
+ * and Data_Make_Struct().
+ */
+ 
+#ifdef __cplusplus
+#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
+#    define PROTECTFUNC(f) ((VALUE (*)()) f)
+#    define VALUEFUNC(f) ((VALUE (*)()) f)
+#    define VOIDFUNC(f)  ((void (*)()) f)
+#  else
+#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
+#      define PROTECTFUNC(f) ((VALUE (*)()) f)
+#      define VALUEFUNC(f) ((VALUE (*)()) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    else /* These definitions should work for Ruby 1.7+ */
+#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
+#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    endif
+#  endif
+#else
+#  define VALUEFUNC(f) (f)
+#  define VOIDFUNC(f) (f)
+#endif
+
+/* Don't use for expressions have side effect */
+#ifndef RB_STRING_VALUE
+#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
+#endif
+#ifndef StringValue
+#define StringValue(s) RB_STRING_VALUE(s)
+#endif
+#ifndef StringValuePtr
+#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
+#endif
+#ifndef StringValueLen
+#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
+#endif
+#ifndef SafeStringValue
+#define SafeStringValue(v) do {\
+    StringValue(v);\
+    rb_check_safe_str(v);\
+} while (0)
+#endif
+
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
+#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
+#endif
+
+static VALUE _mSWIG = Qnil;
+
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+
+/* Define some additional error types */
+#define SWIG_ObjectPreviouslyDeletedError  -100
+
+
+/* Define custom exceptions for errors that do not map to existing Ruby
+   exceptions.  Note this only works for C++ since a global cannot be
+   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/
+
+SWIGINTERN VALUE 
+getNullReferenceError(void) {
+  static int init = 0;
+  static VALUE rb_eNullReferenceError ;
+  if (!init) {
+    init = 1;
+    rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
+  }
+  return rb_eNullReferenceError;
+} 
+
+SWIGINTERN VALUE 
+getObjectPreviouslyDeletedError(void) {
+  static int init = 0;
+  static VALUE rb_eObjectPreviouslyDeleted ;
+  if (!init) {
+    init = 1;
+    rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
+  }
+  return rb_eObjectPreviouslyDeleted;
+} 
+
+
+SWIGINTERN VALUE
+SWIG_Ruby_ErrorType(int SWIG_code) {
+  VALUE type;
+  switch (SWIG_code) {
+  case SWIG_MemoryError:
+    type = rb_eNoMemError;
+    break;
+  case SWIG_IOError:
+    type = rb_eIOError;
+    break;
+  case SWIG_RuntimeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_IndexError:
+    type = rb_eIndexError;
+    break;
+  case SWIG_TypeError:
+    type = rb_eTypeError;
+    break;
+  case SWIG_DivisionByZero:
+    type = rb_eZeroDivError;
+    break;
+  case SWIG_OverflowError:
+    type = rb_eRangeError;
+    break;
+  case SWIG_SyntaxError:
+    type = rb_eSyntaxError;
+    break;
+  case SWIG_ValueError:
+    type = rb_eArgError;
+    break;
+  case SWIG_SystemError:
+    type = rb_eFatal;
+    break;
+  case SWIG_AttributeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_NullReferenceError:
+    type = getNullReferenceError();
+    break;
+  case SWIG_ObjectPreviouslyDeletedError:
+    type = getObjectPreviouslyDeletedError();
+    break;
+  case SWIG_UnknownError:
+    type = rb_eRuntimeError;
+    break;
+  default:
+    type = rb_eRuntimeError;
+  }
+  return type;
+}
+
+
+/* This function is called when a user inputs a wrong argument to
+   a method.
+ */
+SWIGINTERN 
+const char* Ruby_Format_TypeError( const char* msg,
+				   const char* type, 
+				   const char* name, 
+				   const int argn,
+				   VALUE input )
+{
+  char buf[128];
+  VALUE str;
+  VALUE asStr;
+  if ( msg && *msg )
+    {
+      str = rb_str_new2(msg);
+    }
+  else
+    {
+      str = rb_str_new(NULL, 0);
+    }
+
+  str = rb_str_cat2( str, "Expected argument " );
+  sprintf( buf, "%d of type ", argn-1 );
+  str = rb_str_cat2( str, buf );
+  str = rb_str_cat2( str, type );
+  str = rb_str_cat2( str, ", but got " );
+  str = rb_str_cat2( str, rb_obj_classname(input) );
+  str = rb_str_cat2( str, " " );
+  asStr = rb_inspect(input);
+  if ( RSTRING_LEN(asStr) > 30 )
+    {
+      str = rb_str_cat( str, StringValuePtr(asStr), 30 );
+      str = rb_str_cat2( str, "..." );
+    }
+  else
+    {
+      str = rb_str_append( str, asStr );
+    }
+
+  if ( name )
+    {
+      str = rb_str_cat2( str, "\n\tin SWIG method '" );
+      str = rb_str_cat2( str, name );
+      str = rb_str_cat2( str, "'" );
+    }
+
+  return StringValuePtr( str );
+}
+
+/* This function is called when an overloaded method fails */
+SWIGINTERN 
+void Ruby_Format_OverloadedError(
+				 const int argc,
+				 const int maxargs,
+				 const char* method, 
+				 const char* prototypes 
+				 )
+{
+  const char* msg = "Wrong # of arguments";
+  if ( argc <= maxargs ) msg = "Wrong arguments";
+  rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
+	   "Possible C/C++ prototypes are:\n%s",
+	   msg, method, prototypes);
+}
+
+/* -----------------------------------------------------------------------------
+ * rubytracking.swg
+ *
+ * This file contains support for tracking mappings from 
+ * Ruby objects to C++ objects.  This functionality is needed
+ * to implement mark functions for Ruby's mark and sweep
+ * garbage collector.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(ST_DATA_T_DEFINED)
+/* Needs to be explicitly included for Ruby 1.8 and earlier */
+#include <st.h>
+#endif
+
+/* Ruby 1.8 actually assumes the first case. */
+#if SIZEOF_VOIDP == SIZEOF_LONG
+#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
+#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
+#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
+#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
+#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
+#else
+#  error sizeof(void*) is not the same as long or long long
+#endif
+
+/* Global hash table to store Trackings from C/C++
+   structs to Ruby Objects. 
+*/
+static st_table* swig_ruby_trackings = NULL;
+
+static VALUE swig_ruby_trackings_count(ID id, VALUE *var) {
+  return SWIG2NUM(swig_ruby_trackings->num_entries);
+}
+
+
+/* Setup a hash table to store Trackings */
+SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
+  /* Create a hash table to store Trackings from C++
+     objects to Ruby objects. */
+
+  /* Try to see if some other .so has already created a 
+     tracking hash table, which we keep hidden in an instance var
+     in the SWIG module.
+     This is done to allow multiple DSOs to share the same
+     tracking table.
+  */
+  VALUE trackings_value = Qnil;
+  /* change the variable name so that we can mix modules
+     compiled with older SWIG's - this used to be called "@__trackings__" */
+  ID trackings_id = rb_intern( "@__safetrackings__" );
+  VALUE verbose = rb_gv_get("VERBOSE");
+  rb_gv_set("VERBOSE", Qfalse);
+  trackings_value = rb_ivar_get( _mSWIG, trackings_id );
+  rb_gv_set("VERBOSE", verbose);
+
+  /* The trick here is that we have to store the hash table
+  pointer in a Ruby variable. We do not want Ruby's GC to
+  treat this pointer as a Ruby object, so we convert it to
+  a Ruby numeric value. */
+  if (trackings_value == Qnil) {
+    /* No, it hasn't.  Create one ourselves */
+    swig_ruby_trackings = st_init_numtable();
+    rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
+  } else {
+    swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
+  }
+
+        rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", RUBY_VALUE_METHOD_FUNC(swig_ruby_trackings_count), RUBY_VOID_METHOD_FUNC((rb_gvar_setter_t*)NULL))
+;
+}
+
+/* Add a Tracking from a C/C++ struct to a Ruby object */
+SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
+  /* Store the mapping to the global hash table. */
+  st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
+}
+
+/* Get the Ruby object that owns the specified C/C++ struct */
+SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
+  /* Now lookup the value stored in the global hash table */
+  VALUE value;
+
+  if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
+    return value;
+  } else {
+    return Qnil;
+  }
+}
+
+/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
+   is very important to remove objects once they are destroyed
+   since the same memory address may be reused later to create
+   a new object. */
+SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
+  /* Delete the object from the hash table */
+  st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
+}
+
+/* This is a helper method that unlinks a Ruby object from its
+   underlying C++ object.  This is needed if the lifetime of the
+   Ruby object is longer than the C++ object */
+SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
+  VALUE object = SWIG_RubyInstanceFor(ptr);
+
+  if (object != Qnil) {
+    if (TYPE(object) != T_DATA)
+      abort();
+    DATA_PTR(object) = 0;
+  }
+}
+
+/* This is a helper method that iterates over all the trackings
+   passing the C++ object pointer and its related Ruby object
+   to the passed callback function. */
+
+/* Proxy method to abstract the internal trackings datatype */
+      static int swig_ruby_internal_iterate_callback(st_data_t ptr, st_data_t obj, st_data_t meth) {
+        ((void(*)(void*, VALUE))meth)((void*)ptr, (VALUE)obj);
+
+  return ST_CONTINUE;
+}
+
+SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
+  st_foreach(swig_ruby_trackings, RUBY_INT_METHOD_FUNC(swig_ruby_internal_iterate_callback), (st_data_t)meth);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Ruby API portion that goes into the runtime
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGINTERN VALUE
+SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
+  if (NIL_P(target)) {
+    target = o;
+  } else {
+    if (TYPE(target) != T_ARRAY) {
+      VALUE o2 = target;
+      target = rb_ary_new();
+      rb_ary_push(target, o2);
+    }
+    rb_ary_push(target, o);
+  }
+  return target;
+}
+
+/* For ruby1.8.4 and earlier. */
+#ifndef RUBY_INIT_STACK
+   RUBY_EXTERN void Init_stack(VALUE* addr);
+#  define RUBY_INIT_STACK \
+   VALUE variable_in_this_stack_frame; \
+   Init_stack(&variable_in_this_stack_frame);
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* -----------------------------------------------------------------------------
+ * rubyrun.swg
+ *
+ * This file contains the runtime support for Ruby modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
+#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
+#define swig_owntype                                    swig_ruby_owntype
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) 		SWIG_Ruby_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
+#define SWIG_Error(code, msg)            		rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
+#define SWIG_fail                        		goto fail				 
+
+
+/* Ruby-specific SWIG API */
+
+#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
+#define SWIG_define_class(ty)                        	SWIG_Ruby_define_class(ty)
+#define SWIG_NewClassInstance(value, ty)             	SWIG_Ruby_NewClassInstance(value, ty)
+#define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
+#define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  
+
+#include "assert.h"
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  VALUE klass;
+  VALUE mImpl;
+  void  (*mark)(void *);
+  void  (*destroy)(void *);
+  int trackObjects;
+} swig_class;
+
+
+/* Global pointer used to keep some internal SWIG stuff */
+static VALUE _cSWIG_Pointer = Qnil;
+static VALUE swig_runtime_data_type_pointer = Qnil;
+
+/* Global IDs used to keep some internal SWIG stuff */
+static ID swig_arity_id = 0;
+static ID swig_call_id  = 0;
+
+/*
+  If your swig extension is to be run within an embedded ruby and has
+  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
+  This will reset ruby's stack frame on each entry point from the main 
+  program the first time a virtual director function is invoked (in a 
+  non-recursive way).
+  If this is not done, you run the risk of Ruby trashing the stack.
+*/
+
+#ifdef RUBY_EMBEDDED
+
+#  define SWIG_INIT_STACK                            \
+      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
+      ++swig_virtual_calls;
+#  define SWIG_RELEASE_STACK --swig_virtual_calls;
+#  define Ruby_DirectorTypeMismatchException(x) \
+          rb_raise( rb_eTypeError, "%s", x ); return c_result;
+
+      static unsigned int swig_virtual_calls = 0;
+
+#else  /* normal non-embedded extension */
+
+#  define SWIG_INIT_STACK
+#  define SWIG_RELEASE_STACK
+#  define Ruby_DirectorTypeMismatchException(x) \
+          throw Swig::DirectorTypeMismatchException( x );
+
+#endif  /* RUBY_EMBEDDED */
+
+
+SWIGRUNTIME VALUE 
+getExceptionClass(void) {
+  static int init = 0;
+  static VALUE rubyExceptionClass ;
+  if (!init) {
+    init = 1;
+    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
+  }
+  return rubyExceptionClass;
+} 
+
+/* This code checks to see if the Ruby object being raised as part
+   of an exception inherits from the Ruby class Exception.  If so,
+   the object is simply returned.  If not, then a new Ruby exception
+   object is created and that will be returned to Ruby.*/
+SWIGRUNTIME VALUE
+SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
+  VALUE exceptionClass = getExceptionClass();
+  if (rb_obj_is_kind_of(obj, exceptionClass)) {
+    return obj;
+  }  else {
+    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
+  }
+}
+
+/* Initialize Ruby runtime support */
+SWIGRUNTIME void
+SWIG_Ruby_InitRuntime(void)
+{
+  if (_mSWIG == Qnil) {
+    _mSWIG = rb_define_module("SWIG");
+    swig_call_id  = rb_intern("call");
+    swig_arity_id = rb_intern("arity");
+  }
+}
+
+/* Define Ruby class for C type */
+SWIGRUNTIME void
+SWIG_Ruby_define_class(swig_type_info *type)
+{
+  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+  sprintf(klass_name, "TYPE%s", type->name);
+  if (NIL_P(_cSWIG_Pointer)) {
+    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
+    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
+  }
+  rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
+  free((void *) klass_name);
+}
+
+/* Create a new pointer object */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
+{
+  int own =  flags & SWIG_POINTER_OWN; 
+  int track;
+  char *klass_name;
+  swig_class *sklass;
+  VALUE klass;
+  VALUE obj;
+  
+  if (!ptr)
+    return Qnil;
+  
+  if (type->clientdata) {
+    sklass = (swig_class *) type->clientdata;
+		
+    /* Are we tracking this class and have we already returned this Ruby object? */
+    track = sklass->trackObjects;
+    if (track) {
+      obj = SWIG_RubyInstanceFor(ptr);
+      
+      /* Check the object's type and make sure it has the correct type.
+        It might not in cases where methods do things like 
+        downcast methods. */
+      if (obj != Qnil) {
+        VALUE value = rb_iv_get(obj, "@__swigtype__");
+        const char* type_name = RSTRING_PTR(value);
+				
+        if (strcmp(type->name, type_name) == 0) {
+          return obj;
+        }
+      }
+    }
+
+    /* Create a new Ruby object */
+    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
+			   ( own ? VOIDFUNC(sklass->destroy) : 
+			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
+			     ), ptr);
+
+    /* If tracking is on for this class then track this object. */
+    if (track) {
+      SWIG_RubyAddTracking(ptr, obj);
+    }
+  } else {
+    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+    sprintf(klass_name, "TYPE%s", type->name);
+    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
+    free((void *) klass_name);
+    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
+  }
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  
+  return obj;
+}
+
+/* Create a new class instance (always owned) */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
+{
+  VALUE obj;
+  swig_class *sklass = (swig_class *) type->clientdata;
+  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  return obj;
+}
+
+/* Get type mangle from class name */
+SWIGRUNTIMEINLINE char *
+SWIG_Ruby_MangleStr(VALUE obj)
+{
+  VALUE stype = rb_iv_get(obj, "@__swigtype__");
+  return StringValuePtr(stype);
+}
+
+/* Acquire a pointer value */
+typedef struct {
+  void (*datafree)(void *);
+  int own;
+} swig_ruby_owntype;
+
+SWIGRUNTIME swig_ruby_owntype
+SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
+  swig_ruby_owntype oldown = {0, 0};
+  if (obj) {
+    oldown.datafree = RDATA(obj)->dfree;
+    RDATA(obj)->dfree = own.datafree;
+  }
+  return oldown;
+}
+
+/* Convert a pointer value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
+{
+  char *c;
+  swig_cast_info *tc;
+  void *vptr = 0;
+
+  /* Grab the pointer */
+  if (NIL_P(obj)) {
+    if (ptr)
+      *ptr = 0;
+    return SWIG_OK;
+  } else {
+    if (TYPE(obj) != T_DATA) {
+      return SWIG_ERROR;
+    }
+    Data_Get_Struct(obj, void, vptr);
+  }
+  
+  if (own) {
+    own->datafree = RDATA(obj)->dfree;
+    own->own = 0;
+  }
+    
+  /* Check to see if the input object is giving up ownership
+     of the underlying C struct or C++ object.  If so then we
+     need to reset the destructor since the Ruby object no 
+     longer owns the underlying C++ object.*/ 
+  if (flags & SWIG_POINTER_DISOWN) {
+    /* Is tracking on for this class? */
+    int track = 0;
+    if (ty && ty->clientdata) {
+      swig_class *sklass = (swig_class *) ty->clientdata;
+      track = sklass->trackObjects;
+    }
+		
+    if (track) {
+      /* We are tracking objects for this class.  Thus we change the destructor
+       * to SWIG_RubyRemoveTracking.  This allows us to
+       * remove the mapping from the C++ to Ruby object
+       * when the Ruby object is garbage collected.  If we don't
+       * do this, then it is possible we will return a reference 
+       * to a Ruby object that no longer exists thereby crashing Ruby. */
+      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
+    } else {    
+      RDATA(obj)->dfree = 0;
+    }
+  }
+
+  /* Do type-checking if type info was provided */
+  if (ty) {
+    if (ty->clientdata) {
+      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
+        if (vptr == 0) {
+          /* The object has already been deleted */
+          return SWIG_ObjectPreviouslyDeletedError;
+        }
+      }
+    }
+    if ((c = SWIG_MangleStr(obj)) == NULL) {
+      return SWIG_ERROR;
+    }
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) {
+      return SWIG_ERROR;
+    } else {
+      if (ptr) {
+        if (tc->type == ty) {
+          *ptr = vptr;
+        } else {
+          int newmemory = 0;
+          *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
+          if (newmemory == SWIG_CAST_NEW_MEMORY) {
+            assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+            if (own)
+              own->own = own->own | SWIG_CAST_NEW_MEMORY;
+          }
+        }
+      }
+    }
+  } else {
+    if (ptr)
+      *ptr = vptr;
+  }
+  
+  return SWIG_OK;
+}
+
+/* Check convert */
+SWIGRUNTIMEINLINE int
+SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
+{
+  char *c = SWIG_MangleStr(obj);
+  if (!c) return 0;
+  return SWIG_TypeCheck(c,ty) != 0;
+}
+
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r, ptr, sz);
+  strcpy(r, type->name);
+  return rb_str_new2(result);
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c;
+
+  if (TYPE(obj) != T_STRING) goto type_error;
+  c = StringValuePtr(obj);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') goto type_error;
+  c++;
+  c = SWIG_UnpackData(c, ptr, sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) goto type_error;
+  }
+  return SWIG_OK;
+
+ type_error:
+  return SWIG_ERROR;
+}
+
+SWIGRUNTIME swig_module_info *
+SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
+{
+  VALUE pointer;
+  swig_module_info *ret = 0;
+  VALUE verbose = rb_gv_get("VERBOSE");
+
+ /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
+  rb_gv_set("VERBOSE", Qfalse);
+  
+  /* first check if pointer already created */
+  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  if (pointer != Qnil) {
+    Data_Get_Struct(pointer, swig_module_info, ret);
+  }
+
+  /* reinstate warnings */
+  rb_gv_set("VERBOSE", verbose);
+  return ret;
+}
+
+SWIGRUNTIME void 
+SWIG_Ruby_SetModule(swig_module_info *pointer)
+{
+  /* register a new class */
+  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
+  /* create and store the structure pointer to a global variable */
+  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
+  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
+}
+
+/* This function can be used to check whether a proc or method or similarly
+   callable function has been passed.  Usually used in a %typecheck, like:
+
+   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
+        $result = SWIG_Ruby_isCallable( $input );
+   }
+ */
+SWIGINTERN
+int SWIG_Ruby_isCallable( VALUE proc )
+{
+  if ( rb_respond_to( proc, swig_call_id ) )
+    return 1;
+  return 0;
+}
+
+/* This function can be used to check the arity (number of arguments)
+   a proc or method can take.  Usually used in a %typecheck.
+   Valid arities will be that equal to minimal or those < 0
+   which indicate a variable number of parameters at the end.
+ */
+SWIGINTERN
+int SWIG_Ruby_arity( VALUE proc, int minimal )
+{
+  if ( rb_respond_to( proc, swig_arity_id ) )
+    {
+      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
+      int arity = NUM2INT(num);
+      if ( arity < 0 && (arity+1) < -minimal ) return 1;
+      if ( arity == minimal ) return 1;
+      return 1;
+    }
+  return 0;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
+
+
+
+  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) 
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_p_FXAccelTable swig_types[0]
+#define SWIGTYPE_p_FXApp swig_types[1]
+#define SWIGTYPE_p_FXBitmap swig_types[2]
+#define SWIGTYPE_p_FXCURCursor swig_types[3]
+#define SWIGTYPE_p_FXChore swig_types[4]
+#define SWIGTYPE_p_FXComposeContext swig_types[5]
+#define SWIGTYPE_p_FXComposite swig_types[6]
+#define SWIGTYPE_p_FXCursor swig_types[7]
+#define SWIGTYPE_p_FXDataTarget swig_types[8]
+#define SWIGTYPE_p_FXDebugTarget swig_types[9]
+#define SWIGTYPE_p_FXDelegator swig_types[10]
+#define SWIGTYPE_p_FXDict swig_types[11]
+#define SWIGTYPE_p_FXDocument swig_types[12]
+#define SWIGTYPE_p_FXDrawable swig_types[13]
+#define SWIGTYPE_p_FXEvent swig_types[14]
+#define SWIGTYPE_p_FXFileAssoc swig_types[15]
+#define SWIGTYPE_p_FXFileDict swig_types[16]
+#define SWIGTYPE_p_FXFileStream swig_types[17]
+#define SWIGTYPE_p_FXFont swig_types[18]
+#define SWIGTYPE_p_FXFontDesc swig_types[19]
+#define SWIGTYPE_p_FXFrame swig_types[20]
+#define SWIGTYPE_p_FXGIFCursor swig_types[21]
+#define SWIGTYPE_p_FXID swig_types[22]
+#define SWIGTYPE_p_FXIcon swig_types[23]
+#define SWIGTYPE_p_FXIconDict swig_types[24]
+#define SWIGTYPE_p_FXIconSource swig_types[25]
+#define SWIGTYPE_p_FXId swig_types[26]
+#define SWIGTYPE_p_FXMainWindow swig_types[27]
+#define SWIGTYPE_p_FXMemoryStream swig_types[28]
+#define SWIGTYPE_p_FXMutex swig_types[29]
+#define SWIGTYPE_p_FXObject swig_types[30]
+#define SWIGTYPE_p_FXPoint swig_types[31]
+#define SWIGTYPE_p_FXPopup swig_types[32]
+#define SWIGTYPE_p_FXRecentFiles swig_types[33]
+#define SWIGTYPE_p_FXRectangle swig_types[34]
+#define SWIGTYPE_p_FXRegion swig_types[35]
+#define SWIGTYPE_p_FXRegistry swig_types[36]
+#define SWIGTYPE_p_FXRootWindow swig_types[37]
+#define SWIGTYPE_p_FXSettings swig_types[38]
+#define SWIGTYPE_p_FXShell swig_types[39]
+#define SWIGTYPE_p_FXSize swig_types[40]
+#define SWIGTYPE_p_FXSplashWindow swig_types[41]
+#define SWIGTYPE_p_FXStream swig_types[42]
+#define SWIGTYPE_p_FXString swig_types[43]
+#define SWIGTYPE_p_FXStringDict swig_types[44]
+#define SWIGTYPE_p_FXTextCodec swig_types[45]
+#define SWIGTYPE_p_FXTimer swig_types[46]
+#define SWIGTYPE_p_FXTopWindow swig_types[47]
+#define SWIGTYPE_p_FXTranslator swig_types[48]
+#define SWIGTYPE_p_FXVisual swig_types[49]
+#define SWIGTYPE_p_FXWindow swig_types[50]
+#define SWIGTYPE_p_char swig_types[51]
+#define SWIGTYPE_p_double swig_types[52]
+#define SWIGTYPE_p_float swig_types[53]
+#define SWIGTYPE_p_int swig_types[54]
+#define SWIGTYPE_p_long swig_types[55]
+#define SWIGTYPE_p_p_FXComposite swig_types[56]
+#define SWIGTYPE_p_p_FXFrame swig_types[57]
+#define SWIGTYPE_p_p_FXMainWindow swig_types[58]
+#define SWIGTYPE_p_p_FXPopup swig_types[59]
+#define SWIGTYPE_p_p_FXRootWindow swig_types[60]
+#define SWIGTYPE_p_p_FXShell swig_types[61]
+#define SWIGTYPE_p_p_FXSplashWindow swig_types[62]
+#define SWIGTYPE_p_p_FXTopWindow swig_types[63]
+#define SWIGTYPE_p_p_FXWindow swig_types[64]
+#define SWIGTYPE_p_p_char swig_types[65]
+#define SWIGTYPE_p_short swig_types[66]
+#define SWIGTYPE_p_unsigned_char swig_types[67]
+#define SWIGTYPE_p_unsigned_int swig_types[68]
+#define SWIGTYPE_p_unsigned_long swig_types[69]
+#define SWIGTYPE_p_unsigned_short swig_types[70]
+#define SWIGTYPE_p_void swig_types[71]
+static swig_type_info *swig_types[73];
+static swig_module_info swig_module = {swig_types, 72, 0, 0, 0, 0};
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
+
+/* -------- TYPES TABLE (END) -------- */
+
+#define SWIG_init    Init_core
+#define SWIG_name    "Core"
+
+VALUE mFox;
+
+#define SWIG_RUBY_THREAD_BEGIN_BLOCK
+#define SWIG_RUBY_THREAD_END_BLOCK
+
+
+#define SWIGVERSION 0x030012 
+#define SWIG_VERSION SWIGVERSION
+
+
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
+
+
+#include <stdexcept>
+
+
+#include "FXRbCommon.h"
+
+
+inline FXColor to_FXColor(VALUE obj){
+  if(TYPE(obj)==T_STRING){
+    return fxcolorfromname(StringValuePtr(obj));
+    }
+  else if(TYPE(obj)==T_SYMBOL){
+    return fxcolorfromname(rb_id2name(SYM2ID(obj)));
+    }
+  else{
+    return NUM2ULONG(obj);
+    }
+  }
+
+
+inline FXString to_FXString(VALUE obj){
+  if(!NIL_P(obj)){
+    Check_Type(obj,T_STRING);
+    return FXString(StringValuePtr(obj));
+    }
+  else{
+    return FXString::null;
+    }
+  }
+
+
+inline FXbool to_FXbool(VALUE obj){
+  if (obj == Qtrue || obj == Qfalse){
+    return (obj == Qtrue) ? TRUE : FALSE;
+    }
+  else{
+    return static_cast<FXbool>(NUM2UINT(obj));
+    }
+  }
+
+
+static swig_type_info* FXEventTypeInfo=0;
+
+inline void* to_FXEvent(VALUE obj){
+  void* ptr;
+  if(!FXEventTypeInfo){
+    FXEventTypeInfo=SWIG_TypeQuery("FXEvent *");
+    FXASSERT(FXEventTypeInfo!=0);
+    }
+  SWIG_ConvertPtr(obj,&ptr,FXEventTypeInfo,1);
+  return ptr;
+  }
+
+
+void setIgnoreExceptions(VALUE ignore){
+  extern FXbool FXRbCatchExceptions;
+  FXRbCatchExceptions=(ignore==Qtrue)? TRUE : FALSE;
+  }
+
+
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
+
+
+  #define SWIG_From_long   LONG2NUM 
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_int  (int value)
+{    
+  return SWIG_From_long  (value);
+}
+
+
+static FXuint _MKUINT(FXushort l,FXushort h){
+  return MKUINT(l,h);
+  }
+
+static FXuint _FXSEL(FXushort type,FXushort id){
+  return FXSEL(type,id);
+  }
+
+static FXushort _FXSELTYPE(FXuint s){
+  return FXSELTYPE(s);
+  }
+
+static FXushort _FXSELID(FXuint s){
+  return FXSELID(s);
+  }
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_long  (unsigned long value)
+{
+  return ULONG2NUM(value); 
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_int  (unsigned int value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_short  (unsigned short value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+
+static FXuint _FXRGB(FXuchar r,FXuchar g,FXuchar b){
+  return FXRGB(r,g,b);
+  }
+
+static FXuint _FXRGBA(FXuchar r,FXuchar g,FXuchar b,FXuchar a){
+  return FXRGBA(r,g,b,a);
+  }
+
+static FXuchar _FXREDVAL(FXuint rgba){
+  return FXREDVAL(rgba);
+  }
+
+static FXuchar _FXGREENVAL(FXuint rgba){
+  return FXGREENVAL(rgba);
+  }
+
+static FXuchar _FXBLUEVAL(FXuint rgba){
+  return FXBLUEVAL(rgba);
+  }
+
+static FXuchar _FXALPHAVAL(FXuint rgba){
+  return FXALPHAVAL(rgba);
+  }
+
+static FXuchar _FXRGBACOMPVAL(FXuint rgba,FXuchar comp){
+  return FXRGBACOMPVAL(rgba,comp);
+  }
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_char  (unsigned char value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+
+SWIGINTERN VALUE
+SWIG_ruby_failed(VALUE, VALUE)
+{
+  return Qnil;
+} 
+
+
+/*@SWIG:/usr/share/swig3.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE pargs){VALUE *args=(VALUE *)pargs;
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  unsigned long *res = (unsigned long *)(args[1]);
+  *res = type == T_FIXNUM ? NUM2ULONG(obj) : rb_big2ulong(obj);
+  return obj;
+}
+/*@SWIG@*/
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_long (VALUE obj, unsigned long *val) 
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
+    unsigned long v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_VALUE_METHOD_FUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, RUBY_VALUE_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_int (VALUE obj, unsigned int *val)
+{
+  unsigned long v;
+  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
+  if (SWIG_IsOK(res)) {
+    if ((v > UINT_MAX)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = static_cast< unsigned int >(v);
+    }
+  }  
+  return res;
+}
+
+
+SWIGINTERN swig_type_info*
+SWIG_pchar_descriptor(void)
+{
+  static int init = 0;
+  static swig_type_info* info = 0;
+  if (!init) {
+    info = SWIG_TypeQuery("_p_char");
+    init = 1;
+  }
+  return info;
+}
+
+
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
+{
+  if (TYPE(obj) == T_STRING) {
+    char *cstr = StringValuePtr(obj); 
+    size_t size = RSTRING_LEN(obj) + 1;
+    if (cptr)  {
+      if (alloc) {
+	if (*alloc == SWIG_NEWOBJ) {
+	  *cptr = reinterpret_cast< char* >(memcpy(new char[size], cstr, sizeof(char)*(size)));
+	} else {
+	  *cptr = cstr;
+	  *alloc = SWIG_OLDOBJ;
+	}
+      }
+    }
+    if (psize) *psize = size;
+    return SWIG_OK;
+  } else {
+    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+    if (pchar_descriptor) {
+      void* vptr = 0;
+      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
+	if (cptr) *cptr = (char *)vptr;
+	if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
+	if (alloc) *alloc = SWIG_OLDOBJ;
+	return SWIG_OK;
+      }
+    }
+  }  
+  return SWIG_TypeError;
+}
+
+
+
+
+
+  /// Get name of (closest) color to RGB
+  FXchar* fxnamefromcolor(FXColor color){
+    static FXchar colorname[128]; // should be large enough, but still a buffer overflow risk!
+    return fxnamefromcolor(colorname,color);
+    }
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+  if (carray) {
+    if (size > LONG_MAX) {
+      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+      return pchar_descriptor ? 
+	SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : Qnil;
+    } else {
+      return rb_str_new(carray, static_cast< long >(size));
+    }
+  } else {
+    return Qnil;
+  }
+}
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtr(const char *cptr)
+{ 
+  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
+}
+
+
+/// Convert RGB to HSV
+VALUE fxrgb_to_hsv(FXfloat r,FXfloat g,FXfloat b){
+  FXfloat h,s,v;
+  fxrgb_to_hsv(h,s,v,r,g,b);
+  VALUE ary=rb_ary_new();
+  rb_ary_push(ary,rb_float_new(h));
+  rb_ary_push(ary,rb_float_new(s));
+  rb_ary_push(ary,rb_float_new(v));
+  return ary;
+  }
+
+/// Convert HSV to RGB
+VALUE fxhsv_to_rgb(FXfloat h,FXfloat s,FXfloat v){
+  FXfloat r,g,b;
+  fxhsv_to_rgb(r,g,b,h,s,v);
+  VALUE ary=rb_ary_new();
+  rb_ary_push(ary,rb_float_new(r));
+  rb_ary_push(ary,rb_float_new(g));
+  rb_ary_push(ary,rb_float_new(b));
+  return ary;
+  }
+
+
+#include <float.h>
+
+
+#include <math.h>
+
+
+/* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */
+#ifndef SWIG_isfinite
+/* isfinite() is a macro for C99 */
+# if defined(isfinite)
+#  define SWIG_isfinite(X) (isfinite(X))
+# elif defined __cplusplus && __cplusplus >= 201103L
+/* Use a template so that this works whether isfinite() is std::isfinite() or
+ * in the global namespace.  The reality seems to vary between compiler
+ * versions.
+ *
+ * Make sure namespace std exists to avoid compiler warnings.
+ *
+ * extern "C++" is required as this fragment can end up inside an extern "C" { } block
+ */
+namespace std { }
+extern "C++" template<typename T>
+inline int SWIG_isfinite_func(T x) {
+  using namespace std;
+  return isfinite(x);
+}
+#  define SWIG_isfinite(X) (SWIG_isfinite_func(X))
+# elif defined(_MSC_VER)
+#  define SWIG_isfinite(X) (_finite(X))
+# elif defined(__sun) && defined(__SVR4)
+#  include <ieeefp.h>
+#  define SWIG_isfinite(X) (finite(X))
+# endif
+#endif
+
+
+/* Accept infinite as a valid float value unless we are unable to check if a value is finite */
+#ifdef SWIG_isfinite
+# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX) && SWIG_isfinite(X))
+#else
+# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX))
+#endif
+
+
+/*@SWIG:/usr/share/swig3.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE pargs){VALUE *args=(VALUE *)pargs;
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  double *res = (double *)(args[1]);
+  *res = NUM2DBL(obj); (void)type;
+  return obj;
+}
+/*@SWIG@*/
+
+SWIGINTERN int
+SWIG_AsVal_double (VALUE obj, double *val)
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FLOAT) || (type == T_FIXNUM) || (type == T_BIGNUM)) {
+    double v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_VALUE_METHOD_FUNC(SWIG_AUX_NUM2DBL), (VALUE)a, RUBY_VALUE_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_float (VALUE obj, float *val)
+{
+  double v;
+  int res = SWIG_AsVal_double (obj, &v);
+  if (SWIG_IsOK(res)) {
+    if (SWIG_Float_Overflow_Check(v)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = static_cast< float >(v);
+    }
+  }  
+  return res;
+}
+
+
+VALUE fxparsegeometry(const FXchar *string){
+  FXint x,y,w,h;
+  FXint result=fxparsegeometry(string,x,y,w,h);
+  VALUE ary=rb_ary_new();
+  rb_ary_push(ary,INT2NUM(result));
+  rb_ary_push(ary,INT2NUM(x));
+  rb_ary_push(ary,INT2NUM(y));
+  rb_ary_push(ary,INT2NUM(w));
+  rb_ary_push(ary,INT2NUM(h));
+  return ary;
+  }
+
+
+/// Version number that the library has been compiled with
+VALUE _fxversion(){
+  FXString version=FXStringFormat("%d.%d.%d",fxversion[0],fxversion[1],fxversion[2]);
+  return to_ruby(version);
+  }
+
+SWIGINTERN FXStream *new_FXStream(FXObject const *cont=0){
+      return new FXRbStream(cont);
+      }
+
+/*@SWIG:/usr/share/swig3.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE pargs){VALUE *args=(VALUE *)pargs;
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  long *res = (long *)(args[1]);
+  *res = type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj);
+  return obj;
+}
+/*@SWIG@*/
+
+SWIGINTERN int
+SWIG_AsVal_long (VALUE obj, long* val)
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
+    long v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_VALUE_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_VALUE_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_int (VALUE obj, int *val)
+{
+  long v;
+  int res = SWIG_AsVal_long (obj, &v);
+  if (SWIG_IsOK(res)) {
+    if ((v < INT_MIN || v > INT_MAX)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = static_cast< int >(v);
+    }
+  }  
+  return res;
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_bool  (bool value)
+{
+  return value ? Qtrue : Qfalse;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_bool (VALUE obj, bool *val)
+{
+  if (obj == Qtrue) {
+    if (val) *val = true;
+    return SWIG_OK;
+  } else if (obj == Qfalse) {
+    if (val) *val = false;
+    return SWIG_OK;
+  } else {
+    int res = 0;
+    if (SWIG_AsVal_int (obj, &res) == SWIG_OK) {    
+      if (val) *val = res ? true : false;
+      return SWIG_OK;
+    }
+  }  
+  return SWIG_TypeError;
+}
+
+SWIGINTERN FXFileStream *new_FXFileStream(FXObject const *cont=0){
+      return new FXRbFileStream(cont);
+      }
+SWIGINTERN FXMemoryStream *new_FXMemoryStream(FXObject const *cont=0){
+      return new FXRbMemoryStream(cont);
+      }
+SWIGINTERN bool FXMemoryStream_open(FXMemoryStream *self,FXStreamDirection save_or_load,VALUE str){
+      FXuval size=0;
+      FXuchar *data=0;
+      if(!NIL_P(str)){
+        size=RSTRING_LEN(str);
+        data=reinterpret_cast<FXuchar*>(StringValuePtr(str));
+        return self->open(save_or_load,size,data);
+        }
+      else{
+        return self->open(save_or_load,data);
+        }
+      }
+SWIGINTERN VALUE FXMemoryStream_takeBuffer(FXMemoryStream *self){
+      FXuchar* buffer;
+      FXuval sp;
+      self->takeBuffer(buffer,sp);
+      VALUE result=rb_str_new(const_cast<const char *>(reinterpret_cast<char*>(buffer)),sp);
+      FXFREE(&buffer);
+      return result;
+      }
+SWIGINTERN void FXMemoryStream_giveBuffer(FXMemoryStream *self,VALUE str){
+      FXuchar* copy = 0;
+      Check_Type(str,T_STRING);
+      FXuchar* buffer=reinterpret_cast<FXuchar*>(StringValuePtr(str));
+      FXuval sp=RSTRING_LEN(str);
+      if( FXMALLOC(&copy, FXuchar *, sp)) {
+        memcpy(copy, buffer, sp);
+        self->giveBuffer(copy,sp);
+        }
+      }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_short  (short value)
+{    
+  return SWIG_From_long  (value);
+}
+
+SWIGINTERN bool FXSize_operator_Se__Se_(FXSize const *self,FXSize const &s){ return (*self == s); }
+SWIGINTERN FXSize FXSize_operator_Sa_(FXSize const *self,FXSize const &s){ return *self + s; }
+SWIGINTERN FXSize FXSize_operator_Ss_(FXSize const *self,FXSize const &s){ return *self - s; }
+SWIGINTERN FXSize FXSize_operator_Sm_(FXSize const *self,FXshort c){ return *self * c; }
+SWIGINTERN FXSize FXSize_operator_Sd_(FXSize const *self,FXshort c){ return *self / c; }
+SWIGINTERN bool FXPoint_operator_Se__Se_(FXPoint const *self,FXPoint const &p){ return *self == p; }
+SWIGINTERN FXPoint FXPoint_operator_Sa___SWIG_0(FXPoint const *self,FXPoint const &p){ return *self + p; }
+SWIGINTERN FXPoint FXPoint_operator_Sa___SWIG_1(FXPoint const *self,FXSize const &s){ return *self + s; }
+SWIGINTERN FXPoint FXPoint_operator_Ss___SWIG_0(FXPoint const *self,FXPoint const &p){ return *self - p; }
+SWIGINTERN FXPoint FXPoint_operator_Ss___SWIG_1(FXPoint const *self,FXSize const &s){ return *self - s; }
+SWIGINTERN FXPoint FXPoint_operator_Sm_(FXPoint const *self,FXshort c){ return *self * c; }
+SWIGINTERN FXPoint FXPoint_operator_Sd_(FXPoint const *self,FXshort c){ return *self / c; }
+SWIGINTERN bool FXRectangle_operator_Se__Se_(FXRectangle const *self,FXRectangle const &p){
+      return *self == p;
+      }
+SWIGINTERN bool FXRectangle_overlap(FXRectangle const *self,FXRectangle const &p){
+      return overlap(*self,p);
+      }
+SWIGINTERN FXRectangle FXRectangle_operator_Sa_(FXRectangle const *self,FXRectangle const &p){
+      return *self + p;
+      }
+SWIGINTERN FXRectangle FXRectangle_operator_Sm_(FXRectangle const *self,FXRectangle const &p){
+      return *self * p;
+      }
+SWIGINTERN FXRegion FXRegion_operator_Sa_(FXRegion const *self,FXRegion const &other){ return (*self)+other; }
+SWIGINTERN FXRegion FXRegion_operator_Sm_(FXRegion const *self,FXRegion const &other){ return (*self)*other; }
+SWIGINTERN FXRegion FXRegion_operator_Ss_(FXRegion const *self,FXRegion const &other){ return (*self)-other; }
+SWIGINTERN FXRegion FXRegion_operator_Sx_(FXRegion const *self,FXRegion const &other){ return (*self)^other; }
+SWIGINTERN bool FXRegion_operator_Se__Se_(FXRegion const *self,FXRegion const &other){ return (*self)==other; }
+SWIGINTERN FXObject *new_FXObject(){
+      return new FXRbObject();
+      }
+
+static swig_type_info *FXObject_dynamic_cast(void **ptr) {
+    FXObject **ppObject = reinterpret_cast<FXObject **>(ptr);
+    FXAccelTable *pAccelTable=dynamic_cast<FXAccelTable*>(*ppObject);
+    if(pAccelTable){
+      *ptr=reinterpret_cast<void*>(pAccelTable);
+      return SWIG_TypeQuery("FXAccelTable *");
+      }
+    FXApp *pApp=dynamic_cast<FXApp*>(*ppObject);
+    if(pApp){
+      *ptr=reinterpret_cast<void*>(pApp);
+      return SWIG_TypeQuery("FXApp *");
+      }
+    FXDataTarget *pDataTarget=dynamic_cast<FXDataTarget*>(*ppObject);
+    if(pDataTarget){
+      *ptr=reinterpret_cast<void*>(pDataTarget);
+      return SWIG_TypeQuery("FXDataTarget *");
+      }
+    FXDebugTarget *pDebugTarget=dynamic_cast<FXDebugTarget*>(*ppObject);
+    if(pDebugTarget){
+      *ptr=reinterpret_cast<void*>(pDebugTarget);
+      return SWIG_TypeQuery("FXDebugTarget *");
+      }
+    FXDelegator *pDelegator=dynamic_cast<FXDelegator*>(*ppObject);
+    if(pDelegator){
+      *ptr=reinterpret_cast<void*>(pDelegator);
+      return SWIG_TypeQuery("FXDelegator *");
+      }
+    FXDict *pDict=dynamic_cast<FXDict*>(*ppObject);
+    if(pDict){
+      *ptr=reinterpret_cast<void*>(pDict);
+      return SWIG_TypeQuery("FXDict *");
+      }
+    FXDocument *pDocument=dynamic_cast<FXDocument*>(*ppObject);
+    if(pDocument){
+      *ptr=reinterpret_cast<void*>(pDocument);
+      return SWIG_TypeQuery("FXDocument *");
+      }
+    FXGLObject *pGLObject=dynamic_cast<FXGLObject*>(*ppObject);
+    if(pGLObject){
+      *ptr=reinterpret_cast<void*>(pGLObject);
+      return SWIG_TypeQuery("FXGLObject *");
+      }
+    FXHeaderItem *pHeaderItem=dynamic_cast<FXHeaderItem*>(*ppObject);
+    if(pHeaderItem){
+      *ptr=reinterpret_cast<void*>(pHeaderItem);
+      return SWIG_TypeQuery("FXHeaderItem *");
+      }
+    FXIconItem *pIconItem=dynamic_cast<FXIconItem*>(*ppObject);
+    if(pIconItem){
+      *ptr=reinterpret_cast<void*>(pIconItem);
+      return SWIG_TypeQuery("FXIconItem *");
+      }
+    FXIconSource *pIconSource=dynamic_cast<FXIconSource*>(*ppObject);
+    if(pIconSource){
+      *ptr=reinterpret_cast<void*>(pIconSource);
+      return SWIG_TypeQuery("FXIconSource *");
+      }
+    FXId *pId=dynamic_cast<FXId*>(*ppObject);
+    if(pId){
+      *ptr=reinterpret_cast<void*>(pId);
+      return SWIG_TypeQuery("FXId *");
+      }
+    FXListItem *pListItem=dynamic_cast<FXListItem*>(*ppObject);
+    if(pListItem){
+      *ptr=reinterpret_cast<void*>(pListItem);
+      return SWIG_TypeQuery("FXListItem *");
+      }
+    FXRecentFiles *pRecentFiles=dynamic_cast<FXRecentFiles*>(*ppObject);
+    if(pRecentFiles){
+      *ptr=reinterpret_cast<void*>(pRecentFiles);
+      return SWIG_TypeQuery("FXRecentFiles *");
+      }
+    FXTableItem *pTableItem=dynamic_cast<FXTableItem*>(*ppObject);
+    if(pTableItem){
+      *ptr=reinterpret_cast<void*>(pTableItem);
+      return SWIG_TypeQuery("FXTableItem *");
+      }
+    FXTreeItem *pTreeItem=dynamic_cast<FXTreeItem*>(*ppObject);
+    if(pTreeItem){
+      *ptr=reinterpret_cast<void*>(pTreeItem);
+      return SWIG_TypeQuery("FXTreeItem *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXAccelTable *new_FXAccelTable(){
+      return new FXRbAccelTable();
+      }
+SWIGINTERN VALUE FXApp_copyright(){
+      return to_ruby(FXApp::copyright);
+    }
+SWIGINTERN FXApp *new_FXApp(FXchar const *name="Application",FXchar const *vendor="FoxDefault"){
+      if(FXApp::instance()){
+        rb_raise(rb_eRuntimeError,"attempted to create more than one FXApp instance");
+        return 0;
+        }
+      else{
+        return FXRbApp::constructAndInit(name,vendor);
+        }
+      }
+SWIGINTERN FXuval FXApp_getDisplay(FXApp const *self){
+      return reinterpret_cast<FXuval>(self->getDisplay());
+      }
+SWIGINTERN void FXApp_setDefaultVisual(FXApp *self,FXVisual *vis){
+      FXASSERT(vis);
+      if(vis->isMemberOf(FXMETACLASS(FXRbVisual))){
+        dynamic_cast<FXRbVisual*>(vis)->ownedByApp=1;
+        }
+      else if(vis->isMemberOf(FXMETACLASS(FXRbGLVisual))){
+        dynamic_cast<FXRbGLVisual*>(vis)->ownedByApp=1;
+        }
+      self->setDefaultVisual(vis);
+      }
+SWIGINTERN void FXApp_addSignal(FXApp *self,VALUE sigObj,FXObject *tgt,FXSelector sel,FXbool immediate=0,FXuint flags=0){
+      const char *s;
+      FXint sig;
+      switch(TYPE(sigObj)){
+        case T_STRING:
+          s=StringValuePtr(sigObj);
+          sig=FXRbSignalNameToNumber(s);
+          if(sig==0) rb_raise(rb_eArgError,"unrecognized signal name `%s'",s);
+          break;
+        case T_FIXNUM:
+          sig=(FXint)NUM2INT(sigObj);
+          break;
+        default:
+          rb_raise(rb_eArgError,"bad signal type %s",rb_class2name(CLASS_OF(sigObj)));
+          break;
+        }
+      self->addSignal(sig,tgt,sel,immediate,flags);
+      }
+SWIGINTERN void FXApp_removeSignal(FXApp *self,VALUE sigObj){
+      const char *s;
+      FXint sig;
+      switch(TYPE(sigObj)){
+        case T_STRING:
+          s=StringValuePtr(sigObj);
+          sig=FXRbSignalNameToNumber(s);
+          if(sig==0) rb_raise(rb_eArgError,"unrecognized signal name `%s'",s);
+          break;
+        case T_FIXNUM:
+          sig=(FXint)NUM2INT(sigObj);
+          break;
+        default:
+          rb_raise(rb_eArgError,"bad signal type %s",rb_class2name(CLASS_OF(sigObj)));
+          break;
+        }
+      self->removeSignal(sig);
+      }
+SWIGINTERN bool FXApp_addInput(FXApp *self,VALUE obj,FXuint mode,FXObject *tgt,FXSelector sel){
+      FXInputHandle fd;
+      if(mode&(INPUT_READ|INPUT_EXCEPT)){
+        fd=FXRbGetReadFileHandle(obj, mode);
+        self->addInput(fd,mode,tgt,sel);
+        }
+      if(mode&(INPUT_WRITE|INPUT_EXCEPT)){
+        fd=FXRbGetWriteFileHandle(obj, mode);
+        self->addInput(fd,mode,tgt,sel);
+        }
+      return true;
+      }
+SWIGINTERN bool FXApp_removeInput(FXApp *self,VALUE obj,FXuint mode){
+      FXInputHandle fd;
+      if(mode&(INPUT_READ|INPUT_EXCEPT)){
+        fd=FXRbGetReadFileHandle(obj, mode);
+        self->removeInput(fd,mode);
+        FXRbRemoveReadFileHandle(obj, mode);
+        }
+      if(mode&(INPUT_WRITE|INPUT_EXCEPT)){
+        fd=FXRbGetWriteFileHandle(obj, mode);
+        self->removeInput(fd,mode);
+        FXRbRemoveWriteFileHandle(obj, mode);
+        }
+      return true;
+      }
+SWIGINTERN void FXApp_setNormalFont(FXApp *self,FXFont *font){
+      FXASSERT(font);
+      if(font->isMemberOf(FXMETACLASS(FXRbFont))){
+        dynamic_cast<FXRbFont*>(font)->ownedByApp=1;
+	}
+      self->setNormalFont(font);
+      }
+SWIGINTERN void FXApp_setWaitCursor(FXApp *self,FXCursor *cur){
+      FXASSERT(cur);
+      if(cur->isMemberOf(FXMETACLASS(FXRbCursor))){
+        dynamic_cast<FXRbCursor*>(cur)->ownedByApp=1;
+        }
+      else if(cur->isMemberOf(FXMETACLASS(FXRbCURCursor))){
+        dynamic_cast<FXRbCURCursor*>(cur)->ownedByApp=1;
+        }
+      else if(cur->isMemberOf(FXMETACLASS(FXRbGIFCursor))){
+        dynamic_cast<FXRbGIFCursor*>(cur)->ownedByApp=1;
+        }
+      self->setWaitCursor(cur);
+      }
+SWIGINTERN void FXApp_setDefaultCursor(FXApp *self,FXDefaultCursor which,FXCursor *cur){
+      FXASSERT(cur);
+      if(cur->isMemberOf(FXMETACLASS(FXRbCursor))){
+        dynamic_cast<FXRbCursor*>(cur)->ownedByApp=1;
+        }
+      else if(cur->isMemberOf(FXMETACLASS(FXRbCURCursor))){
+        dynamic_cast<FXRbCURCursor*>(cur)->ownedByApp=1;
+        }
+      else if(cur->isMemberOf(FXMETACLASS(FXRbGIFCursor))){
+        dynamic_cast<FXRbGIFCursor*>(cur)->ownedByApp=1;
+        }
+      self->setDefaultCursor(which,cur);
+      }
+SWIGINTERN FXWindow *FXApp_readWindow(FXApp *self,FXStream &store,FXWindow *&window,FXWindow *father,FXWindow *owner){
+      window=0;
+      self->readWindow(store,window,father,owner);
+      return window;
+      }
+SWIGINTERN void FXApp_setThreadsEnabled(FXApp *self,FXbool enabled){
+    FXASSERT(self->isMemberOf(FXMETACLASS(FXRbApp)));
+    dynamic_cast<FXRbApp*>(self)->setThreadsEnabled(enabled);
+    }
+SWIGINTERN FXbool FXApp_threadsEnabled(FXApp const *self){
+    FXASSERT(self->isMemberOf(FXMETACLASS(FXRbApp)));
+    return dynamic_cast<const FXRbApp*>(self)->threadsEnabled();
+    }
+SWIGINTERN void FXApp_setSleepTime(FXApp *self,FXuint sleepTime){
+    FXASSERT(self->isMemberOf(FXMETACLASS(FXRbApp)));
+    dynamic_cast<FXRbApp*>(self)->setSleepTime(sleepTime);
+    }
+SWIGINTERN FXuint FXApp_getSleepTime(FXApp const *self){
+    FXASSERT(self->isMemberOf(FXMETACLASS(FXRbApp)));
+    return dynamic_cast<const FXRbApp*>(self)->getSleepTime();
+    }
+SWIGINTERN FXDataTarget *new_FXDataTarget(VALUE value=Qnil,FXObject *tgt=0,FXSelector sel=0){
+      return new FXRbDataTarget(value,tgt,sel);
+      }
+SWIGINTERN VALUE FXDataTarget_getValue(FXDataTarget const *self){
+      FXASSERT(self->isMemberOf(FXMETACLASS(FXRbDataTarget)));
+      return dynamic_cast<const FXRbDataTarget*>(self)->getValue();
+      }
+SWIGINTERN void FXDataTarget_setValue(FXDataTarget *self,VALUE value){
+      FXASSERT(self->isMemberOf(FXMETACLASS(FXRbDataTarget)));
+      dynamic_cast<FXRbDataTarget*>(self)->setValue(value);
+      }
+SWIGINTERN VALUE FXDebugTarget_messageTypeName(){
+          VALUE messageTypeNames = rb_ary_new();
+          for (int i = 0; i < SEL_LAST; i++) {
+              rb_ary_push(messageTypeNames,
+                  to_ruby(FXDebugTarget::messageTypeName[i]));
+          }
+          return messageTypeNames;
+      }
+SWIGINTERN FXDebugTarget *new_FXDebugTarget(){
+      return new FXRbDebugTarget();
+      }
+SWIGINTERN FXDelegator *new_FXDelegator(FXObject *target=0){
+      return new FXRbDelegator(target);
+      }
+SWIGINTERN FXTranslator *new_FXTranslator(FXApp *a){ return new FXRbTranslator(a); }
+SWIGINTERN FXDict *new_FXDict(){
+      return new FXRbDict();
+      }
+SWIGINTERN bool FXDict_has_key(FXDict const *self,FXchar const *ky){
+      return (self->find(ky) != 0);
+    }
+
+static swig_type_info *FXDict_dynamic_cast(void **ptr) {
+    FXDict **ppDict = reinterpret_cast<FXDict **>(ptr);
+    FXFileDict *pFileDict=dynamic_cast<FXFileDict*>(*ppDict);
+    if(pFileDict){
+      *ptr=reinterpret_cast<void*>(pFileDict);
+      return SWIG_TypeQuery("FXFileDict *");
+      }
+    FXIconDict *pIconDict=dynamic_cast<FXIconDict*>(*ppDict);
+    if(pIconDict){
+      *ptr=reinterpret_cast<void*>(pIconDict);
+      return SWIG_TypeQuery("FXIconDict *");
+      }
+    FXSettings *pSettings=dynamic_cast<FXSettings*>(*ppDict);
+    if(pSettings){
+      *ptr=reinterpret_cast<void*>(pSettings);
+      return SWIG_TypeQuery("FXSettings *");
+      }
+    FXStringDict *pStringDict=dynamic_cast<FXStringDict*>(*ppDict);
+    if(pStringDict){
+      *ptr=reinterpret_cast<void*>(pStringDict);
+      return SWIG_TypeQuery("FXStringDict *");
+      }
+    return 0;
+}
+
+SWIGINTERN VALUE FXFileDict_defaultExecBinding(){
+      return to_ruby(FXFileDict::defaultExecBinding);
+      }
+SWIGINTERN VALUE FXFileDict_defaultDirBinding(){
+      return to_ruby(FXFileDict::defaultDirBinding);
+      }
+SWIGINTERN VALUE FXFileDict_defaultFileBinding(){
+      return to_ruby(FXFileDict::defaultFileBinding);
+      }
+SWIGINTERN FXFileDict *new_FXFileDict__SWIG_0(FXApp *a){
+      return new FXRbFileDict(a);
+      }
+SWIGINTERN FXFileDict *new_FXFileDict__SWIG_1(FXApp *a,FXSettings *db){
+      return new FXRbFileDict(a,db);
+      }
+SWIGINTERN VALUE FXIconDict_defaultIconPath(){
+      return to_ruby(FXIconDict::defaultIconPath);
+      }
+SWIGINTERN FXIconDict *new_FXIconDict(FXApp *app,FXString const &p=FXIconDict::defaultIconPath){
+      return new FXRbIconDict(app,p);
+      }
+SWIGINTERN FXStringDict *new_FXStringDict(){
+      return new FXRbStringDict();
+      }
+SWIGINTERN FXSettings *new_FXSettings(){
+      return new FXRbSettings();
+      }
+
+  #define SWIG_From_double   rb_float_new 
+
+
+static swig_type_info *FXSettings_dynamic_cast(void **ptr) {
+    FXSettings **ppSettings = reinterpret_cast<FXSettings **>(ptr);
+    FXRegistry *pRegistry=dynamic_cast<FXRegistry*>(*ppSettings);
+    if(pRegistry){
+      *ptr=reinterpret_cast<void*>(pRegistry);
+      return SWIG_TypeQuery("FXRegistry *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXRegistry *new_FXRegistry(FXString const &akey=FXString::null,FXString const &vkey=FXString::null){
+      return new FXRbRegistry(akey,vkey);
+      }
+SWIGINTERN FXDocument *new_FXDocument(){
+      return new FXRbDocument();
+      }
+SWIGINTERN FXRecentFiles *new_FXRecentFiles__SWIG_0(){ return new FXRbRecentFiles(); }
+SWIGINTERN FXRecentFiles *new_FXRecentFiles__SWIG_1(FXApp *a){ return new FXRbRecentFiles(a); }
+SWIGINTERN FXRecentFiles *new_FXRecentFiles__SWIG_2(FXApp *a,FXString const &gp,FXObject *tgt=0,FXSelector sel=0){
+      return new FXRbRecentFiles(a,gp,tgt,sel);
+      }
+SWIGINTERN bool FXId_created(FXId const *self){
+      return self->id() != 0;
+      }
+SWIGINTERN void FXId_setUserData(FXId *self,VALUE ptr){
+      self->setUserData(reinterpret_cast<void*>(ptr));
+      }
+SWIGINTERN VALUE FXId_getUserData(FXId const *self){
+      return self->getUserData() ? reinterpret_cast<VALUE>(self->getUserData()) : Qnil;
+      }
+
+static swig_type_info *FXId_dynamic_cast(void **ptr) {
+    FXId **ppId = reinterpret_cast<FXId **>(ptr);
+    FXCursor *pCursor=dynamic_cast<FXCursor*>(*ppId);
+    if(pCursor){
+      *ptr=reinterpret_cast<void*>(pCursor);
+      return SWIG_TypeQuery("FXCursor *");
+      }
+    FXDrawable *pDrawable=dynamic_cast<FXDrawable*>(*ppId);
+    if(pDrawable){
+      *ptr=reinterpret_cast<void*>(pDrawable);
+      return SWIG_TypeQuery("FXDrawable *");
+      }
+    FXFont *pFont=dynamic_cast<FXFont*>(*ppId);
+    if(pFont){
+      *ptr=reinterpret_cast<void*>(pFont);
+      return SWIG_TypeQuery("FXFont *");
+      }
+    FXGLContext *pGLContext=dynamic_cast<FXGLContext*>(*ppId);
+    if(pGLContext){
+      *ptr=reinterpret_cast<void*>(pGLContext);
+      return SWIG_TypeQuery("FXGLContext *");
+      }
+    FXVisual *pVisual=dynamic_cast<FXVisual*>(*ppId);
+    if(pVisual){
+      *ptr=reinterpret_cast<void*>(pVisual);
+      return SWIG_TypeQuery("FXVisual *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXCursor *new_FXCursor__SWIG_0(FXApp *a,FXStockCursor curid=CURSOR_ARROW){
+      return new FXRbCursor(a,curid);
+      }
+SWIGINTERN FXCursor *new_FXCursor__SWIG_1(FXApp *a,FXuchar const *src,FXuchar const *msk,FXint w=32,FXint h=32,FXint hx=0,FXint hy=0){
+      return new FXRbCursor(a,src,msk,w,h,hx,hy);
+      }
+SWIGINTERN FXCursor *new_FXCursor__SWIG_2(FXApp *a,FXColor const *pix,FXint w=32,FXint h=32,FXint hx=0,FXint hy=0){
+      return new FXRbCursor(a,pix,w,h,hx,hy);
+      }
+
+static swig_type_info *FXCursor_dynamic_cast(void **ptr) {
+    FXCursor **ppCursor = reinterpret_cast<FXCursor **>(ptr);
+    FXCURCursor *pCURCursor=dynamic_cast<FXCURCursor*>(*ppCursor);
+    if(pCURCursor){
+      *ptr=reinterpret_cast<void*>(pCURCursor);
+      return SWIG_TypeQuery("FXCURCursor *");
+      }
+    FXGIFCursor *pGIFCursor=dynamic_cast<FXGIFCursor*>(*ppCursor);
+    if(pGIFCursor){
+      *ptr=reinterpret_cast<void*>(pGIFCursor);
+      return SWIG_TypeQuery("FXGIFCursor *");
+      }
+    return 0;
+}
+
+SWIGINTERN VALUE FXCURCursor_fileExt(){
+      return to_ruby(FXCURCursor::fileExt);
+      }
+SWIGINTERN FXCURCursor *new_FXCURCursor(FXApp *a,void const *pix){
+      return new FXRbCURCursor(a,pix);
+      }
+SWIGINTERN VALUE FXGIFCursor_fileExt(){
+      return to_ruby(FXGIFCursor::fileExt);
+      }
+SWIGINTERN FXGIFCursor *new_FXGIFCursor(FXApp *a,void const *pix,FXint hx=-1,FXint hy=-1){
+      return new FXRbGIFCursor(a,pix,hx,hy);
+      }
+
+  /**
+   * Load an GIF (Graphics Interchange Format) file from a stream.
+   * Upon successful return, the pixel array and size are returned.
+   * If an error occurred, the pixel array is set to NULL.
+   */
+  VALUE fxloadGIF(FXStream& store){
+    FXColor* data;
+    FXint width;
+    FXint height;
+    if(fxloadGIF(store,data,width,height)){
+      VALUE ary=rb_ary_new();
+      rb_ary_push(ary,FXRbMakeColorArray(data,width,height));
+      FXFREE(&data);
+      rb_ary_push(ary,to_ruby(width));
+      rb_ary_push(ary,to_ruby(height));
+      return ary;
+      }
+    else{
+      return Qnil;
+      }
+    }
+
+SWIGINTERN FXDrawable *new_FXDrawable(FXApp *a,FXint w,FXint h){
+      return new FXRbDrawable(a,w,h);
+      }
+
+static swig_type_info *FXDrawable_dynamic_cast(void **ptr) {
+    FXDrawable **ppDrawable = reinterpret_cast<FXDrawable **>(ptr);
+    FXBitmap *pBitmap=dynamic_cast<FXBitmap*>(*ppDrawable);
+    if(pBitmap){
+      *ptr=reinterpret_cast<void*>(pBitmap);
+      return SWIG_TypeQuery("FXBitmap *");
+      }
+    FXImage *pImage=dynamic_cast<FXImage*>(*ppDrawable);
+    if(pImage){
+      *ptr=reinterpret_cast<void*>(pImage);
+      return SWIG_TypeQuery("FXImage *");
+      }
+    FXWindow *pWindow=dynamic_cast<FXWindow*>(*ppDrawable);
+    if(pWindow){
+      *ptr=reinterpret_cast<void*>(pWindow);
+      return SWIG_TypeQuery("FXWindow *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXVisual *new_FXVisual(FXApp *a,FXuint flgs,FXuint d=32){
+      return new FXRbVisual(a,flgs,d);
+      }
+
+static swig_type_info *FXVisual_dynamic_cast(void **ptr) {
+    FXVisual **ppVisual = reinterpret_cast<FXVisual **>(ptr);
+    FXGLVisual *pGLVisual=dynamic_cast<FXGLVisual*>(*ppVisual);
+    if(pGLVisual){
+      *ptr=reinterpret_cast<void*>(pGLVisual);
+      return SWIG_TypeQuery("FXGLVisual *");
+      }
+    return 0;
+}
+
+
+SWIGINTERN int
+SWIG_AsCharArray(VALUE obj, char *val, size_t size)
+{ 
+  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
+  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
+  if (SWIG_IsOK(res)) {
+    /* special case of single char conversion when we don't need space for NUL */
+    if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
+    if (csize <= size) {
+      if (val) {
+	if (csize) memcpy(val, cptr, csize*sizeof(char));
+	if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
+      }
+      if (alloc == SWIG_NEWOBJ) {
+	delete[] cptr;
+	res = SWIG_DelNewMask(res);
+      }      
+      return res;
+    }
+    if (alloc == SWIG_NEWOBJ) delete[] cptr;
+  }
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERN size_t
+SWIG_strnlen(const char* s, size_t maxlen)
+{
+  const char *p;
+  for (p = s; maxlen-- && *p; p++)
+    ;
+  return p - s;
+}
+
+SWIGINTERN FXFont *new_FXFont__SWIG_0(FXApp *a,FXString const &string){
+      return new FXRbFont(a,string);
+      }
+SWIGINTERN FXFont *new_FXFont__SWIG_1(FXApp *a,FXString const &face,FXuint sz,FXuint wt=FXFont::Normal,FXuint slant=FXFont::Straight,FXuint encoding=FONTENCODING_DEFAULT,FXuint setwidth=FXFont::NonExpanded,FXuint h=0){
+      return new FXRbFont(a,face,sz,wt,slant,encoding,setwidth,h);
+      }
+SWIGINTERN FXFont *new_FXFont__SWIG_2(FXApp *a,FXFontDesc const &fontdesc){
+      return new FXRbFont(a,fontdesc);
+      }
+SWIGINTERN FXFontDesc FXFont_getFontDesc(FXFont const *self){
+      FXFontDesc fontdesc;
+      self->getFontDesc(fontdesc);
+      return fontdesc;
+    }
+SWIGINTERN VALUE FXFont_listFonts(FXString const &face,FXuint wt=0,FXuint sl=0,FXuint sw=0,FXuint en=0,FXuint h=0){
+      FXFontDesc* fonts;
+      FXuint numfonts;
+      VALUE results = rb_ary_new();
+      if (FXFont::listFonts(fonts, numfonts, face, wt, sl, sw, en, h)) {
+        for (FXuint i = 0; i < numfonts; i++)
+          rb_ary_push(results, to_ruby(new FXFontDesc(fonts[i])));
+        FXFREE(&fonts);
+      }
+      return results;
+    }
+SWIGINTERN FXbool FXFont_hasChar(FXFont const *self,VALUE ch){
+      if(TYPE(ch)==T_STRING){
+        if(RSTRING_LEN(ch)==1){
+          return self->hasChar(*(StringValuePtr(ch))); // FIXME: hasChar() expects an FXwchar
+	  }
+	else{
+	  rb_raise(rb_eArgError,"expected a string of length one");
+	  }
+        }
+      else{
+        return self->hasChar(NUM2INT(ch)); // FIXME: hasChar() expects an FXwchar
+        }
+      }
+SWIGINTERN VALUE FXWindow_octetTypeName(){
+      return to_ruby(FXWindow::octetTypeName);
+    }
+SWIGINTERN VALUE FXWindow_deleteTypeName(){
+      return to_ruby(FXWindow::deleteTypeName);
+    }
+SWIGINTERN VALUE FXWindow_textTypeName(){
+      return to_ruby(FXWindow::textTypeName);
+    }
+SWIGINTERN VALUE FXWindow_colorTypeName(){
+      return to_ruby(FXWindow::colorTypeName);
+    }
+SWIGINTERN VALUE FXWindow_urilistTypeName(){
+      return to_ruby(FXWindow::urilistTypeName);
+    }
+SWIGINTERN VALUE FXWindow_utf8TypeName(){
+      return to_ruby(FXWindow::utf8TypeName);
+    }
+SWIGINTERN VALUE FXWindow_utf16TypeName(){
+      return to_ruby(FXWindow::utf16TypeName);
+    }
+SWIGINTERN FXWindow *new_FXWindow__SWIG_0(FXComposite *p,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbWindow(p,opts,x,y,w,h);
+      }
+SWIGINTERN FXWindow *new_FXWindow__SWIG_1(FXApp *a,FXVisual *vis){
+      return new FXRbWindow(a,vis);
+      }
+SWIGINTERN FXWindow *new_FXWindow__SWIG_2(FXApp *a,FXWindow *own,FXuint opts,FXint x,FXint y,FXint w,FXint h){
+      return new FXRbWindow(a,own,opts,x,y,w,h);
+      }
+SWIGINTERN FXbool FXWindow_removeChild(FXWindow *self,FXWindow *child){
+      if(self->containsChild(child)){
+        delete child;
+        return 1;
+        }
+      else{
+        return 0;
+        }
+      }
+SWIGINTERN bool FXWindow_before(FXWindow const *self,FXWindow const *other){ return FXWindow::before(self, other); }
+SWIGINTERN bool FXWindow_after(FXWindow const *self,FXWindow const *other){ return FXWindow::after(self, other); }
+SWIGINTERN VALUE FXWindow_getCursorPosition(FXWindow const *self){
+      FXint x, y;
+      FXuint buttons;
+      self->getCursorPosition(x, y, buttons);
+      VALUE arr = rb_ary_new();
+      rb_ary_push(arr, INT2NUM(x));
+      rb_ary_push(arr, INT2NUM(y));
+      rb_ary_push(arr, UINT2NUM(buttons));
+      return arr;
+    }
+SWIGINTERN bool FXWindow_acquireSelection(FXWindow *self,VALUE typesArray){
+      Check_Type(typesArray,T_ARRAY);
+      FXDragType *types=0;
+      FXuint numtypes=RARRAY_LEN(typesArray);
+      if(numtypes>0){
+        types=new FXDragType[numtypes];
+        for(FXuint i=0;i<numtypes;i++){
+          types[i]=(FXDragType) NUM2UINT(rb_ary_entry(typesArray,i));
+          }
+      }
+      bool result=self->acquireSelection(types,numtypes);
+      delete [] types;
+      return result;
+      }
+SWIGINTERN bool FXWindow_acquireClipboard(FXWindow *self,VALUE typesArray){
+      Check_Type(typesArray,T_ARRAY);
+      FXDragType *types=0;
+      FXuint numtypes=RARRAY_LEN(typesArray);
+      if(numtypes>0){
+        types=new FXDragType[numtypes];
+        for(FXuint i=0;i<numtypes;i++){
+          types[i]=(FXDragType) NUM2UINT(rb_ary_entry(typesArray,i));
+          }
+      }
+      bool result=self->acquireClipboard(types,numtypes);
+      delete [] types;
+      return result;
+      }
+SWIGINTERN bool FXWindow_beginDrag(FXWindow *self,VALUE typesArray){
+      Check_Type(typesArray,T_ARRAY);
+      FXDragType *types=0;
+      FXuint numtypes=RARRAY_LEN(typesArray);
+      if(numtypes>0){
+        types=new FXDragType[numtypes];
+        for(FXuint i=0;i<numtypes;i++){
+          types[i]=(FXDragType) NUM2UINT(rb_ary_entry(typesArray,i));
+          }
+      }
+      bool result=self->beginDrag(types,numtypes);
+      delete [] types;
+      return result;
+      }
+SWIGINTERN VALUE FXWindow_inquireDNDTypes(FXWindow const *self,FXDNDOrigin origin){
+      FXDragType* types;
+      FXuint numtypes;
+      VALUE arr = rb_ary_new();
+      if (self->inquireDNDTypes(origin, types, numtypes)) {
+        for (FXuint i = 0; i < numtypes; i++)
+          rb_ary_push(arr, to_ruby(types[i]));
+        FXFREE(&types);
+      }
+      return arr;
+    }
+SWIGINTERN void FXWindow_setDNDData(FXWindow const *self,FXDNDOrigin origin,FXDragType type,VALUE str){
+      Check_Type(str, T_STRING);
+      FXuchar* data;
+      FXuint size = RSTRING_LEN(str);
+      if (FXMALLOC(&data, FXuchar, size)) {
+        memcpy((void *) data, (void *) RSTRING_PTR(str), size);
+        self->setDNDData(origin, type, data, size);
+      } else {
+        rb_raise(rb_eNoMemError, "couldn't copy drag-and-drop data");
+      }
+    }
+SWIGINTERN VALUE FXWindow_getDNDData(FXWindow const *self,FXDNDOrigin origin,FXDragType type){
+      FXuchar* data;
+      FXuint size;
+      VALUE result = Qnil;
+      if (self->getDNDData(origin, type, data, size)) {
+        result = rb_str_new((const FXchar *) data, size);
+        FXFREE(&data);
+      }
+      return result;
+    }
+SWIGINTERN VALUE FXWindow_translateCoordinatesFrom(FXWindow const *self,FXWindow const *fromwindow,FXint fromx,FXint fromy){
+      FXint tox, toy;
+      self->translateCoordinatesFrom(tox, toy, fromwindow, fromx, fromy);
+      VALUE result = rb_ary_new();
+      rb_ary_push(result, INT2NUM(tox));
+      rb_ary_push(result, INT2NUM(toy));
+      return result;
+    }
+SWIGINTERN VALUE FXWindow_translateCoordinatesTo(FXWindow const *self,FXWindow const *towindow,FXint fromx,FXint fromy){
+      FXint tox, toy;
+      self->translateCoordinatesTo(tox, toy, towindow, fromx, fromy);
+      VALUE result = rb_ary_new();
+      rb_ary_push(result, INT2NUM(tox));
+      rb_ary_push(result, INT2NUM(toy));
+      return result;
+    }
+
+static swig_type_info *FXWindow_dynamic_cast(void **ptr) {
+    FXWindow **ppWindow = reinterpret_cast<FXWindow **>(ptr);
+    FXCanvas *pCanvas=dynamic_cast<FXCanvas*>(*ppWindow);
+    if(pCanvas){
+      *ptr=reinterpret_cast<void*>(pCanvas);
+      return SWIG_TypeQuery("FXCanvas *");
+      }
+    FXComposite *pComposite=dynamic_cast<FXComposite*>(*ppWindow);
+    if(pComposite){
+      *ptr=reinterpret_cast<void*>(pComposite);
+      return SWIG_TypeQuery("FXComposite *");
+      }
+    FXDragCorner *pDragCorner=dynamic_cast<FXDragCorner*>(*ppWindow);
+    if(pDragCorner){
+      *ptr=reinterpret_cast<void*>(pDragCorner);
+      return SWIG_TypeQuery("FXDragCorner *");
+      }
+    FXFrame *pFrame=dynamic_cast<FXFrame*>(*ppWindow);
+    if(pFrame){
+      *ptr=reinterpret_cast<void*>(pFrame);
+      return SWIG_TypeQuery("FXFrame *");
+      }
+    FXMenuCaption *pMenuCaption=dynamic_cast<FXMenuCaption*>(*ppWindow);
+    if(pMenuCaption){
+      *ptr=reinterpret_cast<void*>(pMenuCaption);
+      return SWIG_TypeQuery("FXMenuCaption *");
+      }
+    FXMenuSeparator *pMenuSeparator=dynamic_cast<FXMenuSeparator*>(*ppWindow);
+    if(pMenuSeparator){
+      *ptr=reinterpret_cast<void*>(pMenuSeparator);
+      return SWIG_TypeQuery("FXMenuSeparator *");
+      }
+    FXScrollBar *pScrollBar=dynamic_cast<FXScrollBar*>(*ppWindow);
+    if(pScrollBar){
+      *ptr=reinterpret_cast<void*>(pScrollBar);
+      return SWIG_TypeQuery("FXScrollBar *");
+      }
+    FXScrollCorner *pScrollCorner=dynamic_cast<FXScrollCorner*>(*ppWindow);
+    if(pScrollCorner){
+      *ptr=reinterpret_cast<void*>(pScrollCorner);
+      return SWIG_TypeQuery("FXScrollCorner *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXFrame *new_FXFrame(FXComposite *p,FXuint opts=FRAME_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbFrame(p,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+
+static swig_type_info *FXFrame_dynamic_cast(void **ptr) {
+    FXFrame **ppFrame = reinterpret_cast<FXFrame **>(ptr);
+    FX7Segment *p7Segment=dynamic_cast<FX7Segment*>(*ppFrame);
+    if(p7Segment){
+      *ptr=reinterpret_cast<void*>(p7Segment);
+      return SWIG_TypeQuery("FX7Segment *");
+      }
+    FXArrowButton *pArrowButton=dynamic_cast<FXArrowButton*>(*ppFrame);
+    if(pArrowButton){
+      *ptr=reinterpret_cast<void*>(pArrowButton);
+      return SWIG_TypeQuery("FXArrowButton *");
+      }
+    FXBitmapFrame *pBitmapFrame=dynamic_cast<FXBitmapFrame*>(*ppFrame);
+    if(pBitmapFrame){
+      *ptr=reinterpret_cast<void*>(pBitmapFrame);
+      return SWIG_TypeQuery("FXBitmapFrame *");
+      }
+    FXColorBar *pColorBar=dynamic_cast<FXColorBar*>(*ppFrame);
+    if(pColorBar){
+      *ptr=reinterpret_cast<void*>(pColorBar);
+      return SWIG_TypeQuery("FXColorBar *");
+      }
+    FXColorRing *pColorRing=dynamic_cast<FXColorRing*>(*ppFrame);
+    if(pColorRing){
+      *ptr=reinterpret_cast<void*>(pColorRing);
+      return SWIG_TypeQuery("FXColorRing *");
+      }
+    FXColorWell *pColorWell=dynamic_cast<FXColorWell*>(*ppFrame);
+    if(pColorWell){
+      *ptr=reinterpret_cast<void*>(pColorWell);
+      return SWIG_TypeQuery("FXColorWell *");
+      }
+    FXColorWheel *pColorWheel=dynamic_cast<FXColorWheel*>(*ppFrame);
+    if(pColorWheel){
+      *ptr=reinterpret_cast<void*>(pColorWheel);
+      return SWIG_TypeQuery("FXColorWheel *");
+      }
+    FXDial *pDial=dynamic_cast<FXDial*>(*ppFrame);
+    if(pDial){
+      *ptr=reinterpret_cast<void*>(pDial);
+      return SWIG_TypeQuery("FXDial *");
+      }
+    FXDockHandler *pDockHandler=dynamic_cast<FXDockHandler*>(*ppFrame);
+    if(pDockHandler){
+      *ptr=reinterpret_cast<void*>(pDockHandler);
+      return SWIG_TypeQuery("FXDockHandler *");
+      }
+    FXHeader *pHeader=dynamic_cast<FXHeader*>(*ppFrame);
+    if(pHeader){
+      *ptr=reinterpret_cast<void*>(pHeader);
+      return SWIG_TypeQuery("FXHeader *");
+      }
+    FXImageFrame *pImageFrame=dynamic_cast<FXImageFrame*>(*ppFrame);
+    if(pImageFrame){
+      *ptr=reinterpret_cast<void*>(pImageFrame);
+      return SWIG_TypeQuery("FXImageFrame *");
+      }
+    FXKnob *pKnob=dynamic_cast<FXKnob*>(*ppFrame);
+    if(pKnob){
+      *ptr=reinterpret_cast<void*>(pKnob);
+      return SWIG_TypeQuery("FXKnob *");
+      }
+    FXLabel *pLabel=dynamic_cast<FXLabel*>(*ppFrame);
+    if(pLabel){
+      *ptr=reinterpret_cast<void*>(pLabel);
+      return SWIG_TypeQuery("FXLabel *");
+      }
+    FXProgressBar *pProgressBar=dynamic_cast<FXProgressBar*>(*ppFrame);
+    if(pProgressBar){
+      *ptr=reinterpret_cast<void*>(pProgressBar);
+      return SWIG_TypeQuery("FXProgressBar *");
+      }
+    FXRealSlider *pRealSlider=dynamic_cast<FXRealSlider*>(*ppFrame);
+    if(pRealSlider){
+      *ptr=reinterpret_cast<void*>(pRealSlider);
+      return SWIG_TypeQuery("FXRealSlider *");
+      }
+    FXSeparator *pSeparator=dynamic_cast<FXSeparator*>(*ppFrame);
+    if(pSeparator){
+      *ptr=reinterpret_cast<void*>(pSeparator);
+      return SWIG_TypeQuery("FXSeparator *");
+      }
+    FXSlider *pSlider=dynamic_cast<FXSlider*>(*ppFrame);
+    if(pSlider){
+      *ptr=reinterpret_cast<void*>(pSlider);
+      return SWIG_TypeQuery("FXSlider *");
+      }
+    FXStatusLine *pStatusLine=dynamic_cast<FXStatusLine*>(*ppFrame);
+    if(pStatusLine){
+      *ptr=reinterpret_cast<void*>(pStatusLine);
+      return SWIG_TypeQuery("FXStatusLine *");
+      }
+    FXTextField *pTextField=dynamic_cast<FXTextField*>(*ppFrame);
+    if(pTextField){
+      *ptr=reinterpret_cast<void*>(pTextField);
+      return SWIG_TypeQuery("FXTextField *");
+      }
+    FXToolBarTab *pToolBarTab=dynamic_cast<FXToolBarTab*>(*ppFrame);
+    if(pToolBarTab){
+      *ptr=reinterpret_cast<void*>(pToolBarTab);
+      return SWIG_TypeQuery("FXToolBarTab *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXComposite *new_FXComposite(FXComposite *p,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbComposite(p,opts,x,y,w,h);
+      }
+
+static swig_type_info *FXComposite_dynamic_cast(void **ptr) {
+    FXComposite **ppComposite = reinterpret_cast<FXComposite **>(ptr);
+    FX4Splitter *p4Splitter=dynamic_cast<FX4Splitter*>(*ppComposite);
+    if(p4Splitter){
+      *ptr=reinterpret_cast<void*>(p4Splitter);
+      return SWIG_TypeQuery("FX4Splitter *");
+      }
+    FXMDIChild *pMDIChild=dynamic_cast<FXMDIChild*>(*ppComposite);
+    if(pMDIChild){
+      *ptr=reinterpret_cast<void*>(pMDIChild);
+      return SWIG_TypeQuery("FXMDIChild *");
+      }
+    FXPacker *pPacker=dynamic_cast<FXPacker*>(*ppComposite);
+    if(pPacker){
+      *ptr=reinterpret_cast<void*>(pPacker);
+      return SWIG_TypeQuery("FXPacker *");
+      }
+    FXRootWindow *pRootWindow=dynamic_cast<FXRootWindow*>(*ppComposite);
+    if(pRootWindow){
+      *ptr=reinterpret_cast<void*>(pRootWindow);
+      return SWIG_TypeQuery("FXRootWindow *");
+      }
+    FXScrollArea *pScrollArea=dynamic_cast<FXScrollArea*>(*ppComposite);
+    if(pScrollArea){
+      *ptr=reinterpret_cast<void*>(pScrollArea);
+      return SWIG_TypeQuery("FXScrollArea *");
+      }
+    FXShell *pShell=dynamic_cast<FXShell*>(*ppComposite);
+    if(pShell){
+      *ptr=reinterpret_cast<void*>(pShell);
+      return SWIG_TypeQuery("FXShell *");
+      }
+    FXSplitter *pSplitter=dynamic_cast<FXSplitter*>(*ppComposite);
+    if(pSplitter){
+      *ptr=reinterpret_cast<void*>(pSplitter);
+      return SWIG_TypeQuery("FXSplitter *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXRootWindow *new_FXRootWindow(FXApp *a,FXVisual *vis){
+      return new FXRbRootWindow(a,vis);
+      }
+SWIGINTERN FXShell *new_FXShell__SWIG_0(FXApp *a,FXuint opts,FXint x,FXint y,FXint w,FXint h){
+      return new FXRbShell(a,opts,x,y,w,h);
+      }
+SWIGINTERN FXShell *new_FXShell__SWIG_1(FXWindow *own,FXuint opts,FXint x,FXint y,FXint w,FXint h){
+      return new FXRbShell(own,opts,x,y,w,h);
+      }
+
+static swig_type_info *FXShell_dynamic_cast(void **ptr) {
+    FXShell **ppShell = reinterpret_cast<FXShell **>(ptr);
+    FXPopup *pPopup=dynamic_cast<FXPopup*>(*ppShell);
+    if(pPopup){
+      *ptr=reinterpret_cast<void*>(pPopup);
+      return SWIG_TypeQuery("FXPopup *");
+      }
+    FXToolTip *pToolTip=dynamic_cast<FXToolTip*>(*ppShell);
+    if(pToolTip){
+      *ptr=reinterpret_cast<void*>(pToolTip);
+      return SWIG_TypeQuery("FXToolTip *");
+      }
+    FXTopWindow *pTopWindow=dynamic_cast<FXTopWindow*>(*ppShell);
+    if(pTopWindow){
+      *ptr=reinterpret_cast<void*>(pTopWindow);
+      return SWIG_TypeQuery("FXTopWindow *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXPopup *new_FXPopup(FXWindow *owner,FXuint opts=POPUP_VERTICAL|FRAME_RAISED|FRAME_THICK,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbPopup(owner,opts,x,y,w,h);
+      }
+
+static swig_type_info *FXPopup_dynamic_cast(void **ptr) {
+    FXPopup **ppPopup = reinterpret_cast<FXPopup **>(ptr);
+    FXMenuPane *pMenuPane=dynamic_cast<FXMenuPane*>(*ppPopup);
+    if(pMenuPane){
+      *ptr=reinterpret_cast<void*>(pMenuPane);
+      return SWIG_TypeQuery("FXMenuPane *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXTopWindow *new_FXTopWindow__SWIG_0(FXApp *a,FXString const &name,FXIcon *ic,FXIcon *mi,FXuint opts,FXint x,FXint y,FXint w,FXint h,FXint pl,FXint pr,FXint pt,FXint pb,FXint hs,FXint vs){
+      return new FXRbTopWindow(a,name,ic,mi,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+SWIGINTERN FXTopWindow *new_FXTopWindow__SWIG_1(FXWindow *owner,FXString const &name,FXIcon *ic,FXIcon *mi,FXuint opts,FXint x,FXint y,FXint w,FXint h,FXint pl,FXint pr,FXint pt,FXint pb,FXint hs,FXint vs){
+      return new FXRbTopWindow(owner,name,ic,mi,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+SWIGINTERN VALUE FXTopWindow_getWMBorders(FXTopWindow *self){
+      FXint left,right,top,bottom;
+      if(self->getWMBorders(left,right,top,bottom)){
+        return rb_ary_new3(4,INT2NUM(left),INT2NUM(right),INT2NUM(top),INT2NUM(bottom));
+        }
+      else{
+        return Qnil; // FIXME
+	}
+      }
+
+static swig_type_info *FXTopWindow_dynamic_cast(void **ptr) {
+    FXTopWindow **ppTopWindow = reinterpret_cast<FXTopWindow **>(ptr);
+    FXDialogBox *pDialogBox=dynamic_cast<FXDialogBox*>(*ppTopWindow);
+    if(pDialogBox){
+      *ptr=reinterpret_cast<void*>(pDialogBox);
+      return SWIG_TypeQuery("FXDialogBox *");
+      }
+    FXMainWindow *pMainWindow=dynamic_cast<FXMainWindow*>(*ppTopWindow);
+    if(pMainWindow){
+      *ptr=reinterpret_cast<void*>(pMainWindow);
+      return SWIG_TypeQuery("FXMainWindow *");
+      }
+    FXSplashWindow *pSplashWindow=dynamic_cast<FXSplashWindow*>(*ppTopWindow);
+    if(pSplashWindow){
+      *ptr=reinterpret_cast<void*>(pSplashWindow);
+      return SWIG_TypeQuery("FXSplashWindow *");
+      }
+    FXToolBarShell *pToolBarShell=dynamic_cast<FXToolBarShell*>(*ppTopWindow);
+    if(pToolBarShell){
+      *ptr=reinterpret_cast<void*>(pToolBarShell);
+      return SWIG_TypeQuery("FXToolBarShell *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXMainWindow *new_FXMainWindow(FXApp *APP,FXString const &name,FXIcon *ic=0,FXIcon *mi=0,FXuint opts=DECOR_ALL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=0,FXint pr=0,FXint pt=0,FXint pb=0,FXint hs=0,FXint vs=0){
+      return new FXRbMainWindow(APP,name,ic,mi,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+SWIGINTERN FXSplashWindow *new_FXSplashWindow__SWIG_0(FXApp *a,FXIcon *ic,FXuint opts=SPLASH_SIMPLE,FXuint ms=5000){
+      /* Icon will be free`d by Rubys GC. */
+      opts &= ~SPLASH_OWNS_ICON;
+      return new FXRbSplashWindow(a,ic,opts,ms);
+      }
+SWIGINTERN FXSplashWindow *new_FXSplashWindow__SWIG_1(FXWindow *own,FXIcon *ic,FXuint opts=SPLASH_SIMPLE,FXuint ms=5000){
+      /* Icon will be free`d by Rubys GC. */
+      opts &= ~SPLASH_OWNS_ICON;
+      return new FXRbSplashWindow(own,ic,opts,ms);
+      }
+SWIGINTERN VALUE
+_wrap_setIgnoreExceptions(int argc, VALUE *argv, VALUE self) {
+  VALUE arg1 = (VALUE) 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  arg1 = argv[0];
+  setIgnoreExceptions(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_MKUINT(int argc, VALUE *argv, VALUE self) {
+  FXushort arg1 ;
+  FXushort arg2 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  arg1 = NUM2UINT(argv[0]);
+  arg2 = NUM2UINT(argv[1]);
+  result = (FXuint)_MKUINT(arg1,arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSEL(int argc, VALUE *argv, VALUE self) {
+  FXushort arg1 ;
+  FXushort arg2 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  arg1 = NUM2UINT(argv[0]);
+  arg2 = NUM2UINT(argv[1]);
+  result = (FXuint)_FXSEL(arg1,arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSELTYPE(int argc, VALUE *argv, VALUE self) {
+  FXuint arg1 ;
+  FXushort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  arg1 = NUM2UINT(argv[0]);
+  result = (FXushort)_FXSELTYPE(arg1);
+  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSELID(int argc, VALUE *argv, VALUE self) {
+  FXuint arg1 ;
+  FXushort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  arg1 = NUM2UINT(argv[0]);
+  result = (FXushort)_FXSELID(arg1);
+  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGB(int argc, VALUE *argv, VALUE self) {
+  FXuchar arg1 ;
+  FXuchar arg2 ;
+  FXuchar arg3 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  arg1 = NUM2UINT(argv[0]);
+  arg2 = NUM2UINT(argv[1]);
+  arg3 = NUM2UINT(argv[2]);
+  result = (FXuint)_FXRGB(arg1,arg2,arg3);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBA(int argc, VALUE *argv, VALUE self) {
+  FXuchar arg1 ;
+  FXuchar arg2 ;
+  FXuchar arg3 ;
+  FXuchar arg4 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  arg1 = NUM2UINT(argv[0]);
+  arg2 = NUM2UINT(argv[1]);
+  arg3 = NUM2UINT(argv[2]);
+  arg4 = NUM2UINT(argv[3]);
+  result = (FXuint)_FXRGBA(arg1,arg2,arg3,arg4);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXREDVAL(int argc, VALUE *argv, VALUE self) {
+  FXuint arg1 ;
+  FXuchar result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  arg1 = NUM2UINT(argv[0]);
+  result = (FXuchar)_FXREDVAL(arg1);
+  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGREENVAL(int argc, VALUE *argv, VALUE self) {
+  FXuint arg1 ;
+  FXuchar result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  arg1 = NUM2UINT(argv[0]);
+  result = (FXuchar)_FXGREENVAL(arg1);
+  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBLUEVAL(int argc, VALUE *argv, VALUE self) {
+  FXuint arg1 ;
+  FXuchar result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  arg1 = NUM2UINT(argv[0]);
+  result = (FXuchar)_FXBLUEVAL(arg1);
+  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXALPHAVAL(int argc, VALUE *argv, VALUE self) {
+  FXuint arg1 ;
+  FXuchar result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  arg1 = NUM2UINT(argv[0]);
+  result = (FXuchar)_FXALPHAVAL(arg1);
+  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBACOMPVAL(int argc, VALUE *argv, VALUE self) {
+  FXuint arg1 ;
+  FXuchar arg2 ;
+  FXuchar result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  arg1 = NUM2UINT(argv[0]);
+  arg2 = NUM2UINT(argv[1]);
+  result = (FXuchar)_FXRGBACOMPVAL(arg1,arg2);
+  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxsleep(int argc, VALUE *argv, VALUE self) {
+  unsigned int arg1 ;
+  unsigned int val1 ;
+  int ecode1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned int","fxsleep", 1, argv[0] ));
+  } 
+  arg1 = static_cast< unsigned int >(val1);
+  fxsleep(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxfilematch(int argc, VALUE *argv, VALUE self) {
+  char *arg1 = (char *) 0 ;
+  char *arg2 = (char *) 0 ;
+  FXuint arg3 = (FXuint) (FILEMATCH_NOESCAPE|FILEMATCH_FILE_NAME) ;
+  int res1 ;
+  char *buf1 = 0 ;
+  int alloc1 = 0 ;
+  int res2 ;
+  char *buf2 = 0 ;
+  int alloc2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","fxfilematch", 1, argv[0] ));
+  }
+  arg1 = reinterpret_cast< char * >(buf1);
+  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","fxfilematch", 2, argv[1] ));
+  }
+  arg2 = reinterpret_cast< char * >(buf2);
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  result = (FXint)fxfilematch((char const *)arg1,(char const *)arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return vresult;
+fail:
+  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_makeHiliteColor(int argc, VALUE *argv, VALUE self) {
+  FXColor arg1 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  arg1 = to_FXColor(argv[0]);
+  result = (FXColor)makeHiliteColor(arg1);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_makeShadowColor(int argc, VALUE *argv, VALUE self) {
+  FXColor arg1 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  arg1 = to_FXColor(argv[0]);
+  result = (FXColor)makeShadowColor(arg1);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxcolorfromname(int argc, VALUE *argv, VALUE self) {
+  FXchar *arg1 = (FXchar *) 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  arg1 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  result = (FXColor)fxcolorfromname((char const *)arg1);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxnamefromcolor(int argc, VALUE *argv, VALUE self) {
+  FXColor arg1 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  arg1 = to_FXColor(argv[0]);
+  result = (FXchar *)fxnamefromcolor(arg1);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxrgb_to_hsv(int argc, VALUE *argv, VALUE self) {
+  FXfloat arg1 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_float(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXfloat","fxrgb_to_hsv", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXfloat >(val1);
+  ecode2 = SWIG_AsVal_float(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","fxrgb_to_hsv", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","fxrgb_to_hsv", 3, argv[2] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  result = (VALUE)fxrgb_to_hsv(arg1,arg2,arg3);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxhsv_to_rgb(int argc, VALUE *argv, VALUE self) {
+  FXfloat arg1 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_float(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXfloat","fxhsv_to_rgb", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXfloat >(val1);
+  ecode2 = SWIG_AsVal_float(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","fxhsv_to_rgb", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","fxhsv_to_rgb", 3, argv[2] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  result = (VALUE)fxhsv_to_rgb(arg1,arg2,arg3);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxisconsole(int argc, VALUE *argv, VALUE self) {
+  FXchar *arg1 = (FXchar *) 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  arg1 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  result = (FXbool)fxisconsole((char const *)arg1);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxversion(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)_fxversion();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxTraceLevel_get(VALUE self) {
+  VALUE _val;
+  
+  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(fxTraceLevel));
+  return _val;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxTraceLevel_set(VALUE self, VALUE _val) {
+  {
+    unsigned int val;
+    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""fxTraceLevel""' of type '""unsigned int""'");
+    }
+    fxTraceLevel = static_cast< unsigned int >(val);
+  }
+  return _val;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXStream;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXStream_allocate(VALUE self)
+#else
+_wrap_FXStream_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXStream);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXStream(int argc, VALUE *argv, VALUE self) {
+  FXObject *arg1 = (FXObject *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXStream *result = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  if (argc > 0) {
+    res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXObject const *","FXStream", 1, argv[0] )); 
+    }
+    arg1 = reinterpret_cast< FXObject * >(argp1);
+  }
+  {
+    result = (FXStream *)new_FXStream((FXObject const *)arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStream_open(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = (FXStream *) 0 ;
+  FXStreamDirection arg2 ;
+  FXuval arg3 = (FXuval) 8192 ;
+  FXuchar *arg4 = (FXuchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  unsigned long val3 ;
+  int ecode3 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream *","open", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXStreamDirection","open", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXStreamDirection >(val2);
+  if (argc > 1) {
+    ecode3 = SWIG_AsVal_unsigned_SS_long(argv[1], &val3);
+    if (!SWIG_IsOK(ecode3)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXuval","open", 3, argv[1] ));
+    } 
+    arg3 = static_cast< FXuval >(val3);
+  }
+  if (argc > 2) {
+    arg4 = NIL_P(argv[2]) ? 0 : reinterpret_cast<FXuchar*>(StringValuePtr(argv[2]));
+  }
+  result = (bool)(arg1)->open(arg2,arg3,arg4);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStream_getSpace(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = (FXStream *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuval result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream const *","getSpace", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (FXuval)((FXStream const *)arg1)->getSpace();
+  vresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStream_setSpace(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = (FXStream *) 0 ;
+  FXuval arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned long val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream *","setSpace", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXuval","setSpace", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXuval >(val2);
+  (arg1)->setSpace(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStream_status(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = (FXStream *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXStreamStatus result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream const *","status", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (FXStreamStatus)((FXStream const *)arg1)->status();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStream_eofq___(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = (FXStream *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream const *","eof", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (bool)((FXStream const *)arg1)->eof();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStream_setError(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = (FXStream *) 0 ;
+  FXStreamStatus arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream *","setError", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXStreamStatus","setError", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXStreamStatus >(val2);
+  (arg1)->setError(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStream_direction(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = (FXStream *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXStreamDirection result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream const *","direction", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (FXStreamDirection)((FXStream const *)arg1)->direction();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStream_container(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = (FXStream *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXObject *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream const *","container", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (FXObject *)((FXStream const *)arg1)->container();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXObject, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStream_getPosition(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = (FXStream *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXlong result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream const *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = ((FXStream const *)arg1)->position();
+  vresult = LONG2NUM(result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStream_swapBytes__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = (FXStream *) 0 ;
+  bool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream *","swapBytes", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","swapBytes", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  (arg1)->swapBytes(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStream_swapBytes__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = (FXStream *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream const *","swapBytes", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (bool)((FXStream const *)arg1)->swapBytes();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXStream_swapBytes(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXStream, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXStream_swapBytes__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXStream, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_bool(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXStream_swapBytes__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "FXStream.swapBytes", 
+    "    void FXStream.swapBytes(bool s)\n"
+    "    bool FXStream.swapBytes()\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStream_setBigEndian(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = (FXStream *) 0 ;
+  bool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream *","setBigEndian", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setBigEndian", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  (arg1)->setBigEndian(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStream_isBigEndian(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = (FXStream *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream const *","isBigEndian", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (bool)((FXStream const *)arg1)->isBigEndian();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStream_close(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = (FXStream *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream *","close", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (bool)FXStream_close(arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStream_flush(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = (FXStream *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream *","flush", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (bool)FXStream_flush(arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStream_setPosition(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = (FXStream *) 0 ;
+  FXlong arg2 ;
+  FXWhence arg3 = (FXWhence) FXFromStart ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  arg2 = static_cast<FXlong>(NUM2LONG(argv[0]));
+  if (argc > 1) {
+    ecode3 = SWIG_AsVal_int(argv[1], &val3);
+    if (!SWIG_IsOK(ecode3)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXWhence","position", 3, argv[1] ));
+    } 
+    arg3 = static_cast< FXWhence >(val3);
+  }
+  result = (bool)FXStream_position(arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXFileStream;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXFileStream_allocate(VALUE self)
+#else
+_wrap_FXFileStream_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXFileStream);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXFileStream(int argc, VALUE *argv, VALUE self) {
+  FXObject *arg1 = (FXObject *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFileStream *result = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  if (argc > 0) {
+    res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXObject const *","FXFileStream", 1, argv[0] )); 
+    }
+    arg1 = reinterpret_cast< FXObject * >(argp1);
+  }
+  {
+    result = (FXFileStream *)new_FXFileStream((FXObject const *)arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileStream_open(int argc, VALUE *argv, VALUE self) {
+  FXFileStream *arg1 = (FXFileStream *) 0 ;
+  FXString *arg2 = 0 ;
+  FXStreamDirection arg3 ;
+  FXuval arg4 = (FXuval) 8192 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  unsigned long val4 ;
+  int ecode4 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileStream *","open", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileStream * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  ecode3 = SWIG_AsVal_int(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXStreamDirection","open", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXStreamDirection >(val3);
+  if (argc > 2) {
+    ecode4 = SWIG_AsVal_unsigned_SS_long(argv[2], &val4);
+    if (!SWIG_IsOK(ecode4)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXuval","open", 4, argv[2] ));
+    } 
+    arg4 = static_cast< FXuval >(val4);
+  }
+  result = (bool)(arg1)->open((FXString const &)*arg2,arg3,arg4);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileStream_getPosition(int argc, VALUE *argv, VALUE self) {
+  FXFileStream *arg1 = (FXFileStream *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXlong result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileStream const *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileStream * >(argp1);
+  result = ((FXFileStream const *)arg1)->position();
+  vresult = LONG2NUM(result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileStream_close(int argc, VALUE *argv, VALUE self) {
+  FXFileStream *arg1 = (FXFileStream *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileStream *","close", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileStream * >(argp1);
+  result = (bool)FXFileStream_close(arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileStream_flush(int argc, VALUE *argv, VALUE self) {
+  FXFileStream *arg1 = (FXFileStream *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileStream *","flush", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileStream * >(argp1);
+  result = (bool)FXFileStream_flush(arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileStream_setPosition(int argc, VALUE *argv, VALUE self) {
+  FXFileStream *arg1 = (FXFileStream *) 0 ;
+  FXlong arg2 ;
+  FXWhence arg3 = (FXWhence) FXFromStart ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileStream *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileStream * >(argp1);
+  arg2 = static_cast<FXlong>(NUM2LONG(argv[0]));
+  if (argc > 1) {
+    ecode3 = SWIG_AsVal_int(argv[1], &val3);
+    if (!SWIG_IsOK(ecode3)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXWhence","position", 3, argv[1] ));
+    } 
+    arg3 = static_cast< FXWhence >(val3);
+  }
+  result = (bool)FXFileStream_position(arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMemoryStream;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMemoryStream_allocate(VALUE self)
+#else
+_wrap_FXMemoryStream_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMemoryStream);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMemoryStream(int argc, VALUE *argv, VALUE self) {
+  FXObject *arg1 = (FXObject *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMemoryStream *result = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  if (argc > 0) {
+    res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXObject const *","FXMemoryStream", 1, argv[0] )); 
+    }
+    arg1 = reinterpret_cast< FXObject * >(argp1);
+  }
+  {
+    result = (FXMemoryStream *)new_FXMemoryStream((FXObject const *)arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMemoryStream_open(int argc, VALUE *argv, VALUE self) {
+  FXMemoryStream *arg1 = (FXMemoryStream *) 0 ;
+  FXStreamDirection arg2 ;
+  VALUE arg3 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMemoryStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMemoryStream *","open", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMemoryStream * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXStreamDirection","open", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXStreamDirection >(val2);
+  arg3 = argv[1];
+  result = (bool)FXMemoryStream_open(arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMemoryStream_takeBuffer(int argc, VALUE *argv, VALUE self) {
+  FXMemoryStream *arg1 = (FXMemoryStream *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMemoryStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMemoryStream *","takeBuffer", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMemoryStream * >(argp1);
+  result = (VALUE)FXMemoryStream_takeBuffer(arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMemoryStream_giveBuffer(int argc, VALUE *argv, VALUE self) {
+  FXMemoryStream *arg1 = (FXMemoryStream *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMemoryStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMemoryStream *","giveBuffer", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMemoryStream * >(argp1);
+  arg2 = argv[0];
+  FXMemoryStream_giveBuffer(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMemoryStream_getPosition(int argc, VALUE *argv, VALUE self) {
+  FXMemoryStream *arg1 = (FXMemoryStream *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXlong result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMemoryStream, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMemoryStream const *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMemoryStream * >(argp1);
+  result = ((FXMemoryStream const *)arg1)->position();
+  vresult = LONG2NUM(result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXSize;
+
+SWIGINTERN VALUE
+_wrap_FXSize_w_set(int argc, VALUE *argv, VALUE self) {
+  FXSize *arg1 = (FXSize *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSize, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSize *","w", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSize * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->w = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSize_w_get(int argc, VALUE *argv, VALUE self) {
+  FXSize *arg1 = (FXSize *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXshort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSize, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSize *","w", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSize * >(argp1);
+  result = (FXshort) ((arg1)->w);
+  vresult = SWIG_From_short(static_cast< short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSize_h_set(int argc, VALUE *argv, VALUE self) {
+  FXSize *arg1 = (FXSize *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSize, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSize *","h", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSize * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->h = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSize_h_get(int argc, VALUE *argv, VALUE self) {
+  FXSize *arg1 = (FXSize *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXshort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSize, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSize *","h", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSize * >(argp1);
+  result = (FXshort) ((arg1)->h);
+  vresult = SWIG_From_short(static_cast< short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSize__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSize *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXSize *)new FXSize();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSize__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXSize *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXSize *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXSize,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSize const &","FXSize", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSize const &","FXSize", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXSize * >(argp1);
+  {
+    result = (FXSize *)new FXSize((FXSize const &)*arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXSize_allocate(VALUE self)
+#else
+_wrap_FXSize_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXSize);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSize__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXshort arg1 ;
+  FXshort arg2 ;
+  FXSize *result = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  arg1 = NUM2INT(argv[0]);
+  arg2 = NUM2INT(argv[1]);
+  {
+    result = (FXSize *)new FXSize(arg1,arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXSize(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[2];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 2) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_FXSize__SWIG_0(nargs, args, self);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSize, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXSize__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      _v = (TYPE(argv[0]) == T_FIXNUM || TYPE(argv[0]) == T_BIGNUM) ? 1 : 0;
+    }
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_new_FXSize__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 2, "FXSize.new", 
+    "    FXSize.new()\n"
+    "    FXSize.new(FXSize const &s)\n"
+    "    FXSize.new(FXshort ww, FXshort hh)\n");
+  
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXSize.empty?
+
+  call-seq:
+    empty? -> bool
+
+Check if FXSize is empty.
+*/
+SWIGINTERN VALUE
+_wrap_FXSize_emptyq___(int argc, VALUE *argv, VALUE self) {
+  FXSize *arg1 = (FXSize *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSize, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSize const *","empty", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSize * >(argp1);
+  result = (bool)((FXSize const *)arg1)->empty();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXSize.==
+
+  call-seq:
+    ==(s) -> bool
+
+Equality comparison operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXSize___eq__(int argc, VALUE *argv, VALUE self) {
+  FXSize *arg1 = (FXSize *) 0 ;
+  FXSize *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSize, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSize const *","operator ==", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSize * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXSize,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXSize const &","operator ==", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSize const &","operator ==", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXSize * >(argp2);
+  result = (bool)FXSize_operator_Se__Se_((FXSize const *)arg1,(FXSize const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXSize.-@
+
+  call-seq:
+    -@ -> FXSize
+
+Negation operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXSize___neg__(int argc, VALUE *argv, VALUE self) {
+  FXSize *arg1 = (FXSize *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXSize result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSize, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSize *","operator -", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSize * >(argp1);
+  result = (arg1)->operator -();
+  vresult = SWIG_NewPointerObj((new FXSize(static_cast< const FXSize& >(result))), SWIGTYPE_p_FXSize, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSize_growN_____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSize *arg1 = (FXSize *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXSize *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSize, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSize *","grow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSize * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXSize *) &(arg1)->grow(arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSize, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSize_growN_____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXSize *arg1 = (FXSize *) 0 ;
+  FXshort arg2 ;
+  FXshort arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXSize *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSize, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSize *","grow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSize * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXSize *) &(arg1)->grow(arg2,arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSize, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSize_growN_____SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXSize *arg1 = (FXSize *) 0 ;
+  FXshort arg2 ;
+  FXshort arg3 ;
+  FXshort arg4 ;
+  FXshort arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXSize *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSize, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSize *","grow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSize * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  result = (FXSize *) &(arg1)->grow(arg2,arg3,arg4,arg5);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSize, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXSize_growN___(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSize, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXSize_growN_____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSize, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          return _wrap_FXSize_growN_____SWIG_1(nargs, args, self);
+        }
+      }
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSize, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXSize_growN_____SWIG_2(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "FXSize.grow!", 
+    "    FXSize FXSize.grow!(FXshort margin)\n"
+    "    FXSize FXSize.grow!(FXshort hormargin, FXshort vermargin)\n"
+    "    FXSize & FXSize.grow!(FXshort leftmargin, FXshort rightmargin, FXshort topmargin, FXshort bottommargin)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSize_shrinkN_____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSize *arg1 = (FXSize *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXSize *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSize, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSize *","shrink", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSize * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXSize *) &(arg1)->shrink(arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSize, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSize_shrinkN_____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXSize *arg1 = (FXSize *) 0 ;
+  FXshort arg2 ;
+  FXshort arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXSize *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSize, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSize *","shrink", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSize * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXSize *) &(arg1)->shrink(arg2,arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSize, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSize_shrinkN_____SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXSize *arg1 = (FXSize *) 0 ;
+  FXshort arg2 ;
+  FXshort arg3 ;
+  FXshort arg4 ;
+  FXshort arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXSize *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSize, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSize *","shrink", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSize * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  result = (FXSize *) &(arg1)->shrink(arg2,arg3,arg4,arg5);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSize, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXSize_shrinkN___(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSize, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXSize_shrinkN_____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSize, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          return _wrap_FXSize_shrinkN_____SWIG_1(nargs, args, self);
+        }
+      }
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSize, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXSize_shrinkN_____SWIG_2(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "FXSize.shrink!", 
+    "    FXSize FXSize.shrink!(FXshort margin)\n"
+    "    FXSize FXSize.shrink!(FXshort hormargin, FXshort vermargin)\n"
+    "    FXSize & FXSize.shrink!(FXshort leftmargin, FXshort rightmargin, FXshort topmargin, FXshort bottommargin)\n");
+  
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXSize.+
+
+  call-seq:
+    +(s) -> FXSize
+
+Add operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXSize___add__(int argc, VALUE *argv, VALUE self) {
+  FXSize *arg1 = (FXSize *) 0 ;
+  FXSize *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXSize result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSize, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSize const *","operator +", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSize * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXSize,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXSize const &","operator +", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSize const &","operator +", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXSize * >(argp2);
+  result = FXSize_operator_Sa_((FXSize const *)arg1,(FXSize const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXSize(static_cast< const FXSize& >(result))), SWIGTYPE_p_FXSize, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXSize.-
+
+  call-seq:
+    -(s) -> FXSize
+
+Substraction operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXSize___sub__(int argc, VALUE *argv, VALUE self) {
+  FXSize *arg1 = (FXSize *) 0 ;
+  FXSize *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXSize result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSize, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSize const *","operator -", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSize * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXSize,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXSize const &","operator -", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSize const &","operator -", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXSize * >(argp2);
+  result = FXSize_operator_Ss_((FXSize const *)arg1,(FXSize const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXSize(static_cast< const FXSize& >(result))), SWIGTYPE_p_FXSize, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSize___mul__(int argc, VALUE *argv, VALUE self) {
+  FXSize *arg1 = (FXSize *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXSize result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSize, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSize const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSize * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = FXSize_operator_Sm_((FXSize const *)arg1,arg2);
+  vresult = SWIG_NewPointerObj((new FXSize(static_cast< const FXSize& >(result))), SWIGTYPE_p_FXSize, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSize___div__(int argc, VALUE *argv, VALUE self) {
+  FXSize *arg1 = (FXSize *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXSize result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSize, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSize const *","operator /", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSize * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = FXSize_operator_Sd_((FXSize const *)arg1,arg2);
+  vresult = SWIG_NewPointerObj((new FXSize(static_cast< const FXSize& >(result))), SWIGTYPE_p_FXSize, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXPoint;
+
+SWIGINTERN VALUE
+_wrap_FXPoint_x_set(int argc, VALUE *argv, VALUE self) {
+  FXPoint *arg1 = (FXPoint *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPoint *","x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPoint * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->x = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPoint_x_get(int argc, VALUE *argv, VALUE self) {
+  FXPoint *arg1 = (FXPoint *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXshort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPoint *","x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPoint * >(argp1);
+  result = (FXshort) ((arg1)->x);
+  vresult = SWIG_From_short(static_cast< short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPoint_y_set(int argc, VALUE *argv, VALUE self) {
+  FXPoint *arg1 = (FXPoint *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPoint *","y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPoint * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->y = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPoint_y_get(int argc, VALUE *argv, VALUE self) {
+  FXPoint *arg1 = (FXPoint *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXshort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPoint *","y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPoint * >(argp1);
+  result = (FXshort) ((arg1)->y);
+  vresult = SWIG_From_short(static_cast< short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXPoint__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSize *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXPoint *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXSize,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSize const &","FXPoint", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSize const &","FXPoint", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXSize * >(argp1);
+  {
+    result = (FXPoint *)new FXPoint((FXSize const &)*arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXPoint__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXPoint *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXPoint *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXPoint,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPoint const &","FXPoint", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXPoint const &","FXPoint", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXPoint * >(argp1);
+  {
+    result = (FXPoint *)new FXPoint((FXPoint const &)*arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXPoint_allocate(VALUE self)
+#else
+_wrap_FXPoint_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXPoint);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXPoint__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXshort arg1 = (FXshort) 0 ;
+  FXshort arg2 = (FXshort) 0 ;
+  FXPoint *result = 0 ;
+  
+  if ((argc < 0) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  if (argc > 0) {
+    arg1 = NUM2INT(argv[0]);
+  }
+  if (argc > 1) {
+    arg2 = NUM2INT(argv[1]);
+  }
+  {
+    result = (FXPoint *)new FXPoint(arg1,arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXPoint(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[2];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 2) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 0) && (argc <= 2)) {
+    int _v;
+    if (argc <= 0) {
+      return _wrap_new_FXPoint__SWIG_2(nargs, args, self);
+    }
+    {
+      _v = (TYPE(argv[0]) == T_FIXNUM || TYPE(argv[0]) == T_BIGNUM) ? 1 : 0;
+    }
+    if (_v) {
+      if (argc <= 1) {
+        return _wrap_new_FXPoint__SWIG_2(nargs, args, self);
+      }
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_new_FXPoint__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXPoint, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXPoint__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSize, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXPoint__SWIG_0(nargs, args, self);
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 2, "FXPoint.new", 
+    "    FXPoint.new(FXSize const &s)\n"
+    "    FXPoint.new(FXPoint const &p)\n"
+    "    FXPoint.new(FXshort xx, FXshort yy)\n");
+  
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXPoint.==
+
+  call-seq:
+    ==(p) -> bool
+
+Equality comparison operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXPoint___eq__(int argc, VALUE *argv, VALUE self) {
+  FXPoint *arg1 = (FXPoint *) 0 ;
+  FXPoint *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPoint const *","operator ==", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPoint * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXPoint,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXPoint const &","operator ==", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXPoint const &","operator ==", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXPoint * >(argp2);
+  result = (bool)FXPoint_operator_Se__Se_((FXPoint const *)arg1,(FXPoint const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXPoint.-@
+
+  call-seq:
+    -@ -> FXPoint
+
+Negation operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXPoint___neg__(int argc, VALUE *argv, VALUE self) {
+  FXPoint *arg1 = (FXPoint *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPoint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPoint *","operator -", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPoint * >(argp1);
+  result = (arg1)->operator -();
+  vresult = SWIG_NewPointerObj((new FXPoint(static_cast< const FXPoint& >(result))), SWIGTYPE_p_FXPoint, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXPoint.+
+
+  call-seq:
+    +(p) -> FXPoint
+    +(s) -> FXPoint
+
+Add operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXPoint___add____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXPoint *arg1 = (FXPoint *) 0 ;
+  FXPoint *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXPoint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPoint const *","operator +", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPoint * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXPoint,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXPoint const &","operator +", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXPoint const &","operator +", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXPoint * >(argp2);
+  result = FXPoint_operator_Sa___SWIG_0((FXPoint const *)arg1,(FXPoint const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXPoint(static_cast< const FXPoint& >(result))), SWIGTYPE_p_FXPoint, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPoint___add____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXPoint *arg1 = (FXPoint *) 0 ;
+  FXSize *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXPoint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPoint const *","operator +", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPoint * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXSize,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXSize const &","operator +", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSize const &","operator +", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXSize * >(argp2);
+  result = FXPoint_operator_Sa___SWIG_1((FXPoint const *)arg1,(FXSize const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXPoint(static_cast< const FXPoint& >(result))), SWIGTYPE_p_FXPoint, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXPoint___add__(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXPoint, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXPoint, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXPoint___add____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXPoint, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXSize, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXPoint___add____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "__add__", 
+    "    FXPoint __add__(FXPoint const &p)\n"
+    "    FXPoint __add__(FXSize const &s)\n");
+  
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXPoint.-
+
+  call-seq:
+    -(p) -> FXPoint
+    -(s) -> FXPoint
+
+Substraction operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXPoint___sub____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXPoint *arg1 = (FXPoint *) 0 ;
+  FXPoint *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXPoint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPoint const *","operator -", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPoint * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXPoint,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXPoint const &","operator -", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXPoint const &","operator -", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXPoint * >(argp2);
+  result = FXPoint_operator_Ss___SWIG_0((FXPoint const *)arg1,(FXPoint const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXPoint(static_cast< const FXPoint& >(result))), SWIGTYPE_p_FXPoint, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPoint___sub____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXPoint *arg1 = (FXPoint *) 0 ;
+  FXSize *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXPoint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPoint const *","operator -", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPoint * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXSize,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXSize const &","operator -", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSize const &","operator -", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXSize * >(argp2);
+  result = FXPoint_operator_Ss___SWIG_1((FXPoint const *)arg1,(FXSize const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXPoint(static_cast< const FXPoint& >(result))), SWIGTYPE_p_FXPoint, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXPoint___sub__(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXPoint, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXPoint, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXPoint___sub____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXPoint, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXSize, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXPoint___sub____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "__sub__", 
+    "    FXPoint __sub__(FXPoint const &p)\n"
+    "    FXPoint __sub__(FXSize const &s)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPoint___mul__(int argc, VALUE *argv, VALUE self) {
+  FXPoint *arg1 = (FXPoint *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPoint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPoint const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPoint * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = FXPoint_operator_Sm_((FXPoint const *)arg1,arg2);
+  vresult = SWIG_NewPointerObj((new FXPoint(static_cast< const FXPoint& >(result))), SWIGTYPE_p_FXPoint, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPoint___div__(int argc, VALUE *argv, VALUE self) {
+  FXPoint *arg1 = (FXPoint *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPoint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPoint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPoint const *","operator /", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPoint * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = FXPoint_operator_Sd_((FXPoint const *)arg1,arg2);
+  vresult = SWIG_NewPointerObj((new FXPoint(static_cast< const FXPoint& >(result))), SWIGTYPE_p_FXPoint, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXRectangle;
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_x_set(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle *","x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->x = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_x_get(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXshort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle *","x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  result = (FXshort) ((arg1)->x);
+  vresult = SWIG_From_short(static_cast< short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_y_set(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle *","y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->y = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_y_get(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXshort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle *","y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  result = (FXshort) ((arg1)->y);
+  vresult = SWIG_From_short(static_cast< short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_w_set(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle *","w", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->w = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_w_get(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXshort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle *","w", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  result = (FXshort) ((arg1)->w);
+  vresult = SWIG_From_short(static_cast< short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_h_set(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle *","h", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->h = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_h_get(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXshort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle *","h", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  result = (FXshort) ((arg1)->h);
+  vresult = SWIG_From_short(static_cast< short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRectangle__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXRectangle *)new FXRectangle();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRectangle__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXshort arg1 ;
+  FXshort arg2 ;
+  FXshort arg3 ;
+  FXshort arg4 ;
+  FXRectangle *result = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  arg1 = NUM2INT(argv[0]);
+  arg2 = NUM2INT(argv[1]);
+  arg3 = NUM2INT(argv[2]);
+  arg4 = NUM2INT(argv[3]);
+  {
+    result = (FXRectangle *)new FXRectangle(arg1,arg2,arg3,arg4);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRectangle__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXPoint *arg1 = 0 ;
+  FXSize *arg2 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXRectangle *result = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXPoint,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPoint const &","FXRectangle", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXPoint const &","FXRectangle", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXPoint * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FXSize,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXSize const &","FXRectangle", 2, argv[1] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSize const &","FXRectangle", 2, argv[1])); 
+  }
+  arg2 = reinterpret_cast< FXSize * >(argp2);
+  {
+    result = (FXRectangle *)new FXRectangle((FXPoint const &)*arg1,(FXSize const &)*arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXRectangle_allocate(VALUE self)
+#else
+_wrap_FXRectangle_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXRectangle);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRectangle__SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXPoint *arg1 = 0 ;
+  FXPoint *arg2 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXRectangle *result = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXPoint,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPoint const &","FXRectangle", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXPoint const &","FXRectangle", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXPoint * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FXPoint,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXPoint const &","FXRectangle", 2, argv[1] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXPoint const &","FXRectangle", 2, argv[1])); 
+  }
+  arg2 = reinterpret_cast< FXPoint * >(argp2);
+  {
+    result = (FXRectangle *)new FXRectangle((FXPoint const &)*arg1,(FXPoint const &)*arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXRectangle(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 4) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_FXRectangle__SWIG_0(nargs, args, self);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXPoint, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXSize, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_FXRectangle__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXPoint, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXPoint, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_FXRectangle__SWIG_3(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    {
+      _v = (TYPE(argv[0]) == T_FIXNUM || TYPE(argv[0]) == T_BIGNUM) ? 1 : 0;
+    }
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_new_FXRectangle__SWIG_1(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXRectangle.new", 
+    "    FXRectangle.new()\n"
+    "    FXRectangle.new(FXshort xx, FXshort yy, FXshort ww, FXshort hh)\n"
+    "    FXRectangle.new(FXPoint const &p, FXSize const &s)\n"
+    "    FXRectangle.new(FXPoint const &topleft, FXPoint const &bottomright)\n");
+  
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXRectangle.==
+
+  call-seq:
+    ==(p) -> bool
+
+Equality comparison operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXRectangle___eq__(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  FXRectangle *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle const *","operator ==", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRectangle,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRectangle const &","operator ==", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRectangle const &","operator ==", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRectangle * >(argp2);
+  result = (bool)FXRectangle_operator_Se__Se_((FXRectangle const *)arg1,(FXRectangle const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_containsq_____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  FXPoint *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXPoint,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXPoint const &","contains", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXPoint const &","contains", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXPoint * >(argp2);
+  result = (bool)((FXRectangle const *)arg1)->contains((FXPoint const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_containsq_____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  FXshort arg2 ;
+  FXshort arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)((FXRectangle const *)arg1)->contains(arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_containsq_____SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  FXRectangle *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRectangle,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRectangle const &","contains", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRectangle const &","contains", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRectangle * >(argp2);
+  result = (bool)((FXRectangle const *)arg1)->contains((FXRectangle const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXRectangle_containsq___(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 4) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRectangle, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXPoint, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRectangle_containsq_____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRectangle, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRectangle, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRectangle_containsq_____SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRectangle, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          return _wrap_FXRectangle_containsq_____SWIG_1(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXRectangle.contains?", 
+    "    bool FXRectangle.contains?(FXPoint const &p)\n"
+    "    bool FXRectangle.contains?(FXshort xx, FXshort yy)\n"
+    "    bool FXRectangle.contains?(FXRectangle const &r)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_overlapsq___(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  FXRectangle *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle const *","overlap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRectangle,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRectangle const &","overlap", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRectangle const &","overlap", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRectangle * >(argp2);
+  result = (bool)FXRectangle_overlap((FXRectangle const *)arg1,(FXRectangle const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_moveN_____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  FXPoint *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXRectangle *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXPoint,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXPoint const &","move", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXPoint const &","move", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXPoint * >(argp2);
+  result = (FXRectangle *) &(arg1)->move((FXPoint const &)*arg2);
+  vresult = FXRbGetRubyObj(result, "FXRectangle *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_moveN_____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  FXshort arg2 ;
+  FXshort arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXRectangle *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXRectangle *) &(arg1)->move(arg2,arg3);
+  vresult = FXRbGetRubyObj(result, "FXRectangle *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXRectangle_moveN___(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 4) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRectangle, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXPoint, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRectangle_moveN_____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRectangle, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          return _wrap_FXRectangle_moveN_____SWIG_1(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXRectangle.move!", 
+    "    FXRectangle FXRectangle.move!(FXPoint const &p)\n"
+    "    FXRectangle & FXRectangle.move!(FXshort dx, FXshort dy)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_growN_____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXRectangle *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle *","grow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXRectangle *) &(arg1)->grow(arg2);
+  vresult = FXRbGetRubyObj(result, "FXRectangle *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_growN_____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  FXshort arg2 ;
+  FXshort arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXRectangle *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle *","grow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXRectangle *) &(arg1)->grow(arg2,arg3);
+  vresult = FXRbGetRubyObj(result, "FXRectangle *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_growN_____SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  FXshort arg2 ;
+  FXshort arg3 ;
+  FXshort arg4 ;
+  FXshort arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXRectangle *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle *","grow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  result = (FXRectangle *) &(arg1)->grow(arg2,arg3,arg4,arg5);
+  vresult = FXRbGetRubyObj(result, "FXRectangle *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXRectangle_growN___(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRectangle, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXRectangle_growN_____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRectangle, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          return _wrap_FXRectangle_growN_____SWIG_1(nargs, args, self);
+        }
+      }
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRectangle, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXRectangle_growN_____SWIG_2(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "FXRectangle.grow!", 
+    "    FXRectangle FXRectangle.grow!(FXshort margin)\n"
+    "    FXRectangle FXRectangle.grow!(FXshort hormargin, FXshort vermargin)\n"
+    "    FXRectangle & FXRectangle.grow!(FXshort leftmargin, FXshort rightmargin, FXshort topmargin, FXshort bottommargin)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_shrinkN_____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXRectangle *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle *","shrink", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXRectangle *) &(arg1)->shrink(arg2);
+  vresult = FXRbGetRubyObj(result, "FXRectangle *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_shrinkN_____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  FXshort arg2 ;
+  FXshort arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXRectangle *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle *","shrink", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXRectangle *) &(arg1)->shrink(arg2,arg3);
+  vresult = FXRbGetRubyObj(result, "FXRectangle *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_shrinkN_____SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  FXshort arg2 ;
+  FXshort arg3 ;
+  FXshort arg4 ;
+  FXshort arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXRectangle *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle *","shrink", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  result = (FXRectangle *) &(arg1)->shrink(arg2,arg3,arg4,arg5);
+  vresult = FXRbGetRubyObj(result, "FXRectangle *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXRectangle_shrinkN___(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRectangle, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXRectangle_shrinkN_____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRectangle, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          return _wrap_FXRectangle_shrinkN_____SWIG_1(nargs, args, self);
+        }
+      }
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRectangle, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXRectangle_shrinkN_____SWIG_2(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "FXRectangle.shrink!", 
+    "    FXRectangle FXRectangle.shrink!(FXshort margin)\n"
+    "    FXRectangle FXRectangle.shrink!(FXshort hormargin, FXshort vermargin)\n"
+    "    FXRectangle & FXRectangle.shrink!(FXshort leftmargin, FXshort rightmargin, FXshort topmargin, FXshort bottommargin)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_tl(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPoint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle const *","tl", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  result = ((FXRectangle const *)arg1)->tl();
+  vresult = SWIG_NewPointerObj((new FXPoint(static_cast< const FXPoint& >(result))), SWIGTYPE_p_FXPoint, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_tr(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPoint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  result = ((FXRectangle const *)arg1)->tr();
+  vresult = SWIG_NewPointerObj((new FXPoint(static_cast< const FXPoint& >(result))), SWIGTYPE_p_FXPoint, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_bl(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPoint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle const *","bl", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  result = ((FXRectangle const *)arg1)->bl();
+  vresult = SWIG_NewPointerObj((new FXPoint(static_cast< const FXPoint& >(result))), SWIGTYPE_p_FXPoint, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle_br(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPoint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle const *","br", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  result = ((FXRectangle const *)arg1)->br();
+  vresult = SWIG_NewPointerObj((new FXPoint(static_cast< const FXPoint& >(result))), SWIGTYPE_p_FXPoint, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXRectangle.+
+
+  call-seq:
+    +(p) -> FXRectangle
+
+Add operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXRectangle___add__(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  FXRectangle *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXRectangle result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle const *","operator +", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRectangle,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRectangle const &","operator +", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRectangle const &","operator +", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRectangle * >(argp2);
+  result = FXRectangle_operator_Sa_((FXRectangle const *)arg1,(FXRectangle const &)*arg2);
+  {
+    FXRectangle* resultptr = new FXRectangle(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXRectangle *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRectangle___mul__(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = (FXRectangle *) 0 ;
+  FXRectangle *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXRectangle result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRectangle,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRectangle const &","operator *", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRectangle const &","operator *", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRectangle * >(argp2);
+  result = FXRectangle_operator_Sm_((FXRectangle const *)arg1,(FXRectangle const &)*arg2);
+  {
+    FXRectangle* resultptr = new FXRectangle(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXRectangle *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXRegion;
+
+SWIGINTERN VALUE
+_wrap_new_FXRegion__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXRegion *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXRegion *)new FXRegion();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRegion__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXRegion *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXRegion *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRegion const &","FXRegion", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","FXRegion", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXRegion * >(argp1);
+  {
+    result = (FXRegion *)new FXRegion((FXRegion const &)*arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRegion__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXRectangle *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXRegion *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXRectangle,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRectangle const &","FXRegion", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRectangle const &","FXRegion", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXRectangle * >(argp1);
+  {
+    result = (FXRegion *)new FXRegion((FXRectangle const &)*arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRegion__SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXint arg1 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXRegion *result = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  arg1 = NUM2INT(argv[0]);
+  arg2 = NUM2INT(argv[1]);
+  arg3 = NUM2INT(argv[2]);
+  arg4 = NUM2INT(argv[3]);
+  {
+    result = (FXRegion *)new FXRegion(arg1,arg2,arg3,arg4);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXRegion_allocate(VALUE self)
+#else
+_wrap_FXRegion_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXRegion);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRegion__SWIG_4(int argc, VALUE *argv, VALUE self) {
+  FXPoint *arg1 = (FXPoint *) 0 ;
+  FXuint arg2 ;
+  bool arg3 = (bool) 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  FXRegion *result = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg1 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg2 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg2; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg1[i] = *pPoint;
+    }
+  }
+  if (argc > 1) {
+    ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+    if (!SWIG_IsOK(ecode3)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","FXRegion", 3, argv[1] ));
+    } 
+    arg3 = static_cast< bool >(val3);
+  }
+  {
+    result = (FXRegion *)new FXRegion((FXPoint const *)arg1,arg2,arg3);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  {
+    delete [] arg1;
+  }
+  return self;
+fail:
+  {
+    delete [] arg1;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXRegion(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 4) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_FXRegion__SWIG_0(nargs, args, self);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRegion, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXRegion__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRectangle, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXRegion__SWIG_2(nargs, args, self);
+    }
+  }
+  if ((argc >= 1) && (argc <= 2)) {
+    int _v;
+    {
+      _v = (TYPE(argv[0]) == T_ARRAY) ? 1 : 0;
+    }
+    if (_v) {
+      if (argc <= 1) {
+        return _wrap_new_FXRegion__SWIG_4(nargs, args, self);
+      }
+      {
+        int res = SWIG_AsVal_bool(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_FXRegion__SWIG_4(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    {
+      _v = (TYPE(argv[0]) == T_FIXNUM || TYPE(argv[0]) == T_BIGNUM) ? 1 : 0;
+    }
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_new_FXRegion__SWIG_3(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXRegion.new", 
+    "    FXRegion.new()\n"
+    "    FXRegion.new(FXRegion const &r)\n"
+    "    FXRegion.new(FXRectangle const &rect)\n"
+    "    FXRegion.new(FXint x, FXint y, FXint w, FXint h)\n"
+    "    FXRegion.new(FXPoint const *points, FXuint npoints, bool winding)\n");
+  
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXRegion.empty?
+
+  call-seq:
+    empty? -> bool
+
+Check if FXRegion is empty.
+*/
+SWIGINTERN VALUE
+_wrap_FXRegion_emptyq___(int argc, VALUE *argv, VALUE self) {
+  FXRegion *arg1 = (FXRegion *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRegion, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRegion const *","empty", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRegion * >(argp1);
+  result = (bool)((FXRegion const *)arg1)->empty();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRegion_containsq_____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXRegion *arg1 = (FXRegion *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRegion, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRegion const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRegion * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)((FXRegion const *)arg1)->contains(arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRegion_containsq_____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXRegion *arg1 = (FXRegion *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRegion, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRegion const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRegion * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  result = (bool)((FXRegion const *)arg1)->contains(arg2,arg3,arg4,arg5);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXRegion_containsq___(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRegion, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          return _wrap_FXRegion_containsq_____SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRegion, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXRegion_containsq_____SWIG_1(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "FXRegion.contains?", 
+    "    bool FXRegion.contains?(FXint x, FXint y)\n"
+    "    bool FXRegion.contains?(FXint x, FXint y, FXint w, FXint h)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRegion_bounds(int argc, VALUE *argv, VALUE self) {
+  FXRegion *arg1 = (FXRegion *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXRectangle result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRegion, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRegion const *","bounds", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRegion * >(argp1);
+  result = ((FXRegion const *)arg1)->bounds();
+  {
+    FXRectangle* resultptr = new FXRectangle(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXRectangle *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRegion_offsetN___(int argc, VALUE *argv, VALUE self) {
+  FXRegion *arg1 = (FXRegion *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXRegion *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRegion, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRegion *","offset", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRegion * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXRegion *) &(arg1)->offset(arg2,arg3);
+  vresult = FXRbGetRubyObj(result, "FXRegion *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXRegion.+
+
+  call-seq:
+    +(other) -> FXRegion
+
+Add operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXRegion___add__(int argc, VALUE *argv, VALUE self) {
+  FXRegion *arg1 = (FXRegion *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXRegion result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRegion, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRegion const *","operator +", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRegion * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","operator +", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","operator +", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  result = FXRegion_operator_Sa_((FXRegion const *)arg1,(FXRegion const &)*arg2);
+  {
+    FXRegion* resultptr = new FXRegion(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXRegion *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRegion___mul__(int argc, VALUE *argv, VALUE self) {
+  FXRegion *arg1 = (FXRegion *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXRegion result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRegion, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRegion const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRegion * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","operator *", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","operator *", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  result = FXRegion_operator_Sm_((FXRegion const *)arg1,(FXRegion const &)*arg2);
+  {
+    FXRegion* resultptr = new FXRegion(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXRegion *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXRegion.-
+
+  call-seq:
+    -(other) -> FXRegion
+
+Substraction operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXRegion___sub__(int argc, VALUE *argv, VALUE self) {
+  FXRegion *arg1 = (FXRegion *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXRegion result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRegion, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRegion const *","operator -", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRegion * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","operator -", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","operator -", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  result = FXRegion_operator_Ss_((FXRegion const *)arg1,(FXRegion const &)*arg2);
+  {
+    FXRegion* resultptr = new FXRegion(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXRegion *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXRegion.^
+
+  call-seq:
+    ^(other) -> FXRegion
+
+XOR operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXRegion___xor__(int argc, VALUE *argv, VALUE self) {
+  FXRegion *arg1 = (FXRegion *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXRegion result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRegion, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRegion const *","operator ^", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRegion * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","operator ^", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","operator ^", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  result = FXRegion_operator_Sx_((FXRegion const *)arg1,(FXRegion const &)*arg2);
+  {
+    FXRegion* resultptr = new FXRegion(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXRegion *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXRegion.==
+
+  call-seq:
+    ==(other) -> bool
+
+Equality comparison operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXRegion___eq__(int argc, VALUE *argv, VALUE self) {
+  FXRegion *arg1 = (FXRegion *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRegion, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRegion const *","operator ==", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRegion * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","operator ==", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","operator ==", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  result = (bool)FXRegion_operator_Se__Se_((FXRegion const *)arg1,(FXRegion const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRegion_reset(int argc, VALUE *argv, VALUE self) {
+  FXRegion *arg1 = (FXRegion *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRegion, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRegion *","reset", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRegion * >(argp1);
+  (arg1)->reset();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXObject;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXObject_allocate(VALUE self)
+#else
+_wrap_FXObject_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXObject);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXObject(int argc, VALUE *argv, VALUE self) {
+  FXObject *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXObject *)new_FXObject();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXObject_handle(int argc, VALUE *argv, VALUE self) {
+  FXObject *arg1 = (FXObject *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXObject *","handle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXObject * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","handle", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = FXRbGetExpectedData(self, arg3, argv[2]);
+  result = (long)(arg1)->handle(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXObject_tryHandle(int argc, VALUE *argv, VALUE self) {
+  FXObject *arg1 = (FXObject *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXObject *","tryHandle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXObject * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","tryHandle", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","tryHandle", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->tryHandle(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXObject_save(int argc, VALUE *argv, VALUE self) {
+  FXObject *arg1 = (FXObject *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXObject const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXObject * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXObject_save((FXObject const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXObject_load(int argc, VALUE *argv, VALUE self) {
+  FXObject *arg1 = (FXObject *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXObject *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXObject * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXObject_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXAccelTable;
+
+SWIGINTERN VALUE
+_wrap_FXAccelTable_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXAccelTable *arg1 = (FXAccelTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXAccelTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXAccelTable *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXAccelTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXAccelTable_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXAccelTable *arg1 = (FXAccelTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXAccelTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXAccelTable *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXAccelTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXAccelTable_allocate(VALUE self)
+#else
+_wrap_FXAccelTable_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXAccelTable);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXAccelTable(int argc, VALUE *argv, VALUE self) {
+  FXAccelTable *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXAccelTable *)new_FXAccelTable();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXAccelTable_addAccel(int argc, VALUE *argv, VALUE self) {
+  FXAccelTable *arg1 = (FXAccelTable *) 0 ;
+  FXHotKey arg2 ;
+  FXObject *arg3 = (FXObject *) 0 ;
+  FXSelector arg4 = (FXSelector) 0 ;
+  FXSelector arg5 = (FXSelector) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 1) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXAccelTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXAccelTable *","addAccel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXAccelTable * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXObject *","addAccel", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXObject * >(argp3);
+  }
+  if (argc > 2) {
+    arg4 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg5 = NUM2UINT(argv[3]);
+  }
+  (arg1)->addAccel(arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXAccelTable_removeAccel(int argc, VALUE *argv, VALUE self) {
+  FXAccelTable *arg1 = (FXAccelTable *) 0 ;
+  FXHotKey arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXAccelTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXAccelTable *","removeAccel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXAccelTable * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->removeAccel(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXAccelTable_hasAccel(int argc, VALUE *argv, VALUE self) {
+  FXAccelTable *arg1 = (FXAccelTable *) 0 ;
+  FXHotKey arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXAccelTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXAccelTable const *","hasAccel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXAccelTable * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  result = (bool)((FXAccelTable const *)arg1)->hasAccel(arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXAccelTable_targetOfAccel(int argc, VALUE *argv, VALUE self) {
+  FXAccelTable *arg1 = (FXAccelTable *) 0 ;
+  FXHotKey arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXObject *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXAccelTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXAccelTable const *","targetOfAccel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXAccelTable * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  result = (FXObject *)((FXAccelTable const *)arg1)->targetOfAccel(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXObject, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXAccelTable_save(int argc, VALUE *argv, VALUE self) {
+  FXAccelTable *arg1 = (FXAccelTable *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXAccelTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXAccelTable const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXAccelTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXAccelTable_save((FXAccelTable const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXAccelTable_load(int argc, VALUE *argv, VALUE self) {
+  FXAccelTable *arg1 = (FXAccelTable *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXAccelTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXAccelTable *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXAccelTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXAccelTable_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_parseAccel(int argc, VALUE *argv, VALUE self) {
+  FXString *arg1 = 0 ;
+  SwigValueWrapper< FXString > p1 ;
+  FXHotKey result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  p1 = to_FXString(argv[0]); arg1 = &p1;
+  result = (FXHotKey)parseAccel((FXString const &)*arg1);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_unparseAccel(int argc, VALUE *argv, VALUE self) {
+  FXHotKey arg1 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  arg1 = NUM2UINT(argv[0]);
+  result = unparseAccel(arg1);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_parseHotKey(int argc, VALUE *argv, VALUE self) {
+  FXString *arg1 = 0 ;
+  SwigValueWrapper< FXString > p1 ;
+  FXHotKey result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  p1 = to_FXString(argv[0]); arg1 = &p1;
+  result = (FXHotKey)parseHotKey((FXString const &)*arg1);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_findHotKey(int argc, VALUE *argv, VALUE self) {
+  FXString *arg1 = 0 ;
+  SwigValueWrapper< FXString > p1 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  p1 = to_FXString(argv[0]); arg1 = &p1;
+  result = (FXint)findHotKey((FXString const &)*arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_stripHotKey(int argc, VALUE *argv, VALUE self) {
+  FXString *arg1 = 0 ;
+  SwigValueWrapper< FXString > p1 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  p1 = to_FXString(argv[0]); arg1 = &p1;
+  result = stripHotKey((FXString const &)*arg1);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXEvent;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXEvent_allocate(VALUE self)
+#else
+_wrap_FXEvent_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXEvent);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXEvent(int argc, VALUE *argv, VALUE self) {
+  FXEvent *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (FXEvent *)new FXEvent();
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_type_set(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","type", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (arg1) (arg1)->type = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_type_get(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","type", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  result = (FXuint) ((arg1)->type);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_time_set(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","time", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (arg1) (arg1)->time = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_time_get(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","time", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  result = (FXuint) ((arg1)->time);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_win_x_set(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","win_x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->win_x = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_win_x_get(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","win_x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  result = (FXint) ((arg1)->win_x);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_win_y_set(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","win_y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->win_y = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_win_y_get(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","win_y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  result = (FXint) ((arg1)->win_y);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_root_x_set(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","root_x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->root_x = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_root_x_get(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","root_x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  result = (FXint) ((arg1)->root_x);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_root_y_set(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","root_y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->root_y = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_root_y_get(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","root_y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  result = (FXint) ((arg1)->root_y);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_state_set(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","state", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->state = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_state_get(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","state", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  result = (FXint) ((arg1)->state);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_code_set(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","code", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->code = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_code_get(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","code", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  result = (FXint) ((arg1)->code);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_text_set(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  FXString arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","text", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  arg2 = to_FXString(argv[0]);
+  if (arg1) (arg1)->text = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_text_get(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","text", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  result =  ((arg1)->text);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_last_x_set(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","last_x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->last_x = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_last_x_get(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","last_x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  result = (FXint) ((arg1)->last_x);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_last_y_set(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","last_y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->last_y = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_last_y_get(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","last_y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  result = (FXint) ((arg1)->last_y);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_click_x_set(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","click_x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->click_x = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_click_x_get(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","click_x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  result = (FXint) ((arg1)->click_x);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_click_y_set(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","click_y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->click_y = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_click_y_get(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","click_y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  result = (FXint) ((arg1)->click_y);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_rootclick_x_set(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","rootclick_x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->rootclick_x = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_rootclick_x_get(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","rootclick_x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  result = (FXint) ((arg1)->rootclick_x);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_rootclick_y_set(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","rootclick_y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->rootclick_y = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_rootclick_y_get(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","rootclick_y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  result = (FXint) ((arg1)->rootclick_y);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_click_time_set(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","click_time", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (arg1) (arg1)->click_time = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_click_time_get(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","click_time", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  result = (FXuint) ((arg1)->click_time);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_click_button_set(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","click_button", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (arg1) (arg1)->click_button = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_click_button_get(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","click_button", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  result = (FXuint) ((arg1)->click_button);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_click_count_set(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","click_count", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->click_count = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_click_count_get(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","click_count", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  result = (FXint) ((arg1)->click_count);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_moved_set(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","moved", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  if (arg1) (arg1)->moved = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_moved_get(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","moved", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  result = (FXbool) ((arg1)->moved);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_rect_set(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  FXRectangle *arg2 = (FXRectangle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","rect", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXRectangle, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRectangle *","rect", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXRectangle * >(argp2);
+  if (arg1) (arg1)->rect = *arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_rect_get(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXRectangle *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","rect", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  result = (FXRectangle *)& ((arg1)->rect);
+  vresult = FXRbGetRubyObj(result, "FXRectangle *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_synthetic_set(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","synthetic", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  if (arg1) (arg1)->synthetic = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_synthetic_get(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","synthetic", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  result = (FXbool) ((arg1)->synthetic);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_target_set(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  FXDragType arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","target", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXDragType","target", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXDragType >(val2);
+  if (arg1) (arg1)->target = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXEvent_target_get(int argc, VALUE *argv, VALUE self) {
+  FXEvent *arg1 = (FXEvent *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXDragType result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXEvent *","target", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXEvent * >(argp1);
+  result = (FXDragType) ((arg1)->target);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXChore;
+
+static swig_class SwigClassFXTimer;
+
+static swig_class SwigClassFXApp;
+
+SWIGINTERN VALUE
+_wrap_FXApp_onCmdQuit(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","onCmdQuit", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdQuit", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdQuit(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_onCmdDump(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","onCmdDump", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDump", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDump(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_onCmdHover(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","onCmdHover", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdHover", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdHover(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_copyright(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXApp_copyright();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXApp_allocate(VALUE self)
+#else
+_wrap_FXApp_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXApp);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXApp(int argc, VALUE *argv, VALUE self) {
+  FXchar *arg1 = (FXchar *) "Application" ;
+  FXchar *arg2 = (FXchar *) "FoxDefault" ;
+  FXApp *result = 0 ;
+  
+  if ((argc < 0) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  if (argc > 0) {
+    arg1 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  }
+  if (argc > 1) {
+    arg2 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  {
+    result = (FXApp *)new_FXApp((char const *)arg1,(char const *)arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getAppName(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getAppName", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXString *) &((FXApp const *)arg1)->getAppName();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getVendorName(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getVendorName", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXString *) &((FXApp const *)arg1)->getVendorName();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_openDisplay(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","openDisplay", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 0) {
+    arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  }
+  result = (bool)(arg1)->openDisplay((FXchar const *)arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_closeDisplay(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","closeDisplay", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (bool)(arg1)->closeDisplay();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getDisplay(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuval result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getDisplay", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXuval)FXApp_getDisplay((FXApp const *)arg1);
+  vresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_isInitialized(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","isInitialized", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (bool)((FXApp const *)arg1)->isInitialized();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getArgc(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getArgc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXint)((FXApp const *)arg1)->getArgc();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getArgv(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar **result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getArgv", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXchar **)((FXApp const *)arg1)->getArgv();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_hasInputMethodq___(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","hasInputMethod", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (bool)((FXApp const *)arg1)->hasInputMethod();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getDefaultVisual(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVisual *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getDefaultVisual", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXVisual *)((FXApp const *)arg1)->getDefaultVisual();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXVisual, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setDefaultVisual(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXVisual *arg2 = (FXVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setDefaultVisual", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXVisual, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVisual *","setDefaultVisual", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXVisual * >(argp2);
+  FXApp_setDefaultVisual(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getMonoVisual(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVisual *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getMonoVisual", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXVisual *)((FXApp const *)arg1)->getMonoVisual();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXVisual, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getRootWindow(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXRootWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getRootWindow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXRootWindow *)((FXApp const *)arg1)->getRootWindow();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXRootWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setRootWindow(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXRootWindow *arg2 = (FXRootWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setRootWindow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRootWindow *","setRootWindow", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXRootWindow * >(argp2);
+  (arg1)->setRootWindow(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_focusWindow(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getFocusWindow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXWindow *)((FXApp const *)arg1)->getFocusWindow();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getCursorWindow(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getCursorWindow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXWindow *)((FXApp const *)arg1)->getCursorWindow();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_activeWindow(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getActiveWindow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXWindow *)((FXApp const *)arg1)->getActiveWindow();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getPopupWindow(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPopup *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getPopupWindow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXPopup *)((FXApp const *)arg1)->getPopupWindow();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXPopup, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_findWindowWithId(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXID arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","findWindowWithId", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = int_to_fxid(argv[0]);
+  result = (FXWindow *)((FXApp const *)arg1)->findWindowWithId(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_findWindowAt(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXID arg4 = (FXID) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","findWindowAt", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = int_to_fxid(argv[2]);
+  }
+  result = (FXWindow *)((FXApp const *)arg1)->findWindowAt(arg2,arg3,arg4);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_addTimeout(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  FXuint arg4 = (FXuint) 1000 ;
+  void *arg5 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res5 ;
+  
+  if ((argc < 2) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","addTimeout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","addTimeout", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    res5 = SWIG_ConvertPtr(argv[3],SWIG_as_voidptrptr(&arg5), 0, 0);
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "void *","addTimeout", 5, argv[3] )); 
+    }
+  }
+  (arg1)->addTimeout(arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_removeTimeout(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","removeTimeout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","removeTimeout", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  (arg1)->removeTimeout(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_hasTimeoutq___(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","hasTimeout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","hasTimeout", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  result = (bool)((FXApp const *)arg1)->hasTimeout(arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_remainingTimeout(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","remainingTimeout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","remainingTimeout", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  result = (FXuint)(arg1)->remainingTimeout(arg2,arg3);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_handleTimeouts(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","handleTimeouts", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  (arg1)->handleTimeouts();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_addChore(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","addChore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","addChore", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  if (argc > 2) {
+    res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","addChore", 4, argv[2] )); 
+    }
+  }
+  (arg1)->addChore(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_removeChore(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","removeChore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","removeChore", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  (arg1)->removeChore(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_hasChoreq___(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","hasChore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","hasChore", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  result = (bool)((FXApp const *)arg1)->hasChore(arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_addSignal(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  FXObject *arg3 = (FXObject *) 0 ;
+  FXSelector arg4 ;
+  FXbool arg5 = (FXbool) 0 ;
+  FXuint arg6 = (FXuint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 3) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","addSignal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = argv[0];
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXObject *","addSignal", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXObject * >(argp3);
+  arg4 = NUM2UINT(argv[2]);
+  if (argc > 3) {
+    arg5 = to_FXbool(argv[3]);
+  }
+  if (argc > 4) {
+    arg6 = NUM2UINT(argv[4]);
+  }
+  FXApp_addSignal(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_removeSignal(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","removeSignal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = argv[0];
+  FXApp_removeSignal(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_addInput(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  FXuint arg3 ;
+  FXObject *arg4 = (FXObject *) 0 ;
+  FXSelector arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","addInput", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = argv[0];
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXObject *","addInput", 4, argv[2] )); 
+  }
+  arg4 = reinterpret_cast< FXObject * >(argp4);
+  arg5 = NUM2UINT(argv[3]);
+  result = (bool)FXApp_addInput(arg1,arg2,arg3,arg4,arg5);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_removeInput(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","removeInput", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = argv[0];
+  arg3 = NUM2UINT(argv[1]);
+  result = (bool)FXApp_removeInput(arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getKeyState(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getKeyState", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  result = (bool)((FXApp const *)arg1)->getKeyState(arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_peekEvent(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","peekEvent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (bool)(arg1)->peekEvent();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_isModal(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","isModal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","isModal", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  result = (bool)((FXApp const *)arg1)->isModal(arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getModalWindow(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getModalWindow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXWindow *)((FXApp const *)arg1)->getModalWindow();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getModality(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXModality result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getModality", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXModality)((FXApp const *)arg1)->getModality();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_stop(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXint arg2 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","stop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2INT(argv[0]);
+  }
+  (arg1)->stop(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_stopModal__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXint arg3 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","stopModal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","stopModal", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  (arg1)->stopModal(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_stopModal__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXint arg2 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","stopModal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2INT(argv[0]);
+  }
+  (arg1)->stopModal(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXApp_stopModal(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 4) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 1) && (argc <= 2)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      if (argc <= 1) {
+        return _wrap_FXApp_stopModal__SWIG_1(nargs, args, self);
+      }
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXApp_stopModal__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if ((argc >= 2) && (argc <= 3)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXWindow, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_FXApp_stopModal__SWIG_0(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          return _wrap_FXApp_stopModal__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXApp.stopModal", 
+    "    void FXApp.stopModal(FXWindow *window, FXint value)\n"
+    "    void FXApp.stopModal(FXint value)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_forceRefresh(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","forceRefresh", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  (arg1)->forceRefresh();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_refresh(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","refresh", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  (arg1)->refresh();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_flush(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  bool arg2 = (bool) false ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","flush", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","flush", 2, argv[0] ));
+    } 
+    arg2 = static_cast< bool >(val2);
+  }
+  (arg1)->flush(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_repaint(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","repaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  (arg1)->repaint();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_reg(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXRegistry *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","reg", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXRegistry *) &(arg1)->reg();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXRegistry, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_registerDragType(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXDragType result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","registerDragType", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  result = (FXDragType)((FXApp const *)arg1)->registerDragType((FXString const &)*arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getDragTypeName(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXDragType arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getDragTypeName", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXDragType","getDragTypeName", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXDragType >(val2);
+  result = ((FXApp const *)arg1)->getDragTypeName(arg2);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getDragWindow(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getDragWindow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXWindow *)((FXApp const *)arg1)->getDragWindow();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_beep(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","beep", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  (arg1)->beep();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_instance(int argc, VALUE *argv, VALUE self) {
+  FXApp *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (FXApp *)FXApp::instance();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXApp, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setNormalFont(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setNormalFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setNormalFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  FXApp_setNormalFont(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getNormalFont(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getNormalFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXFont *)((FXApp const *)arg1)->getNormalFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_beginWaitCursor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","beginWaitCursor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  (arg1)->beginWaitCursor();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_endWaitCursor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","endWaitCursor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  (arg1)->endWaitCursor();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setWaitCursor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXCursor *arg2 = (FXCursor *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setWaitCursor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXCursor, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXCursor *","setWaitCursor", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXCursor * >(argp2);
+  FXApp_setWaitCursor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getWaitCursor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXCursor *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getWaitCursor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXCursor *)((FXApp const *)arg1)->getWaitCursor();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXCursor, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getDefaultCursor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXDefaultCursor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  FXCursor *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getDefaultCursor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXDefaultCursor","getDefaultCursor", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXDefaultCursor >(val2);
+  result = (FXCursor *)((FXApp const *)arg1)->getDefaultCursor(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXCursor, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setDefaultCursor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXDefaultCursor arg2 ;
+  FXCursor *arg3 = (FXCursor *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setDefaultCursor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXDefaultCursor","setDefaultCursor", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXDefaultCursor >(val2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXCursor, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXCursor *","setDefaultCursor", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXCursor * >(argp3);
+  FXApp_setDefaultCursor(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_writeWindow(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXStream *arg2 = 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","writeWindow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","writeWindow", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","writeWindow", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","writeWindow", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  result = (FXbool)(arg1)->writeWindow(*arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_readWindow(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXStream *arg2 = 0 ;
+  FXWindow **arg3 = 0 ;
+  FXWindow *arg4 = (FXWindow *) 0 ;
+  FXWindow *arg5 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","readWindow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","readWindow", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","readWindow", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_p_FXWindow,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *&","readWindow", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXWindow *&","readWindow", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXWindow ** >(argp3);
+  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXWindow *","readWindow", 4, argv[2] )); 
+  }
+  arg4 = reinterpret_cast< FXWindow * >(argp4);
+  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res5)) {
+    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXWindow *","readWindow", 5, argv[3] )); 
+  }
+  arg5 = reinterpret_cast< FXWindow * >(argp5);
+  {
+    if (!arg5) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = (FXWindow *)FXApp_readWindow(arg1,*arg2,*arg3,arg4,arg5);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_mutex(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMutex *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","mutex", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXMutex *) &(arg1)->mutex();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMutex, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setTranslator(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXTranslator *arg2 = (FXTranslator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setTranslator", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTranslator, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTranslator *","setTranslator", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTranslator * >(argp2);
+  (arg1)->setTranslator(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getTranslator(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTranslator *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getTranslator", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXTranslator *)((FXApp const *)arg1)->getTranslator();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXTranslator, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getTypingSpeed(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getTypingSpeed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXuint)((FXApp const *)arg1)->getTypingSpeed();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getClickSpeed(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getClickSpeed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXuint)((FXApp const *)arg1)->getClickSpeed();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getScrollSpeed(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getScrollSpeed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXuint)((FXApp const *)arg1)->getScrollSpeed();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getScrollDelay(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getScrollDelay", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXuint)((FXApp const *)arg1)->getScrollDelay();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getBlinkSpeed(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getBlinkSpeed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXuint)((FXApp const *)arg1)->getBlinkSpeed();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getAnimSpeed(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getAnimSpeed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXuint)((FXApp const *)arg1)->getAnimSpeed();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getMenuPause(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getMenuPause", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXuint)((FXApp const *)arg1)->getMenuPause();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getTooltipPause(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getTooltipPause", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXuint)((FXApp const *)arg1)->getTooltipPause();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getTooltipTime(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getTooltipTime", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXuint)((FXApp const *)arg1)->getTooltipTime();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getDragDelta(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getDragDelta", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXint)((FXApp const *)arg1)->getDragDelta();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getWheelLines(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getWheelLines", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXint)((FXApp const *)arg1)->getWheelLines();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_scrollBarSize(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getScrollBarSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXint)((FXApp const *)arg1)->getScrollBarSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setTypingSpeed(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setTypingSpeed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setTypingSpeed(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setClickSpeed(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setClickSpeed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setClickSpeed(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setScrollSpeed(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setScrollSpeed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setScrollSpeed(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setScrollDelay(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setScrollDelay", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setScrollDelay(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setBlinkSpeed(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setBlinkSpeed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setBlinkSpeed(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setAnimSpeed(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setAnimSpeed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setAnimSpeed(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setMenuPause(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setMenuPause", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setMenuPause(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setTooltipPause(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setTooltipPause", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setTooltipPause(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setTooltipTime(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setTooltipTime", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setTooltipTime(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setDragDelta(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setDragDelta", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setDragDelta(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setWheelLines(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setWheelLines", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setWheelLines(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_scrollBarSizee___(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setScrollBarSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setScrollBarSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getBorderColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getBorderColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXColor)((FXApp const *)arg1)->getBorderColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getBaseColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getBaseColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXColor)((FXApp const *)arg1)->getBaseColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getHiliteColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getHiliteColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXColor)((FXApp const *)arg1)->getHiliteColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getShadowColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getShadowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXColor)((FXApp const *)arg1)->getShadowColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getBackColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXColor)((FXApp const *)arg1)->getBackColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getForeColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getForeColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXColor)((FXApp const *)arg1)->getForeColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getSelforeColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getSelforeColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXColor)((FXApp const *)arg1)->getSelforeColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getSelbackColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getSelbackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXColor)((FXApp const *)arg1)->getSelbackColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getTipforeColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getTipforeColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXColor)((FXApp const *)arg1)->getTipforeColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getTipbackColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getTipbackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXColor)((FXApp const *)arg1)->getTipbackColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getSelMenuTextColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getSelMenuTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXColor)((FXApp const *)arg1)->getSelMenuTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getSelMenuBackColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getSelMenuBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXColor)((FXApp const *)arg1)->getSelMenuBackColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setBorderColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setBorderColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setBorderColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setBaseColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setBaseColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setBaseColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setHiliteColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setHiliteColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setHiliteColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setShadowColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setShadowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setShadowColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setBackColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setForeColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setForeColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setForeColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setSelforeColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setSelforeColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelforeColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setSelbackColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setSelbackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelbackColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setTipforeColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setTipforeColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTipforeColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setTipbackColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setTipbackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTipbackColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setSelMenuTextColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setSelMenuTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelMenuTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setSelMenuBackColor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setSelMenuBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelMenuBackColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_dumpWidgets(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","dumpWidgets", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  ((FXApp const *)arg1)->dumpWidgets();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getWindowCount(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getWindowCount", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXuint)((FXApp const *)arg1)->getWindowCount();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_save(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXApp_save((FXApp const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_load(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXApp_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_create(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  FXApp_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_destroy(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  FXApp_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_detach(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  FXApp_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_run(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","run", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXint)FXApp_run(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_runOneEvent(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  bool arg2 = (bool) true ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","runOneEvent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","runOneEvent", 2, argv[0] ));
+    } 
+    arg2 = static_cast< bool >(val2);
+  }
+  result = (bool)FXApp_runOneEvent(arg1,arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_runUntil(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuint *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","runUntil", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_unsigned_int,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXuint &","runUntil", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXuint &","runUntil", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXuint * >(argp2);
+  result = (FXint)FXApp_runUntil(arg1,*arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_runWhileEvents(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","runWhileEvents", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXint)FXApp_runWhileEvents(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_runModalWhileEvents(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","runModalWhileEvents", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 0) {
+    res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","runModalWhileEvents", 2, argv[0] )); 
+    }
+    arg2 = reinterpret_cast< FXWindow * >(argp2);
+  }
+  result = (FXint)FXApp_runModalWhileEvents(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_runModal(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","runModal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXint)FXApp_runModal(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_runModalFor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","runModalFor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","runModalFor", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  result = (FXint)FXApp_runModalFor(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_runModalWhileShown(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","runModalWhileShown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","runModalWhileShown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  result = (FXint)FXApp_runModalWhileShown(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_runPopup(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","runPopup", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","runPopup", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  {
+    if (!arg2) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = (FXint)FXApp_runPopup(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_init(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  bool arg3 = (bool) true ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","init", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = argv[0];
+  if (argc > 1) {
+    ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+    if (!SWIG_IsOK(ecode3)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","init", 3, argv[1] ));
+    } 
+    arg3 = static_cast< bool >(val3);
+  }
+  FXApp_init(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_exit(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXint arg2 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","exit", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2INT(argv[0]);
+  }
+  FXApp_exit(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_threadsEnablede___(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setThreadsEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXApp_setThreadsEnabled(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_threadsEnabledq___(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","threadsEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXbool)FXApp_threadsEnabled((FXApp const *)arg1);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_setSleepTime(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","setSleepTime", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  FXApp_setSleepTime(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXApp_getSleepTime(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp const *","getSleepTime", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  result = (FXuint)FXApp_getSleepTime((FXApp const *)arg1);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXDataTarget;
+
+SWIGINTERN VALUE
+_wrap_FXDataTarget_onCmdValue(int argc, VALUE *argv, VALUE self) {
+  FXDataTarget *arg1 = (FXDataTarget *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDataTarget, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDataTarget *","onCmdValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDataTarget * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDataTarget_onUpdValue(int argc, VALUE *argv, VALUE self) {
+  FXDataTarget *arg1 = (FXDataTarget *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDataTarget, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDataTarget *","onUpdValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDataTarget * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDataTarget_onCmdOption(int argc, VALUE *argv, VALUE self) {
+  FXDataTarget *arg1 = (FXDataTarget *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDataTarget, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDataTarget *","onCmdOption", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDataTarget * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdOption", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdOption(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDataTarget_onUpdOption(int argc, VALUE *argv, VALUE self) {
+  FXDataTarget *arg1 = (FXDataTarget *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDataTarget, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDataTarget *","onUpdOption", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDataTarget * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdOption", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdOption(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXDataTarget_allocate(VALUE self)
+#else
+_wrap_FXDataTarget_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXDataTarget);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXDataTarget(int argc, VALUE *argv, VALUE self) {
+  VALUE arg1 = (VALUE) Qnil ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXDataTarget *result = 0 ;
+  
+  if ((argc < 0) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  if (argc > 0) {
+    arg1 = argv[0];
+  }
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXDataTarget", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  {
+    result = (FXDataTarget *)new_FXDataTarget(arg1,arg2,arg3);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDataTarget_setTarget(int argc, VALUE *argv, VALUE self) {
+  FXDataTarget *arg1 = (FXDataTarget *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDataTarget, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDataTarget *","setTarget", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDataTarget * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","setTarget", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  (arg1)->setTarget(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDataTarget_getTarget(int argc, VALUE *argv, VALUE self) {
+  FXDataTarget *arg1 = (FXDataTarget *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXObject *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDataTarget, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDataTarget const *","getTarget", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDataTarget * >(argp1);
+  result = (FXObject *)((FXDataTarget const *)arg1)->getTarget();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXObject, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDataTarget_setSelector(int argc, VALUE *argv, VALUE self) {
+  FXDataTarget *arg1 = (FXDataTarget *) 0 ;
+  FXSelector arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDataTarget, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDataTarget *","setSelector", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDataTarget * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setSelector(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDataTarget_getSelector(int argc, VALUE *argv, VALUE self) {
+  FXDataTarget *arg1 = (FXDataTarget *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXSelector result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDataTarget, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDataTarget const *","getSelector", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDataTarget * >(argp1);
+  result = (FXSelector)((FXDataTarget const *)arg1)->getSelector();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDataTarget_getType(int argc, VALUE *argv, VALUE self) {
+  FXDataTarget *arg1 = (FXDataTarget *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDataTarget, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDataTarget const *","getType", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDataTarget * >(argp1);
+  result = (FXuint)((FXDataTarget const *)arg1)->getType();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDataTarget_getValue(int argc, VALUE *argv, VALUE self) {
+  FXDataTarget *arg1 = (FXDataTarget *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDataTarget, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDataTarget const *","getValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDataTarget * >(argp1);
+  result = (VALUE)FXDataTarget_getValue((FXDataTarget const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDataTarget_setValue(int argc, VALUE *argv, VALUE self) {
+  FXDataTarget *arg1 = (FXDataTarget *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDataTarget, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDataTarget *","setValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDataTarget * >(argp1);
+  arg2 = argv[0];
+  FXDataTarget_setValue(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDataTarget_save(int argc, VALUE *argv, VALUE self) {
+  FXDataTarget *arg1 = (FXDataTarget *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDataTarget, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDataTarget const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDataTarget * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDataTarget_save((FXDataTarget const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDataTarget_load(int argc, VALUE *argv, VALUE self) {
+  FXDataTarget *arg1 = (FXDataTarget *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDataTarget, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDataTarget *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDataTarget * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDataTarget_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXDebugTarget;
+
+SWIGINTERN VALUE
+_wrap_FXDebugTarget_messageTypeName(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXDebugTarget_messageTypeName();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDebugTarget_onMessage(int argc, VALUE *argv, VALUE self) {
+  FXDebugTarget *arg1 = (FXDebugTarget *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDebugTarget, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDebugTarget *","onMessage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDebugTarget * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMessage", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onMessage(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXDebugTarget_allocate(VALUE self)
+#else
+_wrap_FXDebugTarget_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXDebugTarget);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXDebugTarget(int argc, VALUE *argv, VALUE self) {
+  FXDebugTarget *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXDebugTarget *)new_FXDebugTarget();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDebugTarget_save(int argc, VALUE *argv, VALUE self) {
+  FXDebugTarget *arg1 = (FXDebugTarget *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDebugTarget, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDebugTarget const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDebugTarget * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDebugTarget_save((FXDebugTarget const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDebugTarget_load(int argc, VALUE *argv, VALUE self) {
+  FXDebugTarget *arg1 = (FXDebugTarget *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDebugTarget, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDebugTarget *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDebugTarget * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDebugTarget_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXDelegator;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXDelegator_allocate(VALUE self)
+#else
+_wrap_FXDelegator_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXDelegator);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXDelegator(int argc, VALUE *argv, VALUE self) {
+  FXObject *arg1 = (FXObject *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXDelegator *result = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  if (argc > 0) {
+    res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXObject *","FXDelegator", 1, argv[0] )); 
+    }
+    arg1 = reinterpret_cast< FXObject * >(argp1);
+  }
+  {
+    result = (FXDelegator *)new_FXDelegator(arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDelegator_getDelegate(int argc, VALUE *argv, VALUE self) {
+  FXDelegator *arg1 = (FXDelegator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXObject *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDelegator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDelegator const *","getDelegate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDelegator * >(argp1);
+  result = (FXObject *)((FXDelegator const *)arg1)->getDelegate();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXObject, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDelegator_setDelegate(int argc, VALUE *argv, VALUE self) {
+  FXDelegator *arg1 = (FXDelegator *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDelegator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDelegator *","setDelegate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDelegator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","setDelegate", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  (arg1)->setDelegate(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDelegator_save(int argc, VALUE *argv, VALUE self) {
+  FXDelegator *arg1 = (FXDelegator *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDelegator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDelegator const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDelegator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDelegator_save((FXDelegator const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDelegator_load(int argc, VALUE *argv, VALUE self) {
+  FXDelegator *arg1 = (FXDelegator *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDelegator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDelegator *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDelegator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDelegator_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXTranslator;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXTranslator_allocate(VALUE self)
+#else
+_wrap_FXTranslator_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXTranslator);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXTranslator(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTranslator *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXTranslator", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXTranslator *)new_FXTranslator(arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTranslator_getApp(int argc, VALUE *argv, VALUE self) {
+  FXTranslator *arg1 = (FXTranslator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXApp *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTranslator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTranslator const *","getApp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTranslator * >(argp1);
+  result = (FXApp *)((FXTranslator const *)arg1)->getApp();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXApp, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTranslator_setTextCodec(int argc, VALUE *argv, VALUE self) {
+  FXTranslator *arg1 = (FXTranslator *) 0 ;
+  FXTextCodec *arg2 = (FXTextCodec *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTranslator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTranslator *","setTextCodec", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTranslator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTextCodec, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTextCodec *","setTextCodec", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTextCodec * >(argp2);
+  (arg1)->setTextCodec(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTranslator_getTextCodec(int argc, VALUE *argv, VALUE self) {
+  FXTranslator *arg1 = (FXTranslator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTextCodec *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTranslator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTranslator const *","getTextCodec", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTranslator * >(argp1);
+  result = (FXTextCodec *)((FXTranslator const *)arg1)->getTextCodec();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXTextCodec, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTranslator_save(int argc, VALUE *argv, VALUE self) {
+  FXTranslator *arg1 = (FXTranslator *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTranslator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTranslator const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTranslator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTranslator_save((FXTranslator const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTranslator_load(int argc, VALUE *argv, VALUE self) {
+  FXTranslator *arg1 = (FXTranslator *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTranslator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTranslator *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTranslator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTranslator_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTranslator_tr(int argc, VALUE *argv, VALUE self) {
+  FXTranslator *arg1 = (FXTranslator *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  FXchar *arg4 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTranslator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTranslator const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTranslator * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  if (argc > 2) {
+    arg4 = NIL_P(argv[2]) ? 0 : StringValuePtr(argv[2]);
+  }
+  result = (FXchar *)FXTranslator_tr((FXTranslator const *)arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXDict;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXDict_allocate(VALUE self)
+#else
+_wrap_FXDict_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXDict);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXDict(int argc, VALUE *argv, VALUE self) {
+  FXDict *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXDict *)new_FXDict();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXDict.getTotalSize
+
+  call-seq:
+    getTotalSize -> FXint
+
+Size or Length of the FXDict.
+*/
+SWIGINTERN VALUE
+_wrap_FXDict_getTotalSize(int argc, VALUE *argv, VALUE self) {
+  FXDict *arg1 = (FXDict *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDict const *","size", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDict * >(argp1);
+  result = (FXint)((FXDict const *)arg1)->size();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXDict.setTotalSize
+
+  call-seq:
+    setTotalSize(m)
+
+Size or Length of the FXDict.
+*/
+SWIGINTERN VALUE
+_wrap_FXDict_setTotalSize(int argc, VALUE *argv, VALUE self) {
+  FXDict *arg1 = (FXDict *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDict *","size", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDict * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->size(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDict_length(int argc, VALUE *argv, VALUE self) {
+  FXDict *arg1 = (FXDict *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDict const *","no", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDict * >(argp1);
+  result = (FXint)((FXDict const *)arg1)->no();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDict_remove(int argc, VALUE *argv, VALUE self) {
+  FXDict *arg1 = (FXDict *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDict *","remove", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDict * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  result = (void *)(arg1)->remove((FXchar const *)arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDict_key(int argc, VALUE *argv, VALUE self) {
+  FXDict *arg1 = (FXDict *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDict const *","key", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDict * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  result = (FXchar *)((FXDict const *)arg1)->key(arg2);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDict_mark(int argc, VALUE *argv, VALUE self) {
+  FXDict *arg1 = (FXDict *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDict const *","mark", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDict * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  result = (bool)((FXDict const *)arg1)->mark(arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXDict.first
+
+  call-seq:
+    first -> FXint
+
+Return the first element in FXDict.
+*/
+SWIGINTERN VALUE
+_wrap_FXDict_first(int argc, VALUE *argv, VALUE self) {
+  FXDict *arg1 = (FXDict *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDict const *","first", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDict * >(argp1);
+  result = (FXint)((FXDict const *)arg1)->first();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXDict.last
+
+  call-seq:
+    last -> FXint
+
+Return the last element in FXDict.
+*/
+SWIGINTERN VALUE
+_wrap_FXDict_last(int argc, VALUE *argv, VALUE self) {
+  FXDict *arg1 = (FXDict *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDict const *","last", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDict * >(argp1);
+  result = (FXint)((FXDict const *)arg1)->last();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDict_next(int argc, VALUE *argv, VALUE self) {
+  FXDict *arg1 = (FXDict *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDict const *","next", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDict * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)((FXDict const *)arg1)->next(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDict_prev(int argc, VALUE *argv, VALUE self) {
+  FXDict *arg1 = (FXDict *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDict const *","prev", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDict * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)((FXDict const *)arg1)->prev(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDict_clear(int argc, VALUE *argv, VALUE self) {
+  FXDict *arg1 = (FXDict *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDict *","clear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDict * >(argp1);
+  (arg1)->clear();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDict_has_keyq___(int argc, VALUE *argv, VALUE self) {
+  FXDict *arg1 = (FXDict *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDict const *","has_key", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDict * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  result = (bool)FXDict_has_key((FXDict const *)arg1,(char const *)arg2);
+  vresult = (result ? Qtrue : Qfalse);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDict_save(int argc, VALUE *argv, VALUE self) {
+  FXDict *arg1 = (FXDict *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDict const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDict * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDict_save((FXDict const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDict_load(int argc, VALUE *argv, VALUE self) {
+  FXDict *arg1 = (FXDict *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDict *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDict * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDict_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXFileAssoc;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXFileAssoc_allocate(VALUE self)
+#else
+_wrap_FXFileAssoc_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXFileAssoc);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXFileAssoc(int argc, VALUE *argv, VALUE self) {
+  FXFileAssoc *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (FXFileAssoc *)new FXFileAssoc();
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileAssoc_command_set(int argc, VALUE *argv, VALUE self) {
+  FXFileAssoc *arg1 = (FXFileAssoc *) 0 ;
+  FXString arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileAssoc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileAssoc *","command", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileAssoc * >(argp1);
+  arg2 = to_FXString(argv[0]);
+  if (arg1) (arg1)->command = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileAssoc_command_get(int argc, VALUE *argv, VALUE self) {
+  FXFileAssoc *arg1 = (FXFileAssoc *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileAssoc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileAssoc *","command", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileAssoc * >(argp1);
+  result =  ((arg1)->command);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileAssoc_extension_set(int argc, VALUE *argv, VALUE self) {
+  FXFileAssoc *arg1 = (FXFileAssoc *) 0 ;
+  FXString arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileAssoc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileAssoc *","extension", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileAssoc * >(argp1);
+  arg2 = to_FXString(argv[0]);
+  if (arg1) (arg1)->extension = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileAssoc_extension_get(int argc, VALUE *argv, VALUE self) {
+  FXFileAssoc *arg1 = (FXFileAssoc *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileAssoc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileAssoc *","extension", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileAssoc * >(argp1);
+  result =  ((arg1)->extension);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileAssoc_mimetype_set(int argc, VALUE *argv, VALUE self) {
+  FXFileAssoc *arg1 = (FXFileAssoc *) 0 ;
+  FXString arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileAssoc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileAssoc *","mimetype", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileAssoc * >(argp1);
+  arg2 = to_FXString(argv[0]);
+  if (arg1) (arg1)->mimetype = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileAssoc_mimetype_get(int argc, VALUE *argv, VALUE self) {
+  FXFileAssoc *arg1 = (FXFileAssoc *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileAssoc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileAssoc *","mimetype", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileAssoc * >(argp1);
+  result =  ((arg1)->mimetype);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileAssoc_bigicon_set(int argc, VALUE *argv, VALUE self) {
+  FXFileAssoc *arg1 = (FXFileAssoc *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileAssoc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileAssoc *","bigicon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileAssoc * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","bigicon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  if (arg1) (arg1)->bigicon = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileAssoc_bigicon_get(int argc, VALUE *argv, VALUE self) {
+  FXFileAssoc *arg1 = (FXFileAssoc *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileAssoc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileAssoc *","bigicon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileAssoc * >(argp1);
+  result = (FXIcon *) ((arg1)->bigicon);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileAssoc_bigiconopen_set(int argc, VALUE *argv, VALUE self) {
+  FXFileAssoc *arg1 = (FXFileAssoc *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileAssoc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileAssoc *","bigiconopen", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileAssoc * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","bigiconopen", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  if (arg1) (arg1)->bigiconopen = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileAssoc_bigiconopen_get(int argc, VALUE *argv, VALUE self) {
+  FXFileAssoc *arg1 = (FXFileAssoc *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileAssoc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileAssoc *","bigiconopen", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileAssoc * >(argp1);
+  result = (FXIcon *) ((arg1)->bigiconopen);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileAssoc_miniicon_set(int argc, VALUE *argv, VALUE self) {
+  FXFileAssoc *arg1 = (FXFileAssoc *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileAssoc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileAssoc *","miniicon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileAssoc * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","miniicon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  if (arg1) (arg1)->miniicon = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileAssoc_miniicon_get(int argc, VALUE *argv, VALUE self) {
+  FXFileAssoc *arg1 = (FXFileAssoc *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileAssoc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileAssoc *","miniicon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileAssoc * >(argp1);
+  result = (FXIcon *) ((arg1)->miniicon);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileAssoc_miniiconopen_set(int argc, VALUE *argv, VALUE self) {
+  FXFileAssoc *arg1 = (FXFileAssoc *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileAssoc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileAssoc *","miniiconopen", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileAssoc * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","miniiconopen", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  if (arg1) (arg1)->miniiconopen = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileAssoc_miniiconopen_get(int argc, VALUE *argv, VALUE self) {
+  FXFileAssoc *arg1 = (FXFileAssoc *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileAssoc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileAssoc *","miniiconopen", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileAssoc * >(argp1);
+  result = (FXIcon *) ((arg1)->miniiconopen);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileAssoc_dragtype_set(int argc, VALUE *argv, VALUE self) {
+  FXFileAssoc *arg1 = (FXFileAssoc *) 0 ;
+  FXDragType arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileAssoc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileAssoc *","dragtype", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileAssoc * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXDragType","dragtype", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXDragType >(val2);
+  if (arg1) (arg1)->dragtype = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileAssoc_dragtype_get(int argc, VALUE *argv, VALUE self) {
+  FXFileAssoc *arg1 = (FXFileAssoc *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXDragType result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileAssoc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileAssoc *","dragtype", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileAssoc * >(argp1);
+  result = (FXDragType) ((arg1)->dragtype);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileAssoc_flags_set(int argc, VALUE *argv, VALUE self) {
+  FXFileAssoc *arg1 = (FXFileAssoc *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileAssoc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileAssoc *","flags", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileAssoc * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (arg1) (arg1)->flags = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileAssoc_flags_get(int argc, VALUE *argv, VALUE self) {
+  FXFileAssoc *arg1 = (FXFileAssoc *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileAssoc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileAssoc *","flags", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileAssoc * >(argp1);
+  result = (FXuint) ((arg1)->flags);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXFileDict;
+
+SWIGINTERN VALUE
+_wrap_FXFileDict_defaultExecBinding(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXFileDict_defaultExecBinding();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDict_defaultDirBinding(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXFileDict_defaultDirBinding();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDict_defaultFileBinding(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXFileDict_defaultFileBinding();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXFileDict__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFileDict *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXFileDict", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXFileDict *)new_FXFileDict__SWIG_0(arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXFileDict_allocate(VALUE self)
+#else
+_wrap_FXFileDict_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXFileDict);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXFileDict__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXSettings *arg2 = (FXSettings *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXFileDict *result = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXFileDict", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXSettings *","FXFileDict", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXSettings * >(argp2);
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXFileDict *)new_FXFileDict__SWIG_1(arg1,arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXFileDict(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[2];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 2) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXFileDict__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXSettings, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_FXFileDict__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 2, "FXFileDict.new", 
+    "    FXFileDict.new(FXApp *a)\n"
+    "    FXFileDict.new(FXApp *a, FXSettings *db)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDict_setSettings(int argc, VALUE *argv, VALUE self) {
+  FXFileDict *arg1 = (FXFileDict *) 0 ;
+  FXSettings *arg2 = (FXSettings *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDict *","setSettings", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDict * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXSettings *","setSettings", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXSettings * >(argp2);
+  (arg1)->setSettings(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDict_getSettings(int argc, VALUE *argv, VALUE self) {
+  FXFileDict *arg1 = (FXFileDict *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXSettings *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDict const *","getSettings", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDict * >(argp1);
+  result = (FXSettings *)((FXFileDict const *)arg1)->getSettings();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSettings, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDict_setIconDict(int argc, VALUE *argv, VALUE self) {
+  FXFileDict *arg1 = (FXFileDict *) 0 ;
+  FXIconDict *arg2 = (FXIconDict *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDict *","setIconDict", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDict * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIconDict, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconDict *","setIconDict", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIconDict * >(argp2);
+  (arg1)->setIconDict(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDict_getIconDict(int argc, VALUE *argv, VALUE self) {
+  FXFileDict *arg1 = (FXFileDict *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIconDict *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDict const *","getIconDict", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDict * >(argp1);
+  result = (FXIconDict *)((FXFileDict const *)arg1)->getIconDict();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXIconDict, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDict_setIconPath(int argc, VALUE *argv, VALUE self) {
+  FXFileDict *arg1 = (FXFileDict *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDict *","setIconPath", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDict * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setIconPath((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDict_getIconPath(int argc, VALUE *argv, VALUE self) {
+  FXFileDict *arg1 = (FXFileDict *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDict const *","getIconPath", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDict * >(argp1);
+  result = (FXString *) &((FXFileDict const *)arg1)->getIconPath();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDict_replace(int argc, VALUE *argv, VALUE self) {
+  FXFileDict *arg1 = (FXFileDict *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFileAssoc *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDict *","replace", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDict * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  result = (FXFileAssoc *)(arg1)->replace((FXchar const *)arg2,(FXchar const *)arg3);
+  vresult = FXRbGetRubyObj(result, "FXFileAssoc *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDict_remove(int argc, VALUE *argv, VALUE self) {
+  FXFileDict *arg1 = (FXFileDict *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFileAssoc *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDict *","remove", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDict * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  result = (FXFileAssoc *)(arg1)->remove((FXchar const *)arg2);
+  vresult = FXRbGetRubyObj(result, "FXFileAssoc *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXFileDict.find
+
+  call-seq:
+    find(ext) -> FXFileAssoc
+
+Find an element in the class.
+*/
+SWIGINTERN VALUE
+_wrap_FXFileDict_find(int argc, VALUE *argv, VALUE self) {
+  FXFileDict *arg1 = (FXFileDict *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFileAssoc *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDict *","find", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDict * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  result = (FXFileAssoc *)(arg1)->find((FXchar const *)arg2);
+  vresult = FXRbGetRubyObj(result, "FXFileAssoc *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDict_save(int argc, VALUE *argv, VALUE self) {
+  FXFileDict *arg1 = (FXFileDict *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDict const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDict * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXFileDict_save((FXFileDict const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDict_load(int argc, VALUE *argv, VALUE self) {
+  FXFileDict *arg1 = (FXFileDict *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDict *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDict * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXFileDict_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDict_findFileBinding(int argc, VALUE *argv, VALUE self) {
+  FXFileDict *arg1 = (FXFileDict *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFileAssoc *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDict *","findFileBinding", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDict * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  result = (FXFileAssoc *)FXFileDict_findFileBinding(arg1,(char const *)arg2);
+  vresult = FXRbGetRubyObj(result, "FXFileAssoc *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDict_findDirBinding(int argc, VALUE *argv, VALUE self) {
+  FXFileDict *arg1 = (FXFileDict *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFileAssoc *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDict *","findDirBinding", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDict * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  result = (FXFileAssoc *)FXFileDict_findDirBinding(arg1,(char const *)arg2);
+  vresult = FXRbGetRubyObj(result, "FXFileAssoc *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDict_findExecBinding(int argc, VALUE *argv, VALUE self) {
+  FXFileDict *arg1 = (FXFileDict *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFileAssoc *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDict *","findExecBinding", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDict * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  result = (FXFileAssoc *)FXFileDict_findExecBinding(arg1,(char const *)arg2);
+  vresult = FXRbGetRubyObj(result, "FXFileAssoc *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXIconDict;
+
+SWIGINTERN VALUE
+_wrap_FXIconDict_defaultIconPath(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXIconDict_defaultIconPath();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXIconDict_allocate(VALUE self)
+#else
+_wrap_FXIconDict_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXIconDict);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXIconDict(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXString const &arg2_defvalue = FXIconDict::defaultIconPath ;
+  FXString *arg2 = (FXString *) &arg2_defvalue ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXIconDict *result = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXIconDict", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    p2 = to_FXString(argv[1]); arg2 = &p2;
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXIconDict *)new_FXIconDict(arg1,(FXString const &)*arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconDict_iconSourcee___(int argc, VALUE *argv, VALUE self) {
+  FXIconDict *arg1 = (FXIconDict *) 0 ;
+  FXIconSource *arg2 = (FXIconSource *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconDict *","setIconSource", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconDict * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIconSource, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconSource *","setIconSource", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIconSource * >(argp2);
+  (arg1)->setIconSource(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconDict_iconSource(int argc, VALUE *argv, VALUE self) {
+  FXIconDict *arg1 = (FXIconDict *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIconSource *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconDict const *","getIconSource", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconDict * >(argp1);
+  result = (FXIconSource *)((FXIconDict const *)arg1)->getIconSource();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXIconSource, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconDict_iconPathe___(int argc, VALUE *argv, VALUE self) {
+  FXIconDict *arg1 = (FXIconDict *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconDict *","setIconPath", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconDict * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setIconPath((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconDict_iconPath(int argc, VALUE *argv, VALUE self) {
+  FXIconDict *arg1 = (FXIconDict *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconDict const *","getIconPath", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconDict * >(argp1);
+  result = (FXString *) &((FXIconDict const *)arg1)->getIconPath();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXIconDict.insert
+
+  call-seq:
+    insert(name) -> FXIcon *
+
+Insert one or more new elements in the FXIconDict.
+*/
+SWIGINTERN VALUE
+_wrap_FXIconDict_insert(int argc, VALUE *argv, VALUE self) {
+  FXIconDict *arg1 = (FXIconDict *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconDict *","insert", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconDict * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  result = (FXIcon *)(arg1)->insert((FXchar const *)arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconDict_remove(int argc, VALUE *argv, VALUE self) {
+  FXIconDict *arg1 = (FXIconDict *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconDict *","remove", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconDict * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  result = (FXIcon *)(arg1)->remove((FXchar const *)arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXIconDict.find
+
+  call-seq:
+    find(name) -> FXIcon *
+
+Find an element in the class.
+*/
+SWIGINTERN VALUE
+_wrap_FXIconDict_find(int argc, VALUE *argv, VALUE self) {
+  FXIconDict *arg1 = (FXIconDict *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconDict *","find", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconDict * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  result = (FXIcon *)(arg1)->find((FXchar const *)arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXStringDict;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXStringDict_allocate(VALUE self)
+#else
+_wrap_FXStringDict_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXStringDict);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXStringDict(int argc, VALUE *argv, VALUE self) {
+  FXStringDict *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXStringDict *)new_FXStringDict();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXStringDict.insert
+
+  call-seq:
+    insert(ky, str, mrk=False) -> FXchar const *
+
+Insert one or more new elements in the FXStringDict.
+*/
+SWIGINTERN VALUE
+_wrap_FXStringDict_insert(int argc, VALUE *argv, VALUE self) {
+  FXStringDict *arg1 = (FXStringDict *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  bool arg4 = (bool) false ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val4 ;
+  int ecode4 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStringDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStringDict *","insert", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStringDict * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  if (argc > 2) {
+    ecode4 = SWIG_AsVal_bool(argv[2], &val4);
+    if (!SWIG_IsOK(ecode4)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","insert", 4, argv[2] ));
+    } 
+    arg4 = static_cast< bool >(val4);
+  }
+  result = (FXchar *)(arg1)->insert((FXchar const *)arg2,(FXchar const *)arg3,arg4);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStringDict_replace(int argc, VALUE *argv, VALUE self) {
+  FXStringDict *arg1 = (FXStringDict *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  bool arg4 = (bool) false ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val4 ;
+  int ecode4 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStringDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStringDict *","replace", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStringDict * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  if (argc > 2) {
+    ecode4 = SWIG_AsVal_bool(argv[2], &val4);
+    if (!SWIG_IsOK(ecode4)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","replace", 4, argv[2] ));
+    } 
+    arg4 = static_cast< bool >(val4);
+  }
+  result = (FXchar *)(arg1)->replace((FXchar const *)arg2,(FXchar const *)arg3,arg4);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStringDict_remove(int argc, VALUE *argv, VALUE self) {
+  FXStringDict *arg1 = (FXStringDict *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStringDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStringDict *","remove", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStringDict * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  result = (FXchar *)(arg1)->remove((FXchar const *)arg2);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXStringDict.find
+
+  call-seq:
+    find(ky) -> FXchar const *
+
+Find an element in the class.
+*/
+SWIGINTERN VALUE
+_wrap_FXStringDict_find(int argc, VALUE *argv, VALUE self) {
+  FXStringDict *arg1 = (FXStringDict *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStringDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStringDict const *","find", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStringDict * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  result = (FXchar *)((FXStringDict const *)arg1)->find((FXchar const *)arg2);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStringDict_data(int argc, VALUE *argv, VALUE self) {
+  FXStringDict *arg1 = (FXStringDict *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStringDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStringDict const *","data", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStringDict * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  result = (FXchar *)((FXStringDict const *)arg1)->data(arg2);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStringDict_save(int argc, VALUE *argv, VALUE self) {
+  FXStringDict *arg1 = (FXStringDict *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStringDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStringDict const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStringDict * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXStringDict_save((FXStringDict const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStringDict_load(int argc, VALUE *argv, VALUE self) {
+  FXStringDict *arg1 = (FXStringDict *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStringDict, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStringDict *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStringDict * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXStringDict_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXSettings;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXSettings_allocate(VALUE self)
+#else
+_wrap_FXSettings_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXSettings);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSettings(int argc, VALUE *argv, VALUE self) {
+  FXSettings *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXSettings *)new_FXSettings();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSettings_parseFile(int argc, VALUE *argv, VALUE self) {
+  FXSettings *arg1 = (FXSettings *) 0 ;
+  FXString *arg2 = 0 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSettings *","parseFile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSettings * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","parseFile", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  result = (bool)(arg1)->parseFile((FXString const &)*arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSettings_unparseFile(int argc, VALUE *argv, VALUE self) {
+  FXSettings *arg1 = (FXSettings *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSettings *","unparseFile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSettings * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  result = (bool)(arg1)->unparseFile((FXString const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSettings_data(int argc, VALUE *argv, VALUE self) {
+  FXSettings *arg1 = (FXSettings *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXStringDict *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSettings const *","data", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSettings * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  result = (FXStringDict *)((FXSettings const *)arg1)->data(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXStringDict, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXSettings.find
+
+  call-seq:
+    find(section) -> FXStringDict
+
+Find an element in the class.
+*/
+SWIGINTERN VALUE
+_wrap_FXSettings_find(int argc, VALUE *argv, VALUE self) {
+  FXSettings *arg1 = (FXSettings *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXStringDict *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSettings const *","find", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSettings * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  result = (FXStringDict *)((FXSettings const *)arg1)->find((FXchar const *)arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXStringDict, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSettings_readStringEntry(int argc, VALUE *argv, VALUE self) {
+  FXSettings *arg1 = (FXSettings *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  FXchar *arg4 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSettings *","readStringEntry", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSettings * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  if (argc > 2) {
+    arg4 = NIL_P(argv[2]) ? 0 : StringValuePtr(argv[2]);
+  }
+  result = (FXchar *)(arg1)->readStringEntry((FXchar const *)arg2,(FXchar const *)arg3,(FXchar const *)arg4);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSettings_readIntEntry(int argc, VALUE *argv, VALUE self) {
+  FXSettings *arg1 = (FXSettings *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSettings *","readIntEntry", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSettings * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  result = (FXint)(arg1)->readIntEntry((FXchar const *)arg2,(FXchar const *)arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSettings_readUnsignedEntry(int argc, VALUE *argv, VALUE self) {
+  FXSettings *arg1 = (FXSettings *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSettings *","readUnsignedEntry", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSettings * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2UINT(argv[2]);
+  }
+  result = (FXuint)(arg1)->readUnsignedEntry((FXchar const *)arg2,(FXchar const *)arg3,arg4);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSettings_readRealEntry(int argc, VALUE *argv, VALUE self) {
+  FXSettings *arg1 = (FXSettings *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  FXdouble arg4 = (FXdouble) 0.0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSettings *","readRealEntry", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSettings * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  if (argc > 2) {
+    ecode4 = SWIG_AsVal_double(argv[2], &val4);
+    if (!SWIG_IsOK(ecode4)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","readRealEntry", 4, argv[2] ));
+    } 
+    arg4 = static_cast< FXdouble >(val4);
+  }
+  result = (FXdouble)(arg1)->readRealEntry((FXchar const *)arg2,(FXchar const *)arg3,arg4);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSettings_readColorEntry(int argc, VALUE *argv, VALUE self) {
+  FXSettings *arg1 = (FXSettings *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  FXColor arg4 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSettings *","readColorEntry", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSettings * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  if (argc > 2) {
+    arg4 = to_FXColor(argv[2]);
+  }
+  result = (FXColor)(arg1)->readColorEntry((FXchar const *)arg2,(FXchar const *)arg3,arg4);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSettings_writeStringEntry(int argc, VALUE *argv, VALUE self) {
+  FXSettings *arg1 = (FXSettings *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  FXchar *arg4 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSettings *","writeStringEntry", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSettings * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  arg4 = NIL_P(argv[2]) ? 0 : StringValuePtr(argv[2]);
+  result = (bool)(arg1)->writeStringEntry((FXchar const *)arg2,(FXchar const *)arg3,(FXchar const *)arg4);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSettings_writeIntEntry(int argc, VALUE *argv, VALUE self) {
+  FXSettings *arg1 = (FXSettings *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSettings *","writeIntEntry", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSettings * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  result = (bool)(arg1)->writeIntEntry((FXchar const *)arg2,(FXchar const *)arg3,arg4);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSettings_writeUnsignedEntry(int argc, VALUE *argv, VALUE self) {
+  FXSettings *arg1 = (FXSettings *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  FXuint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSettings *","writeUnsignedEntry", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSettings * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  arg4 = NUM2UINT(argv[2]);
+  result = (bool)(arg1)->writeUnsignedEntry((FXchar const *)arg2,(FXchar const *)arg3,arg4);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSettings_writeRealEntry(int argc, VALUE *argv, VALUE self) {
+  FXSettings *arg1 = (FXSettings *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  FXdouble arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSettings *","writeRealEntry", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSettings * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  ecode4 = SWIG_AsVal_double(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","writeRealEntry", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXdouble >(val4);
+  result = (bool)(arg1)->writeRealEntry((FXchar const *)arg2,(FXchar const *)arg3,arg4);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSettings_writeColorEntry(int argc, VALUE *argv, VALUE self) {
+  FXSettings *arg1 = (FXSettings *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  FXColor arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSettings *","writeColorEntry", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSettings * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  result = (bool)(arg1)->writeColorEntry((FXchar const *)arg2,(FXchar const *)arg3,arg4);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSettings_deleteEntry(int argc, VALUE *argv, VALUE self) {
+  FXSettings *arg1 = (FXSettings *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSettings *","deleteEntry", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSettings * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  result = (bool)(arg1)->deleteEntry((FXchar const *)arg2,(FXchar const *)arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSettings_existingEntry(int argc, VALUE *argv, VALUE self) {
+  FXSettings *arg1 = (FXSettings *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSettings *","existingEntry", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSettings * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  result = (bool)(arg1)->existingEntry((FXchar const *)arg2,(FXchar const *)arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSettings_deleteSection(int argc, VALUE *argv, VALUE self) {
+  FXSettings *arg1 = (FXSettings *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSettings *","deleteSection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSettings * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  result = (bool)(arg1)->deleteSection((FXchar const *)arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSettings_existingSection(int argc, VALUE *argv, VALUE self) {
+  FXSettings *arg1 = (FXSettings *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSettings *","existingSection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSettings * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  result = (bool)(arg1)->existingSection((FXchar const *)arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSettings_clear(int argc, VALUE *argv, VALUE self) {
+  FXSettings *arg1 = (FXSettings *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSettings *","clear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSettings * >(argp1);
+  result = (FXbool)(arg1)->clear();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSettings_setModified(int argc, VALUE *argv, VALUE self) {
+  FXSettings *arg1 = (FXSettings *) 0 ;
+  bool arg2 = (bool) true ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSettings *","setModified", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSettings * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setModified", 2, argv[0] ));
+    } 
+    arg2 = static_cast< bool >(val2);
+  }
+  (arg1)->setModified(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSettings_isModified(int argc, VALUE *argv, VALUE self) {
+  FXSettings *arg1 = (FXSettings *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSettings const *","isModified", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSettings * >(argp1);
+  result = (bool)((FXSettings const *)arg1)->isModified();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSettings_save(int argc, VALUE *argv, VALUE self) {
+  FXSettings *arg1 = (FXSettings *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSettings const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSettings * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXSettings_save((FXSettings const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSettings_load(int argc, VALUE *argv, VALUE self) {
+  FXSettings *arg1 = (FXSettings *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSettings, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSettings *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSettings * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXSettings_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXRegistry;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXRegistry_allocate(VALUE self)
+#else
+_wrap_FXRegistry_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXRegistry);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRegistry(int argc, VALUE *argv, VALUE self) {
+  FXString const &arg1_defvalue = FXString::null ;
+  FXString *arg1 = (FXString *) &arg1_defvalue ;
+  FXString const &arg2_defvalue = FXString::null ;
+  FXString *arg2 = (FXString *) &arg2_defvalue ;
+  SwigValueWrapper< FXString > p1 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXRegistry *result = 0 ;
+  
+  if ((argc < 0) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  if (argc > 0) {
+    p1 = to_FXString(argv[0]); arg1 = &p1;
+  }
+  if (argc > 1) {
+    p2 = to_FXString(argv[1]); arg2 = &p2;
+  }
+  {
+    result = (FXRegistry *)new_FXRegistry((FXString const &)*arg1,(FXString const &)*arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRegistry_read(int argc, VALUE *argv, VALUE self) {
+  FXRegistry *arg1 = (FXRegistry *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRegistry, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRegistry *","read", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRegistry * >(argp1);
+  result = (bool)(arg1)->read();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRegistry_write(int argc, VALUE *argv, VALUE self) {
+  FXRegistry *arg1 = (FXRegistry *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRegistry, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRegistry *","write", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRegistry * >(argp1);
+  result = (bool)(arg1)->write();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRegistry_getAppKey(int argc, VALUE *argv, VALUE self) {
+  FXRegistry *arg1 = (FXRegistry *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRegistry, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRegistry const *","getAppKey", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRegistry * >(argp1);
+  result = (FXString *) &((FXRegistry const *)arg1)->getAppKey();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRegistry_getVendorKey(int argc, VALUE *argv, VALUE self) {
+  FXRegistry *arg1 = (FXRegistry *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRegistry, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRegistry const *","getVendorKey", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRegistry * >(argp1);
+  result = (FXString *) &((FXRegistry const *)arg1)->getVendorKey();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRegistry_setAsciiMode(int argc, VALUE *argv, VALUE self) {
+  FXRegistry *arg1 = (FXRegistry *) 0 ;
+  bool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRegistry, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRegistry *","setAsciiMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRegistry * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setAsciiMode", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  (arg1)->setAsciiMode(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRegistry_getAsciiMode(int argc, VALUE *argv, VALUE self) {
+  FXRegistry *arg1 = (FXRegistry *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRegistry, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRegistry const *","getAsciiMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRegistry * >(argp1);
+  result = (bool)((FXRegistry const *)arg1)->getAsciiMode();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRegistry_save(int argc, VALUE *argv, VALUE self) {
+  FXRegistry *arg1 = (FXRegistry *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRegistry, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRegistry const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRegistry * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXRegistry_save((FXRegistry const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRegistry_load(int argc, VALUE *argv, VALUE self) {
+  FXRegistry *arg1 = (FXRegistry *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRegistry, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRegistry *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRegistry * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXRegistry_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXDocument;
+
+SWIGINTERN VALUE
+_wrap_FXDocument_onUpdTitle(int argc, VALUE *argv, VALUE self) {
+  FXDocument *arg1 = (FXDocument *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDocument, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDocument *","onUpdTitle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDocument * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdTitle", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdTitle(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDocument_onUpdFilename(int argc, VALUE *argv, VALUE self) {
+  FXDocument *arg1 = (FXDocument *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDocument, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDocument *","onUpdFilename", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDocument * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdFilename", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdFilename(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXDocument_allocate(VALUE self)
+#else
+_wrap_FXDocument_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXDocument);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXDocument(int argc, VALUE *argv, VALUE self) {
+  FXDocument *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXDocument *)new_FXDocument();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDocument_isModified(int argc, VALUE *argv, VALUE self) {
+  FXDocument *arg1 = (FXDocument *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDocument, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDocument const *","isModified", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDocument * >(argp1);
+  result = (FXbool)((FXDocument const *)arg1)->isModified();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDocument_setModified(int argc, VALUE *argv, VALUE self) {
+  FXDocument *arg1 = (FXDocument *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDocument, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDocument *","setModified", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDocument * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->setModified(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDocument_setTitle(int argc, VALUE *argv, VALUE self) {
+  FXDocument *arg1 = (FXDocument *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDocument, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDocument *","setTitle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDocument * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTitle((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDocument_getTitle(int argc, VALUE *argv, VALUE self) {
+  FXDocument *arg1 = (FXDocument *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDocument, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDocument const *","getTitle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDocument * >(argp1);
+  result = (FXString *) &((FXDocument const *)arg1)->getTitle();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDocument_setFilename(int argc, VALUE *argv, VALUE self) {
+  FXDocument *arg1 = (FXDocument *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDocument, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDocument *","setFilename", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDocument * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setFilename((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDocument_getFilename(int argc, VALUE *argv, VALUE self) {
+  FXDocument *arg1 = (FXDocument *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDocument, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDocument const *","getFilename", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDocument * >(argp1);
+  result = (FXString *) &((FXDocument const *)arg1)->getFilename();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDocument_save(int argc, VALUE *argv, VALUE self) {
+  FXDocument *arg1 = (FXDocument *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDocument, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDocument const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDocument * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDocument_save((FXDocument const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDocument_load(int argc, VALUE *argv, VALUE self) {
+  FXDocument *arg1 = (FXDocument *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDocument, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDocument *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDocument * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDocument_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXRecentFiles;
+
+SWIGINTERN VALUE
+_wrap_FXRecentFiles_onCmdClear(int argc, VALUE *argv, VALUE self) {
+  FXRecentFiles *arg1 = (FXRecentFiles *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRecentFiles, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRecentFiles *","onCmdClear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRecentFiles * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdClear", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdClear(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRecentFiles_onCmdFile(int argc, VALUE *argv, VALUE self) {
+  FXRecentFiles *arg1 = (FXRecentFiles *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRecentFiles, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRecentFiles *","onCmdFile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRecentFiles * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdFile", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdFile(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRecentFiles_onUpdFile(int argc, VALUE *argv, VALUE self) {
+  FXRecentFiles *arg1 = (FXRecentFiles *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRecentFiles, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRecentFiles *","onUpdFile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRecentFiles * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdFile", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdFile(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRecentFiles_onUpdAnyFiles(int argc, VALUE *argv, VALUE self) {
+  FXRecentFiles *arg1 = (FXRecentFiles *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRecentFiles, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRecentFiles *","onUpdAnyFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRecentFiles * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdAnyFiles", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdAnyFiles(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRecentFiles__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXRecentFiles *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXRecentFiles *)new_FXRecentFiles__SWIG_0();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRecentFiles__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXRecentFiles *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXRecentFiles", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXRecentFiles *)new_FXRecentFiles__SWIG_1(arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXRecentFiles_allocate(VALUE self)
+#else
+_wrap_FXRecentFiles_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXRecentFiles);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRecentFiles__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXString *arg2 = 0 ;
+  FXObject *arg3 = (FXObject *) 0 ;
+  FXSelector arg4 = (FXSelector) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXRecentFiles *result = 0 ;
+  
+  if ((argc < 2) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXRecentFiles", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXObject *","FXRecentFiles", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXObject * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXRecentFiles *)new_FXRecentFiles__SWIG_2(arg1,(FXString const &)*arg2,arg3,arg4);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXRecentFiles(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 4) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_FXRecentFiles__SWIG_0(nargs, args, self);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXRecentFiles__SWIG_1(nargs, args, self);
+    }
+  }
+  if ((argc >= 2) && (argc <= 4)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_new_FXRecentFiles__SWIG_2(nargs, args, self);
+        }
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXObject, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXRecentFiles__SWIG_2(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_new_FXRecentFiles__SWIG_2(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXRecentFiles.new", 
+    "    FXRecentFiles.new()\n"
+    "    FXRecentFiles.new(FXApp *a)\n"
+    "    FXRecentFiles.new(FXApp *a, FXString const &gp, FXObject *tgt, FXSelector sel)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRecentFiles_app(int argc, VALUE *argv, VALUE self) {
+  FXRecentFiles *arg1 = (FXRecentFiles *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXApp *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRecentFiles, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRecentFiles const *","getApp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRecentFiles * >(argp1);
+  result = (FXApp *)((FXRecentFiles const *)arg1)->getApp();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXApp, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRecentFiles_setMaxFiles(int argc, VALUE *argv, VALUE self) {
+  FXRecentFiles *arg1 = (FXRecentFiles *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRecentFiles, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRecentFiles *","setMaxFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRecentFiles * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setMaxFiles(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRecentFiles_getMaxFiles(int argc, VALUE *argv, VALUE self) {
+  FXRecentFiles *arg1 = (FXRecentFiles *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRecentFiles, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRecentFiles const *","getMaxFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRecentFiles * >(argp1);
+  result = (FXint)((FXRecentFiles const *)arg1)->getMaxFiles();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRecentFiles_setGroupName(int argc, VALUE *argv, VALUE self) {
+  FXRecentFiles *arg1 = (FXRecentFiles *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRecentFiles, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRecentFiles *","setGroupName", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRecentFiles * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setGroupName((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRecentFiles_getGroupName(int argc, VALUE *argv, VALUE self) {
+  FXRecentFiles *arg1 = (FXRecentFiles *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRecentFiles, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRecentFiles const *","getGroupName", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRecentFiles * >(argp1);
+  result = ((FXRecentFiles const *)arg1)->getGroupName();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRecentFiles_setTarget(int argc, VALUE *argv, VALUE self) {
+  FXRecentFiles *arg1 = (FXRecentFiles *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRecentFiles, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRecentFiles *","setTarget", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRecentFiles * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","setTarget", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  (arg1)->setTarget(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRecentFiles_getTarget(int argc, VALUE *argv, VALUE self) {
+  FXRecentFiles *arg1 = (FXRecentFiles *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXObject *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRecentFiles, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRecentFiles const *","getTarget", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRecentFiles * >(argp1);
+  result = (FXObject *)((FXRecentFiles const *)arg1)->getTarget();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXObject, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRecentFiles_setSelector(int argc, VALUE *argv, VALUE self) {
+  FXRecentFiles *arg1 = (FXRecentFiles *) 0 ;
+  FXSelector arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRecentFiles, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRecentFiles *","setSelector", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRecentFiles * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setSelector(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRecentFiles_getSelector(int argc, VALUE *argv, VALUE self) {
+  FXRecentFiles *arg1 = (FXRecentFiles *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXSelector result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRecentFiles, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRecentFiles const *","getSelector", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRecentFiles * >(argp1);
+  result = (FXSelector)((FXRecentFiles const *)arg1)->getSelector();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRecentFiles_getFile(int argc, VALUE *argv, VALUE self) {
+  FXRecentFiles *arg1 = (FXRecentFiles *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRecentFiles, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRecentFiles const *","getFile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRecentFiles * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = ((FXRecentFiles const *)arg1)->getFile(arg2);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRecentFiles_setFile(int argc, VALUE *argv, VALUE self) {
+  FXRecentFiles *arg1 = (FXRecentFiles *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRecentFiles, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRecentFiles *","setFile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRecentFiles * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  (arg1)->setFile(arg2,(FXString const &)*arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRecentFiles_appendFile(int argc, VALUE *argv, VALUE self) {
+  FXRecentFiles *arg1 = (FXRecentFiles *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRecentFiles, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRecentFiles *","appendFile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRecentFiles * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->appendFile((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRecentFiles_removeFile(int argc, VALUE *argv, VALUE self) {
+  FXRecentFiles *arg1 = (FXRecentFiles *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRecentFiles, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRecentFiles *","removeFile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRecentFiles * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->removeFile((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRecentFiles_clear(int argc, VALUE *argv, VALUE self) {
+  FXRecentFiles *arg1 = (FXRecentFiles *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRecentFiles, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRecentFiles *","clear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRecentFiles * >(argp1);
+  (arg1)->clear();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRecentFiles_save(int argc, VALUE *argv, VALUE self) {
+  FXRecentFiles *arg1 = (FXRecentFiles *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRecentFiles, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRecentFiles const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRecentFiles * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXRecentFiles_save((FXRecentFiles const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRecentFiles_load(int argc, VALUE *argv, VALUE self) {
+  FXRecentFiles *arg1 = (FXRecentFiles *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRecentFiles, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRecentFiles *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRecentFiles * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXRecentFiles_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXId;
+
+SWIGINTERN VALUE
+_wrap_FXId_getApp(int argc, VALUE *argv, VALUE self) {
+  FXId *arg1 = (FXId *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXApp *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXId, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXId const *","getApp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXId * >(argp1);
+  result = (FXApp *)((FXId const *)arg1)->getApp();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXApp, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXId_xid(int argc, VALUE *argv, VALUE self) {
+  FXId *arg1 = (FXId *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXID result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXId, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXId const *","id", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXId * >(argp1);
+  result = ((FXId const *)arg1)->id();
+  vresult = fxid_to_int(result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXId_createdq___(int argc, VALUE *argv, VALUE self) {
+  FXId *arg1 = (FXId *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXId, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXId const *","created", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXId * >(argp1);
+  result = (bool)FXId_created((FXId const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXId_setUserData(int argc, VALUE *argv, VALUE self) {
+  FXId *arg1 = (FXId *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXId, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXId *","setUserData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXId * >(argp1);
+  arg2 = argv[0];
+  FXId_setUserData(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXId_getUserData(int argc, VALUE *argv, VALUE self) {
+  FXId *arg1 = (FXId *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXId, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXId const *","getUserData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXId * >(argp1);
+  result = (VALUE)FXId_getUserData((FXId const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXId_save(int argc, VALUE *argv, VALUE self) {
+  FXId *arg1 = (FXId *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXId, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXId const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXId * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXId_save((FXId const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXId_load(int argc, VALUE *argv, VALUE self) {
+  FXId *arg1 = (FXId *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXId, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXId *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXId * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXId_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXId_create(int argc, VALUE *argv, VALUE self) {
+  FXId *arg1 = (FXId *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXId, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXId *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXId * >(argp1);
+  FXId_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXId_detach(int argc, VALUE *argv, VALUE self) {
+  FXId *arg1 = (FXId *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXId, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXId *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXId * >(argp1);
+  FXId_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXId_destroy(int argc, VALUE *argv, VALUE self) {
+  FXId *arg1 = (FXId *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXId, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXId *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXId * >(argp1);
+  FXId_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXCursor;
+
+SWIGINTERN VALUE
+_wrap_new_FXCursor__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXStockCursor arg2 = (FXStockCursor) CURSOR_ARROW ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  FXCursor *result = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXCursor", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    ecode2 = SWIG_AsVal_int(argv[1], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXStockCursor","FXCursor", 2, argv[1] ));
+    } 
+    arg2 = static_cast< FXStockCursor >(val2);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXCursor *)new_FXCursor__SWIG_0(arg1,arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXCursor__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuchar *arg2 = (FXuchar *) 0 ;
+  FXuchar *arg3 = (FXuchar *) 0 ;
+  FXint arg4 = (FXint) 32 ;
+  FXint arg5 = (FXint) 32 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXCursor *result = 0 ;
+  
+  if ((argc < 3) || (argc > 7)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXCursor", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXuchar const *","FXCursor", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXuchar * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXuchar const *","FXCursor", 3, argv[2] )); 
+  }
+  arg3 = reinterpret_cast< FXuchar * >(argp3);
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXCursor *)new_FXCursor__SWIG_1(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,arg4,arg5,arg6,arg7);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXCursor_allocate(VALUE self)
+#else
+_wrap_FXCursor_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXCursor);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXCursor__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXColor *arg2 = (FXColor *) 0 ;
+  FXint arg3 = (FXint) 32 ;
+  FXint arg4 = (FXint) 32 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXCursor *result = 0 ;
+  
+  if ((argc < 2) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXCursor", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_unsigned_int, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXColor const *","FXCursor", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXColor * >(argp2);
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXCursor *)new_FXCursor__SWIG_2(arg1,(unsigned int const *)arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXCursor(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[7];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 7) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 1) && (argc <= 2)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      if (argc <= 1) {
+        return _wrap_new_FXCursor__SWIG_0(nargs, args, self);
+      }
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_FXCursor__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if ((argc >= 2) && (argc <= 6)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_int, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_new_FXCursor__SWIG_2(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXCursor__SWIG_2(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXCursor__SWIG_2(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXCursor__SWIG_2(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                return _wrap_new_FXCursor__SWIG_2(nargs, args, self);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 3) && (argc <= 7)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_char, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXCursor__SWIG_1(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXCursor__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXCursor__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXCursor__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  return _wrap_new_FXCursor__SWIG_1(nargs, args, self);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 7, "FXCursor.new", 
+    "    FXCursor.new(FXApp *a, FXStockCursor curid)\n"
+    "    FXCursor.new(FXApp *a, FXuchar const *src, FXuchar const *msk, FXint w, FXint h, FXint hx, FXint hy)\n"
+    "    FXCursor.new(FXApp *a, FXColor const *pix, FXint w, FXint h, FXint hx, FXint hy)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCursor_getWidth(int argc, VALUE *argv, VALUE self) {
+  FXCursor *arg1 = (FXCursor *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCursor const *","getWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCursor * >(argp1);
+  result = (FXint)((FXCursor const *)arg1)->getWidth();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCursor_getHeight(int argc, VALUE *argv, VALUE self) {
+  FXCursor *arg1 = (FXCursor *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCursor const *","getHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCursor * >(argp1);
+  result = (FXint)((FXCursor const *)arg1)->getHeight();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCursor_setHotX(int argc, VALUE *argv, VALUE self) {
+  FXCursor *arg1 = (FXCursor *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCursor *","setHotX", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCursor * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setHotX(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCursor_getHotX(int argc, VALUE *argv, VALUE self) {
+  FXCursor *arg1 = (FXCursor *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCursor const *","getHotX", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCursor * >(argp1);
+  result = (FXint)((FXCursor const *)arg1)->getHotX();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCursor_setHotY(int argc, VALUE *argv, VALUE self) {
+  FXCursor *arg1 = (FXCursor *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCursor *","setHotY", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCursor * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setHotY(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCursor_getHotY(int argc, VALUE *argv, VALUE self) {
+  FXCursor *arg1 = (FXCursor *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCursor const *","getHotY", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCursor * >(argp1);
+  result = (FXint)((FXCursor const *)arg1)->getHotY();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCursor_isColor(int argc, VALUE *argv, VALUE self) {
+  FXCursor *arg1 = (FXCursor *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCursor const *","isColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCursor * >(argp1);
+  result = (bool)((FXCursor const *)arg1)->isColor();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCursor_save(int argc, VALUE *argv, VALUE self) {
+  FXCursor *arg1 = (FXCursor *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCursor const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCursor * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXCursor_save((FXCursor const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCursor_load(int argc, VALUE *argv, VALUE self) {
+  FXCursor *arg1 = (FXCursor *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCursor *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCursor * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXCursor_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCursor_create(int argc, VALUE *argv, VALUE self) {
+  FXCursor *arg1 = (FXCursor *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCursor *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCursor * >(argp1);
+  FXCursor_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCursor_detach(int argc, VALUE *argv, VALUE self) {
+  FXCursor *arg1 = (FXCursor *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCursor *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCursor * >(argp1);
+  FXCursor_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCursor_destroy(int argc, VALUE *argv, VALUE self) {
+  FXCursor *arg1 = (FXCursor *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCursor *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCursor * >(argp1);
+  FXCursor_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCursor_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXCursor *arg1 = (FXCursor *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCursor const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCursor * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXCursor_savePixels((FXCursor const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCursor_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXCursor *arg1 = (FXCursor *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCursor *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCursor * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXCursor_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXCURCursor;
+
+SWIGINTERN VALUE
+_wrap_FXCURCursor_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXCURCursor_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXCURCursor_allocate(VALUE self)
+#else
+_wrap_FXCURCursor_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXCURCursor);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXCURCursor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *arg2 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXCURCursor *result = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXCURCursor", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  {
+    if (argv[1] != Qnil) {
+      Check_Type(argv[1], T_STRING);
+      arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
+    } else {
+      arg2 = NULL;
+    }
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXCURCursor *)new_FXCURCursor(arg1,(void const *)arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCURCursor_save(int argc, VALUE *argv, VALUE self) {
+  FXCURCursor *arg1 = (FXCURCursor *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCURCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCURCursor const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCURCursor * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXCURCursor_save((FXCURCursor const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCURCursor_load(int argc, VALUE *argv, VALUE self) {
+  FXCURCursor *arg1 = (FXCURCursor *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCURCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCURCursor *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCURCursor * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXCURCursor_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCURCursor_create(int argc, VALUE *argv, VALUE self) {
+  FXCURCursor *arg1 = (FXCURCursor *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCURCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCURCursor *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCURCursor * >(argp1);
+  FXCURCursor_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCURCursor_detach(int argc, VALUE *argv, VALUE self) {
+  FXCURCursor *arg1 = (FXCURCursor *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCURCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCURCursor *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCURCursor * >(argp1);
+  FXCURCursor_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCURCursor_destroy(int argc, VALUE *argv, VALUE self) {
+  FXCURCursor *arg1 = (FXCURCursor *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCURCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCURCursor *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCURCursor * >(argp1);
+  FXCURCursor_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCURCursor_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXCURCursor *arg1 = (FXCURCursor *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCURCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCURCursor const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCURCursor * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXCURCursor_savePixels((FXCURCursor const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCURCursor_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXCURCursor *arg1 = (FXCURCursor *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCURCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCURCursor *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCURCursor * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXCURCursor_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXGIFCursor;
+
+SWIGINTERN VALUE
+_wrap_FXGIFCursor_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXGIFCursor_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXGIFCursor_allocate(VALUE self)
+#else
+_wrap_FXGIFCursor_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXGIFCursor);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXGIFCursor(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXint arg3 = (FXint) -1 ;
+  FXint arg4 = (FXint) -1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXGIFCursor *result = 0 ;
+  
+  if ((argc < 2) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXGIFCursor", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  {
+    if (argv[1] != Qnil) {
+      Check_Type(argv[1], T_STRING);
+      arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
+    } else {
+      arg2 = NULL;
+    }
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXGIFCursor *)new_FXGIFCursor(arg1,(void const *)arg2,arg3,arg4);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFCursor_save(int argc, VALUE *argv, VALUE self) {
+  FXGIFCursor *arg1 = (FXGIFCursor *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFCursor const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFCursor * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXGIFCursor_save((FXGIFCursor const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFCursor_load(int argc, VALUE *argv, VALUE self) {
+  FXGIFCursor *arg1 = (FXGIFCursor *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFCursor *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFCursor * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXGIFCursor_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFCursor_create(int argc, VALUE *argv, VALUE self) {
+  FXGIFCursor *arg1 = (FXGIFCursor *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFCursor *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFCursor * >(argp1);
+  FXGIFCursor_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFCursor_detach(int argc, VALUE *argv, VALUE self) {
+  FXGIFCursor *arg1 = (FXGIFCursor *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFCursor *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFCursor * >(argp1);
+  FXGIFCursor_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFCursor_destroy(int argc, VALUE *argv, VALUE self) {
+  FXGIFCursor *arg1 = (FXGIFCursor *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFCursor *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFCursor * >(argp1);
+  FXGIFCursor_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFCursor_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXGIFCursor *arg1 = (FXGIFCursor *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFCursor const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFCursor * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXGIFCursor_savePixels((FXGIFCursor const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFCursor_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXGIFCursor *arg1 = (FXGIFCursor *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFCursor, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFCursor *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFCursor * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXGIFCursor_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxsaveGIF(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  FXColor *arg2 = (FXColor *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXbool arg5 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxsaveGIF", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxsaveGIF", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  {
+    arg2=NULL;
+    if(argv[1]!=Qnil){
+      Check_Type(argv[1],T_ARRAY);
+      if(FXMALLOC(&arg2,FXColor,RARRAY_LEN(argv[1]))){
+        for(long i=0; i<RARRAY_LEN(argv[1]); i++){
+          arg2[i]=static_cast<FXColor>(NUM2UINT(rb_ary_entry(argv[1],i)));
+        }
+      }
+    }
+  }
+  arg3 = NUM2INT(argv[2]);
+  arg4 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg5 = to_FXbool(argv[4]);
+  }
+  result = (bool)fxsaveGIF(*arg1,(unsigned int const *)arg2,arg3,arg4,arg5);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  FXFREE(&arg2);
+  return vresult;
+fail:
+  FXFREE(&arg2);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxloadGIF(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxloadGIF", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxloadGIF", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (VALUE)fxloadGIF(*arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxcheckGIF(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxcheckGIF", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxcheckGIF", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (bool)fxcheckGIF(*arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXDrawable;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXDrawable_allocate(VALUE self)
+#else
+_wrap_FXDrawable_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXDrawable);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXDrawable(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXDrawable *result = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXDrawable", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2INT(argv[1]);
+  arg3 = NUM2INT(argv[2]);
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXDrawable *)new_FXDrawable(arg1,arg2,arg3);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDrawable_getWidth(int argc, VALUE *argv, VALUE self) {
+  FXDrawable *arg1 = (FXDrawable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDrawable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDrawable const *","getWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDrawable * >(argp1);
+  result = (FXint)((FXDrawable const *)arg1)->getWidth();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDrawable_getHeight(int argc, VALUE *argv, VALUE self) {
+  FXDrawable *arg1 = (FXDrawable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDrawable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDrawable const *","getHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDrawable * >(argp1);
+  result = (FXint)((FXDrawable const *)arg1)->getHeight();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDrawable_getVisual(int argc, VALUE *argv, VALUE self) {
+  FXDrawable *arg1 = (FXDrawable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVisual *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDrawable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDrawable const *","getVisual", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDrawable * >(argp1);
+  result = (FXVisual *)((FXDrawable const *)arg1)->getVisual();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXVisual, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDrawable_setVisual(int argc, VALUE *argv, VALUE self) {
+  FXDrawable *arg1 = (FXDrawable *) 0 ;
+  FXVisual *arg2 = (FXVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDrawable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDrawable *","setVisual", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDrawable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXVisual, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVisual *","setVisual", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXVisual * >(argp2);
+  (arg1)->setVisual(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDrawable_save(int argc, VALUE *argv, VALUE self) {
+  FXDrawable *arg1 = (FXDrawable *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDrawable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDrawable const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDrawable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDrawable_save((FXDrawable const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDrawable_load(int argc, VALUE *argv, VALUE self) {
+  FXDrawable *arg1 = (FXDrawable *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDrawable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDrawable *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDrawable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDrawable_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDrawable_create(int argc, VALUE *argv, VALUE self) {
+  FXDrawable *arg1 = (FXDrawable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDrawable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDrawable *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDrawable * >(argp1);
+  FXDrawable_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDrawable_detach(int argc, VALUE *argv, VALUE self) {
+  FXDrawable *arg1 = (FXDrawable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDrawable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDrawable *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDrawable * >(argp1);
+  FXDrawable_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDrawable_destroy(int argc, VALUE *argv, VALUE self) {
+  FXDrawable *arg1 = (FXDrawable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDrawable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDrawable *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDrawable * >(argp1);
+  FXDrawable_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDrawable_resize(int argc, VALUE *argv, VALUE self) {
+  FXDrawable *arg1 = (FXDrawable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDrawable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDrawable *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDrawable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDrawable_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXVisual;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXVisual_allocate(VALUE self)
+#else
+_wrap_FXVisual_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXVisual);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVisual(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuint arg2 ;
+  FXuint arg3 = (FXuint) 32 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVisual *result = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXVisual", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2UINT(argv[1]);
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXVisual *)new_FXVisual(arg1,arg2,arg3);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVisual_visualType(int argc, VALUE *argv, VALUE self) {
+  FXVisual *arg1 = (FXVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVisualType result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVisual const *","getType", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVisual * >(argp1);
+  result = (FXVisualType)((FXVisual const *)arg1)->getType();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVisual_getFlags(int argc, VALUE *argv, VALUE self) {
+  FXVisual *arg1 = (FXVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVisual const *","getFlags", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVisual * >(argp1);
+  result = (FXuint)((FXVisual const *)arg1)->getFlags();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVisual_getDepth(int argc, VALUE *argv, VALUE self) {
+  FXVisual *arg1 = (FXVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVisual const *","getDepth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVisual * >(argp1);
+  result = (FXuint)((FXVisual const *)arg1)->getDepth();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVisual_getNumColors(int argc, VALUE *argv, VALUE self) {
+  FXVisual *arg1 = (FXVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVisual const *","getNumColors", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVisual * >(argp1);
+  result = (FXuint)((FXVisual const *)arg1)->getNumColors();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVisual_getNumRed(int argc, VALUE *argv, VALUE self) {
+  FXVisual *arg1 = (FXVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVisual const *","getNumRed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVisual * >(argp1);
+  result = (FXuint)((FXVisual const *)arg1)->getNumRed();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVisual_getNumGreen(int argc, VALUE *argv, VALUE self) {
+  FXVisual *arg1 = (FXVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVisual const *","getNumGreen", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVisual * >(argp1);
+  result = (FXuint)((FXVisual const *)arg1)->getNumGreen();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVisual_getNumBlue(int argc, VALUE *argv, VALUE self) {
+  FXVisual *arg1 = (FXVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVisual const *","getNumBlue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVisual * >(argp1);
+  result = (FXuint)((FXVisual const *)arg1)->getNumBlue();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVisual_getPixel(int argc, VALUE *argv, VALUE self) {
+  FXVisual *arg1 = (FXVisual *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPixel result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVisual *","getPixel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVisual * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  result = (FXPixel)(arg1)->getPixel(arg2);
+  vresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVisual_getColor(int argc, VALUE *argv, VALUE self) {
+  FXVisual *arg1 = (FXVisual *) 0 ;
+  FXPixel arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned long val2 ;
+  int ecode2 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVisual *","getColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVisual * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXPixel","getColor", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXPixel >(val2);
+  result = (FXColor)(arg1)->getColor(arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVisual_setMaxColors(int argc, VALUE *argv, VALUE self) {
+  FXVisual *arg1 = (FXVisual *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVisual *","setMaxColors", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVisual * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setMaxColors(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVisual_getMaxColors(int argc, VALUE *argv, VALUE self) {
+  FXVisual *arg1 = (FXVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVisual const *","getMaxColors", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVisual * >(argp1);
+  result = (FXuint)((FXVisual const *)arg1)->getMaxColors();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVisual_save(int argc, VALUE *argv, VALUE self) {
+  FXVisual *arg1 = (FXVisual *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVisual const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVisual * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXVisual_save((FXVisual const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVisual_load(int argc, VALUE *argv, VALUE self) {
+  FXVisual *arg1 = (FXVisual *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVisual *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVisual * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXVisual_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVisual_create(int argc, VALUE *argv, VALUE self) {
+  FXVisual *arg1 = (FXVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVisual *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVisual * >(argp1);
+  FXVisual_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVisual_detach(int argc, VALUE *argv, VALUE self) {
+  FXVisual *arg1 = (FXVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVisual *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVisual * >(argp1);
+  FXVisual_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVisual_destroy(int argc, VALUE *argv, VALUE self) {
+  FXVisual *arg1 = (FXVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVisual *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVisual * >(argp1);
+  FXVisual_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXFontDesc;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXFontDesc_allocate(VALUE self)
+#else
+_wrap_FXFontDesc_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXFontDesc);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXFontDesc(int argc, VALUE *argv, VALUE self) {
+  FXFontDesc *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (FXFontDesc *)new FXFontDesc();
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDesc_face_set(int argc, VALUE *argv, VALUE self) {
+  FXFontDesc *arg1 = (FXFontDesc *) 0 ;
+  FXchar *arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  char temp2[116] ;
+  int res2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDesc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDesc *","face", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDesc * >(argp1);
+  res2 = SWIG_AsCharArray(argv[0], temp2, 116);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [116]","face", 2, argv[0] ));
+  }
+  arg2 = reinterpret_cast< char * >(temp2);
+  if (arg2) memcpy(arg1->face,arg2,116*sizeof(char));
+  else memset(arg1->face,0,116*sizeof(char));
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDesc_face_get(int argc, VALUE *argv, VALUE self) {
+  FXFontDesc *arg1 = (FXFontDesc *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDesc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDesc *","face", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDesc * >(argp1);
+  result = (FXchar *)(FXchar *) ((arg1)->face);
+  {
+    size_t size = SWIG_strnlen(result, 116);
+    
+    
+    
+    vresult = SWIG_FromCharPtrAndSize(result, size);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Core::FXFontDesc.size
+
+  call-seq:
+    size -> FXushort
+
+Size or Length of the FXFontDesc.
+*/
+
+/*
+  Document-method: Core::FXFontDesc.size=
+
+  call-seq:
+    size=(x) -> FXushort
+
+Size or Length of the FXFontDesc.
+*/
+SWIGINTERN VALUE
+_wrap_FXFontDesc_size_set(int argc, VALUE *argv, VALUE self) {
+  FXFontDesc *arg1 = (FXFontDesc *) 0 ;
+  FXushort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDesc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDesc *","size", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDesc * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (arg1) (arg1)->size = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDesc_size_get(int argc, VALUE *argv, VALUE self) {
+  FXFontDesc *arg1 = (FXFontDesc *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXushort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDesc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDesc *","size", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDesc * >(argp1);
+  result = (FXushort) ((arg1)->size);
+  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDesc_weight_set(int argc, VALUE *argv, VALUE self) {
+  FXFontDesc *arg1 = (FXFontDesc *) 0 ;
+  FXushort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDesc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDesc *","weight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDesc * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (arg1) (arg1)->weight = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDesc_weight_get(int argc, VALUE *argv, VALUE self) {
+  FXFontDesc *arg1 = (FXFontDesc *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXushort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDesc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDesc *","weight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDesc * >(argp1);
+  result = (FXushort) ((arg1)->weight);
+  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDesc_slant_set(int argc, VALUE *argv, VALUE self) {
+  FXFontDesc *arg1 = (FXFontDesc *) 0 ;
+  FXushort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDesc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDesc *","slant", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDesc * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (arg1) (arg1)->slant = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDesc_slant_get(int argc, VALUE *argv, VALUE self) {
+  FXFontDesc *arg1 = (FXFontDesc *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXushort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDesc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDesc *","slant", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDesc * >(argp1);
+  result = (FXushort) ((arg1)->slant);
+  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDesc_setwidth_set(int argc, VALUE *argv, VALUE self) {
+  FXFontDesc *arg1 = (FXFontDesc *) 0 ;
+  FXushort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDesc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDesc *","setwidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDesc * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (arg1) (arg1)->setwidth = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDesc_setwidth_get(int argc, VALUE *argv, VALUE self) {
+  FXFontDesc *arg1 = (FXFontDesc *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXushort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDesc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDesc *","setwidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDesc * >(argp1);
+  result = (FXushort) ((arg1)->setwidth);
+  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDesc_encoding_set(int argc, VALUE *argv, VALUE self) {
+  FXFontDesc *arg1 = (FXFontDesc *) 0 ;
+  FXushort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDesc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDesc *","encoding", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDesc * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (arg1) (arg1)->encoding = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDesc_encoding_get(int argc, VALUE *argv, VALUE self) {
+  FXFontDesc *arg1 = (FXFontDesc *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXushort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDesc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDesc *","encoding", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDesc * >(argp1);
+  result = (FXushort) ((arg1)->encoding);
+  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDesc_flags_set(int argc, VALUE *argv, VALUE self) {
+  FXFontDesc *arg1 = (FXFontDesc *) 0 ;
+  FXushort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDesc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDesc *","flags", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDesc * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (arg1) (arg1)->flags = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDesc_flags_get(int argc, VALUE *argv, VALUE self) {
+  FXFontDesc *arg1 = (FXFontDesc *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXushort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDesc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDesc *","flags", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDesc * >(argp1);
+  result = (FXushort) ((arg1)->flags);
+  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXFont;
+
+SWIGINTERN VALUE
+_wrap_new_FXFont__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXFont *result = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXFont", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXFont *)new_FXFont__SWIG_0(arg1,(FXString const &)*arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXFont__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXString *arg2 = 0 ;
+  FXuint arg3 ;
+  FXuint arg4 = (FXuint) FXFont::Normal ;
+  FXuint arg5 = (FXuint) FXFont::Straight ;
+  FXuint arg6 = (FXuint) FONTENCODING_DEFAULT ;
+  FXuint arg7 = (FXuint) FXFont::NonExpanded ;
+  FXuint arg8 = (FXuint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXFont *result = 0 ;
+  
+  if ((argc < 3) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXFont", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  arg3 = NUM2UINT(argv[2]);
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2UINT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2UINT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2UINT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXFont *)new_FXFont__SWIG_1(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXFont_allocate(VALUE self)
+#else
+_wrap_FXFont_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXFont);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXFont__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXFontDesc *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXFont *result = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXFont", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FXFontDesc,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFontDesc const &","FXFont", 2, argv[1] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXFontDesc const &","FXFont", 2, argv[1])); 
+  }
+  arg2 = reinterpret_cast< FXFontDesc * >(argp2);
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXFont *)new_FXFont__SWIG_2(arg1,(FXFontDesc const &)*arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXFont(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[8];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 8) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXFontDesc, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_FXFont__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_new_FXFont__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if ((argc >= 3) && (argc <= 8)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXFont__SWIG_1(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXFont__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXFont__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXFont__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  if (argc <= 7) {
+                    return _wrap_new_FXFont__SWIG_1(nargs, args, self);
+                  }
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    return _wrap_new_FXFont__SWIG_1(nargs, args, self);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 8, "FXFont.new", 
+    "    FXFont.new(FXApp *a, FXString const &string)\n"
+    "    FXFont.new(FXApp *a, FXString const &face, FXuint sz, FXuint wt, FXuint slant, FXuint encoding, FXuint setwidth, FXuint h)\n"
+    "    FXFont.new(FXApp *a, FXFontDesc const &fontdesc)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_family(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getFamily", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = ((FXFont const *)arg1)->getFamily();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_foundry(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getFoundry", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = ((FXFont const *)arg1)->getFoundry();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getName(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getName", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXString *) &((FXFont const *)arg1)->getName();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getActualName(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getActualName", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXString *) &((FXFont const *)arg1)->getActualName();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getSize(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXuint)((FXFont const *)arg1)->getSize();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getActualSize(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getActualSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXuint)((FXFont const *)arg1)->getActualSize();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getWeight(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getWeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXuint)((FXFont const *)arg1)->getWeight();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getActualWeight(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getActualWeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXuint)((FXFont const *)arg1)->getActualWeight();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getSlant(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getSlant", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXuint)((FXFont const *)arg1)->getSlant();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getActualSlant(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getActualSlant", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXuint)((FXFont const *)arg1)->getActualSlant();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getEncoding(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getEncoding", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXuint)((FXFont const *)arg1)->getEncoding();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getActualEncoding(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getActualEncoding", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXuint)((FXFont const *)arg1)->getActualEncoding();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getSetWidth(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getSetWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXuint)((FXFont const *)arg1)->getSetWidth();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getActualSetWidth(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getActualSetWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXuint)((FXFont const *)arg1)->getActualSetWidth();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getHints(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getHints", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXuint)((FXFont const *)arg1)->getHints();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_flags(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getFlags", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXuint)((FXFont const *)arg1)->getFlags();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getFontDesc(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFontDesc result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getFontDesc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = FXFont_getFontDesc((FXFont const *)arg1);
+  {
+    FXFontDesc* resultptr = new FXFontDesc(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXFontDesc *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_angle(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getAngle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXint)((FXFont const *)arg1)->getAngle();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_font(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = ((FXFont const *)arg1)->getFont();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_listFonts(int argc, VALUE *argv, VALUE self) {
+  FXString *arg1 = 0 ;
+  FXuint arg2 = (FXuint) 0 ;
+  FXuint arg3 = (FXuint) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXuint arg5 = (FXuint) 0 ;
+  FXuint arg6 = (FXuint) 0 ;
+  SwigValueWrapper< FXString > p1 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  p1 = to_FXString(argv[0]); arg1 = &p1;
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2UINT(argv[5]);
+  }
+  result = (VALUE)FXFont_listFonts((FXString const &)*arg1,arg2,arg3,arg4,arg5,arg6);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_save(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXFont_save((FXFont const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_load(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXFont_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_create(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  FXFont_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_detach(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  FXFont_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_destroy(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  FXFont_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_setFontDesc(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  FXFontDesc *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont *","setFontDesc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXFontDesc,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFontDesc const &","setFontDesc", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXFontDesc const &","setFontDesc", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXFontDesc * >(argp2);
+  FXFont_setFontDesc(arg1,(FXFontDesc const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_setAngle(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont *","setAngle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXFont_setAngle(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_setFont(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  FXFont_setFont(arg1,(FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_isFontMono(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","isFontMono", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXbool)FXFont_isFontMono((FXFont const *)arg1);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_hasChar(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","hasChar", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  arg2 = argv[0];
+  result = (FXbool)FXFont_hasChar((FXFont const *)arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getMinChar(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXwchar result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getMinChar", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXwchar)FXFont_getMinChar((FXFont const *)arg1);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getMaxChar(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXwchar result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getMaxChar", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXwchar)FXFont_getMaxChar((FXFont const *)arg1);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_leftBearing(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  FXwchar arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","leftBearing", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXwchar","leftBearing", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXwchar >(val2);
+  result = (FXint)FXFont_leftBearing((FXFont const *)arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_rightBearing(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  FXwchar arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","rightBearing", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXwchar","rightBearing", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXwchar >(val2);
+  result = (FXint)FXFont_rightBearing((FXFont const *)arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getFontWidth(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getFontWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXint)FXFont_getFontWidth((FXFont const *)arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getFontHeight(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getFontHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXint)FXFont_getFontHeight((FXFont const *)arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getFontAscent(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getFontAscent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXint)FXFont_getFontAscent((FXFont const *)arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getFontDescent(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getFontDescent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXint)FXFont_getFontDescent((FXFont const *)arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getFontLeading(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getFontLeading", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXint)FXFont_getFontLeading((FXFont const *)arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getFontSpacing(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getFontSpacing", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  result = (FXint)FXFont_getFontSpacing((FXFont const *)arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getCharWidth(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  FXwchar arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getCharWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXwchar","getCharWidth", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXwchar >(val2);
+  result = (FXint)FXFont_getCharWidth((FXFont const *)arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getTextWidth(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getTextWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  result = (FXint)FXFont_getTextWidth((FXFont const *)arg1,(FXString const &)*arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFont_getTextHeight(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont const *","getTextHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  result = (FXint)FXFont_getTextHeight((FXFont const *)arg1,(FXString const &)*arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXWindow;
+
+SWIGINTERN VALUE
+_wrap_FXWindow_octetType_get(VALUE self) {
+  VALUE _val;
+  
+  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(FXWindow::octetType));
+  return _val;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_octetType_set(VALUE self, VALUE _val) {
+  {
+    unsigned int val;
+    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""FXWindow::octetType""' of type '""FXDragType""'");
+    }
+    FXWindow::octetType = static_cast< FXDragType >(val);
+  }
+  return _val;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_deleteType_get(VALUE self) {
+  VALUE _val;
+  
+  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(FXWindow::deleteType));
+  return _val;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_deleteType_set(VALUE self, VALUE _val) {
+  {
+    unsigned int val;
+    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""FXWindow::deleteType""' of type '""FXDragType""'");
+    }
+    FXWindow::deleteType = static_cast< FXDragType >(val);
+  }
+  return _val;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_textType_get(VALUE self) {
+  VALUE _val;
+  
+  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(FXWindow::textType));
+  return _val;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_textType_set(VALUE self, VALUE _val) {
+  {
+    unsigned int val;
+    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""FXWindow::textType""' of type '""FXDragType""'");
+    }
+    FXWindow::textType = static_cast< FXDragType >(val);
+  }
+  return _val;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_utf8Type_get(VALUE self) {
+  VALUE _val;
+  
+  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(FXWindow::utf8Type));
+  return _val;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_utf8Type_set(VALUE self, VALUE _val) {
+  {
+    unsigned int val;
+    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""FXWindow::utf8Type""' of type '""FXDragType""'");
+    }
+    FXWindow::utf8Type = static_cast< FXDragType >(val);
+  }
+  return _val;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_utf16Type_get(VALUE self) {
+  VALUE _val;
+  
+  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(FXWindow::utf16Type));
+  return _val;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_utf16Type_set(VALUE self, VALUE _val) {
+  {
+    unsigned int val;
+    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""FXWindow::utf16Type""' of type '""FXDragType""'");
+    }
+    FXWindow::utf16Type = static_cast< FXDragType >(val);
+  }
+  return _val;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_colorType_get(VALUE self) {
+  VALUE _val;
+  
+  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(FXWindow::colorType));
+  return _val;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_colorType_set(VALUE self, VALUE _val) {
+  {
+    unsigned int val;
+    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""FXWindow::colorType""' of type '""FXDragType""'");
+    }
+    FXWindow::colorType = static_cast< FXDragType >(val);
+  }
+  return _val;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_urilistType_get(VALUE self) {
+  VALUE _val;
+  
+  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(FXWindow::urilistType));
+  return _val;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_urilistType_set(VALUE self, VALUE _val) {
+  {
+    unsigned int val;
+    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""FXWindow::urilistType""' of type '""FXDragType""'");
+    }
+    FXWindow::urilistType = static_cast< FXDragType >(val);
+  }
+  return _val;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_stringType_get(VALUE self) {
+  VALUE _val;
+  
+  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(FXWindow::stringType));
+  return _val;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_imageType_get(VALUE self) {
+  VALUE _val;
+  
+  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(FXWindow::imageType));
+  return _val;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onMap(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onMap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMap", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMap(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onUnmap(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onUnmap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUnmap", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUnmap(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onConfigure(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onConfigure", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onConfigure", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onConfigure(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onUpdate(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onUpdate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdate", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdate(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onMouseWheel(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onMouseWheel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMouseWheel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMouseWheel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onEnter(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onLeave(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onMiddleBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onMiddleBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMiddleBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMiddleBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onMiddleBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onMiddleBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMiddleBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMiddleBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onRightBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onRightBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onRightBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onRightBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onRightBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onRightBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onBeginDrag(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onBeginDrag", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onBeginDrag", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onBeginDrag(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onEndDrag(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onEndDrag", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEndDrag", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEndDrag(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onDragged(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onDragged", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDragged", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDragged(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onDestroy(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onDestroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDestroy", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onDestroy(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onFocusSelf(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onFocusSelf", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusSelf", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onFocusSelf(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onFocusIn(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onFocusIn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusIn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusIn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onFocusOut(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onFocusOut", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusOut", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusOut(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onSelectionLost(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onSelectionLost", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSelectionLost", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onSelectionLost(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onSelectionGained(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onSelectionGained", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSelectionGained", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onSelectionGained(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onSelectionRequest(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onSelectionRequest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSelectionRequest", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onSelectionRequest(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onClipboardLost(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onClipboardLost", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClipboardLost", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onClipboardLost(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onClipboardGained(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onClipboardGained", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClipboardGained", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onClipboardGained(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onClipboardRequest(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onClipboardRequest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClipboardRequest", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onClipboardRequest(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onDNDEnter(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onDNDEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onDNDLeave(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onDNDLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onDNDMotion(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onDNDMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onDNDDrop(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onDNDDrop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDDrop", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDDrop(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onDNDRequest(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onDNDRequest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDRequest", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDRequest(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onCmdShow(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onCmdShow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdShow", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdShow(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onCmdHide(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onCmdHide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdHide", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdHide(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onUpdToggleShown(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onUpdToggleShown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdToggleShown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdToggleShown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onCmdToggleShown(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onCmdToggleShown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdToggleShown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdToggleShown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onCmdRaise(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onCmdRaise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdRaise", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdRaise(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onCmdLower(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onCmdLower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdLower", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdLower(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onCmdEnable(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onCmdEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdEnable", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdEnable(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onCmdDisable(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onCmdDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDisable", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDisable(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onUpdToggleEnabled(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onUpdToggleEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdToggleEnabled", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdToggleEnabled(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onCmdToggleEnabled(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onCmdToggleEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdToggleEnabled", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdToggleEnabled(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onCmdUpdate(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onCmdUpdate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdUpdate", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdUpdate(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onUpdYes(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onUpdYes", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdYes", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdYes(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_onCmdDelete(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","onCmdDelete", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDelete", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDelete(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_octetTypeName(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXWindow_octetTypeName();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_deleteTypeName(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXWindow_deleteTypeName();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_textTypeName(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXWindow_textTypeName();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_colorTypeName(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXWindow_colorTypeName();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_urilistTypeName(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXWindow_urilistTypeName();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_utf8TypeName(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXWindow_utf8TypeName();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_utf16TypeName(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXWindow_utf16TypeName();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXWindow__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXuint arg2 = (FXuint) 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  
+  if ((argc < 1) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXWindow", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXWindow *)new_FXWindow__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXWindow__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXVisual *arg2 = (FXVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXWindow *result = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXWindow", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXVisual, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVisual *","FXWindow", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXVisual * >(argp2);
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXWindow *)new_FXWindow__SWIG_1(arg1,arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXWindow_allocate(VALUE self)
+#else
+_wrap_FXWindow_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXWindow);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXWindow__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXuint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXWindow *result = 0 ;
+  
+  if ((argc < 7) || (argc > 7)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXWindow", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","FXWindow", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  arg3 = NUM2UINT(argv[2]);
+  arg4 = NUM2INT(argv[3]);
+  arg5 = NUM2INT(argv[4]);
+  arg6 = NUM2INT(argv[5]);
+  arg7 = NUM2INT(argv[6]);
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    if (!arg2) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXWindow *)new_FXWindow__SWIG_2(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXWindow(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[7];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 7) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 1) && (argc <= 6)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComposite, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      if (argc <= 1) {
+        return _wrap_new_FXWindow__SWIG_0(nargs, args, self);
+      }
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_new_FXWindow__SWIG_0(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXWindow__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXWindow__SWIG_0(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXWindow__SWIG_0(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                return _wrap_new_FXWindow__SWIG_0(nargs, args, self);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVisual, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_FXWindow__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 7) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXWindow, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  return _wrap_new_FXWindow__SWIG_2(nargs, args, self);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 7, "FXWindow.new", 
+    "    FXWindow.new(FXComposite *p, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n"
+    "    FXWindow.new(FXApp *a, FXVisual *vis)\n"
+    "    FXWindow.new(FXApp *a, FXWindow *own, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getParent(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getParent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXWindow *)((FXWindow const *)arg1)->getParent();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getOwner(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getOwner", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXWindow *)((FXWindow const *)arg1)->getOwner();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getShell(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getShell", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXWindow *)((FXWindow const *)arg1)->getShell();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getRoot(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getRoot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXWindow *)((FXWindow const *)arg1)->getRoot();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getNext(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getNext", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXWindow *)((FXWindow const *)arg1)->getNext();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getPrev(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getPrev", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXWindow *)((FXWindow const *)arg1)->getPrev();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getFirst(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getFirst", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXWindow *)((FXWindow const *)arg1)->getFirst();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getLast(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getLast", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXWindow *)((FXWindow const *)arg1)->getLast();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getFocus(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXWindow *)((FXWindow const *)arg1)->getFocus();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_setKey(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setKey", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setKey(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getKey(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getKey", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXuint)((FXWindow const *)arg1)->getKey();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_setTarget(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setTarget", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","setTarget", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  (arg1)->setTarget(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getTarget(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXObject *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getTarget", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXObject *)((FXWindow const *)arg1)->getTarget();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXObject, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_setSelector(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXSelector arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setSelector", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setSelector(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getSelector(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXSelector result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getSelector", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXSelector)((FXWindow const *)arg1)->getSelector();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getX(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getX", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXint)((FXWindow const *)arg1)->getX();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getY(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getY", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXint)((FXWindow const *)arg1)->getY();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_setX(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setX", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setX(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_setY(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setY", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setY(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_setWidth(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setWidth(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_setHeight(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setHeight(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_setLayoutHints(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setLayoutHints", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setLayoutHints(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getLayoutHints(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getLayoutHints", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXuint)((FXWindow const *)arg1)->getLayoutHints();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getAccelTable(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXAccelTable *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getAccelTable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXAccelTable *)((FXWindow const *)arg1)->getAccelTable();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXAccelTable, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_setAccelTable(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXAccelTable *arg2 = (FXAccelTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setAccelTable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXAccelTable, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXAccelTable *","setAccelTable", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXAccelTable * >(argp2);
+  (arg1)->setAccelTable(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_addHotKey(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXHotKey arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","addHotKey", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->addHotKey(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_remHotKey(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXHotKey arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","remHotKey", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->remHotKey(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_setHelpTag(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setHelpTag", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpTag((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getHelpTag(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getHelpTag", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXString *) &((FXWindow const *)arg1)->getHelpTag();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_isShell(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","isShell", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (bool)((FXWindow const *)arg1)->isShell();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_isOwnerOf(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","isOwnerOf", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow const *","isOwnerOf", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  result = (bool)((FXWindow const *)arg1)->isOwnerOf((FXWindow const *)arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_isChildOf(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","isChildOf", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow const *","isChildOf", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  result = (bool)((FXWindow const *)arg1)->isChildOf((FXWindow const *)arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_containsChild(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","containsChild", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow const *","containsChild", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  result = (bool)((FXWindow const *)arg1)->containsChild((FXWindow const *)arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getChildAt(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getChildAt", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXWindow *)((FXWindow const *)arg1)->getChildAt(arg2,arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_numChildren(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","numChildren", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXint)((FXWindow const *)arg1)->numChildren();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_indexOfChild(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","indexOfChild", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow const *","indexOfChild", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  result = (FXint)((FXWindow const *)arg1)->indexOfChild((FXWindow const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_removeChild(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","removeChild", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","removeChild", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  result = (FXbool)FXWindow_removeChild(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_childAtIndex(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","childAtIndex", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->numChildren()) {
+      rb_raise(rb_eIndexError, "child window index out of bounds");
+    }
+  }
+  result = (FXWindow *)((FXWindow const *)arg1)->childAtIndex(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_commonAncestor(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXWindow::commonAncestor", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","FXWindow::commonAncestor", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  result = (FXWindow *)FXWindow::commonAncestor(arg1,arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_beforeq___(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","FXWindow::before", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow const *","FXWindow::before", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  result = (bool)FXWindow::before((FXWindow const *)arg1,(FXWindow const *)arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_afterq___(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","FXWindow::after", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow const *","FXWindow::after", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  result = (bool)FXWindow::after((FXWindow const *)arg1,(FXWindow const *)arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_before(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","before", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow const *","before", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  result = (bool)FXWindow_before((FXWindow const *)arg1,(FXWindow const *)arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_after(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","after", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow const *","after", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  result = (bool)FXWindow_after((FXWindow const *)arg1,(FXWindow const *)arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_composeContext(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXComposeContext *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getComposeContext", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXComposeContext *)((FXWindow const *)arg1)->getComposeContext();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXComposeContext, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_createComposeContext(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","createComposeContext", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  (arg1)->createComposeContext();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_destroyComposeContext(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","destroyComposeContext", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  (arg1)->destroyComposeContext();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_setDefaultCursor(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXCursor *arg2 = (FXCursor *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setDefaultCursor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXCursor, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXCursor *","setDefaultCursor", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXCursor * >(argp2);
+  (arg1)->setDefaultCursor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getDefaultCursor(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXCursor *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getDefaultCursor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXCursor *)((FXWindow const *)arg1)->getDefaultCursor();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXCursor, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_setDragCursor(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXCursor *arg2 = (FXCursor *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setDragCursor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXCursor, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXCursor *","setDragCursor", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXCursor * >(argp2);
+  (arg1)->setDragCursor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getDragCursor(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXCursor *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getDragCursor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXCursor *)((FXWindow const *)arg1)->getDragCursor();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXCursor, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getCursorPosition(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getCursorPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (VALUE)FXWindow_getCursorPosition((FXWindow const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_setCursorPosition(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setCursorPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXint)(arg1)->setCursorPosition(arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_isEnabled(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","isEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (bool)((FXWindow const *)arg1)->isEnabled();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_isActive(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","isActive", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (bool)((FXWindow const *)arg1)->isActive();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_hasFocus(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","hasFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (bool)((FXWindow const *)arg1)->hasFocus();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_inFocusChainq___(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","inFocusChain", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (bool)((FXWindow const *)arg1)->inFocusChain();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_isDefault(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","isDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (bool)((FXWindow const *)arg1)->isDefault();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_setInitial(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  bool arg2 = (bool) true ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setInitial", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setInitial", 2, argv[0] ));
+    } 
+    arg2 = static_cast< bool >(val2);
+  }
+  (arg1)->setInitial(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_isInitial(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","isInitial", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (bool)((FXWindow const *)arg1)->isInitial();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_forceRefresh(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","forceRefresh", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  (arg1)->forceRefresh();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_scroll(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","scroll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  ((FXWindow const *)arg1)->scroll(arg2,arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_update__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","update", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  ((FXWindow const *)arg1)->update(arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_update__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","update", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  ((FXWindow const *)arg1)->update();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXWindow_update(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXWindow_update__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXWindow_update__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "FXWindow.update", 
+    "    void FXWindow.update(FXint x, FXint y, FXint w, FXint h)\n"
+    "    void FXWindow.update()\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_repaint__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","repaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  ((FXWindow const *)arg1)->repaint(arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_repaint__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","repaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  ((FXWindow const *)arg1)->repaint();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXWindow_repaint(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXWindow_repaint__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXWindow_repaint__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "FXWindow.repaint", 
+    "    void FXWindow.repaint(FXint x, FXint y, FXint w, FXint h)\n"
+    "    void FXWindow.repaint()\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_grab(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","grab", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  (arg1)->grab();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_ungrab(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","ungrab", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  (arg1)->ungrab();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_grabbed(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","grabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (bool)((FXWindow const *)arg1)->grabbed();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_grabKeyboard(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","grabKeyboard", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  (arg1)->grabKeyboard();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_ungrabKeyboard(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","ungrabKeyboard", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  (arg1)->ungrabKeyboard();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_grabbedKeyboard(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","grabbedKeyboard", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (bool)((FXWindow const *)arg1)->grabbedKeyboard();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_shown(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","shown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (bool)((FXWindow const *)arg1)->shown();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_underCursor(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","underCursor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (bool)((FXWindow const *)arg1)->underCursor();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_hasSelection(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","hasSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (bool)((FXWindow const *)arg1)->hasSelection();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_acquireSelection(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","acquireSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = argv[0];
+  result = (bool)FXWindow_acquireSelection(arg1,arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_releaseSelection(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","releaseSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (bool)(arg1)->releaseSelection();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_hasClipboard(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","hasClipboard", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (bool)((FXWindow const *)arg1)->hasClipboard();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_acquireClipboard(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","acquireClipboard", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = argv[0];
+  result = (bool)FXWindow_acquireClipboard(arg1,arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_releaseClipboard(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","releaseClipboard", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (bool)(arg1)->releaseClipboard();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_isDropEnabled(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","isDropEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (bool)((FXWindow const *)arg1)->isDropEnabled();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_isDragging(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","isDragging", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (bool)((FXWindow const *)arg1)->isDragging();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_beginDrag(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","beginDrag", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = argv[0];
+  result = (bool)FXWindow_beginDrag(arg1,arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_handleDrag(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXDragAction arg4 = (FXDragAction) DRAG_COPY ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val4 ;
+  int ecode4 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","handleDrag", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    ecode4 = SWIG_AsVal_int(argv[2], &val4);
+    if (!SWIG_IsOK(ecode4)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXDragAction","handleDrag", 4, argv[2] ));
+    } 
+    arg4 = static_cast< FXDragAction >(val4);
+  }
+  result = (bool)(arg1)->handleDrag(arg2,arg3,arg4);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_endDrag(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  bool arg2 = (bool) true ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  FXDragAction result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","endDrag", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","endDrag", 2, argv[0] ));
+    } 
+    arg2 = static_cast< bool >(val2);
+  }
+  result = (FXDragAction)(arg1)->endDrag(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_isDropTarget(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","isDropTarget", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (bool)((FXWindow const *)arg1)->isDropTarget();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_setDragRectangle(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  bool arg6 = (bool) true ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val6 ;
+  int ecode6 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","setDragRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    ecode6 = SWIG_AsVal_bool(argv[4], &val6);
+    if (!SWIG_IsOK(ecode6)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","setDragRectangle", 6, argv[4] ));
+    } 
+    arg6 = static_cast< bool >(val6);
+  }
+  ((FXWindow const *)arg1)->setDragRectangle(arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_clearDragRectangle(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","clearDragRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  ((FXWindow const *)arg1)->clearDragRectangle();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_acceptDrop(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXDragAction arg2 = (FXDragAction) DRAG_ACCEPT ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","acceptDrop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_int(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXDragAction","acceptDrop", 2, argv[0] ));
+    } 
+    arg2 = static_cast< FXDragAction >(val2);
+  }
+  ((FXWindow const *)arg1)->acceptDrop(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_didAccept(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXDragAction result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","didAccept", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXDragAction)((FXWindow const *)arg1)->didAccept();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_dropFinished(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXDragAction arg2 = (FXDragAction) DRAG_REJECT ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","dropFinished", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_int(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXDragAction","dropFinished", 2, argv[0] ));
+    } 
+    arg2 = static_cast< FXDragAction >(val2);
+  }
+  ((FXWindow const *)arg1)->dropFinished(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_inquireDNDTypes(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXDNDOrigin arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","inquireDNDTypes", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXDNDOrigin","inquireDNDTypes", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXDNDOrigin >(val2);
+  result = (VALUE)FXWindow_inquireDNDTypes((FXWindow const *)arg1,arg2);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_offeredDNDType(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXDNDOrigin arg2 ;
+  FXDragType arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  unsigned int val3 ;
+  int ecode3 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","offeredDNDType", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXDNDOrigin","offeredDNDType", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXDNDOrigin >(val2);
+  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXDragType","offeredDNDType", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXDragType >(val3);
+  result = (bool)((FXWindow const *)arg1)->offeredDNDType(arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_inquireDNDAction(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXDragAction result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","inquireDNDAction", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXDragAction)((FXWindow const *)arg1)->inquireDNDAction();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_setDNDData(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXDNDOrigin arg2 ;
+  FXDragType arg3 ;
+  VALUE arg4 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  unsigned int val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","setDNDData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXDNDOrigin","setDNDData", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXDNDOrigin >(val2);
+  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXDragType","setDNDData", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXDragType >(val3);
+  arg4 = argv[2];
+  FXWindow_setDNDData((FXWindow const *)arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getDNDData(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXDNDOrigin arg2 ;
+  FXDragType arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  unsigned int val3 ;
+  int ecode3 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getDNDData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXDNDOrigin","getDNDData", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXDNDOrigin >(val2);
+  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXDragType","getDNDData", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXDragType >(val3);
+  result = (VALUE)FXWindow_getDNDData((FXWindow const *)arg1,arg2,arg3);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_translateCoordinatesFrom(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","translateCoordinatesFrom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow const *","translateCoordinatesFrom", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  result = (VALUE)FXWindow_translateCoordinatesFrom((FXWindow const *)arg1,(FXWindow const *)arg2,arg3,arg4);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_translateCoordinatesTo(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","translateCoordinatesTo", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow const *","translateCoordinatesTo", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  result = (VALUE)FXWindow_translateCoordinatesTo((FXWindow const *)arg1,(FXWindow const *)arg2,arg3,arg4);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getBackColor(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","getBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXColor)((FXWindow const *)arg1)->getBackColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_save(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXWindow_save((FXWindow const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_load(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXWindow_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_create(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  FXWindow_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_detach(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  FXWindow_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_destroy(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  FXWindow_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_resize(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXWindow_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXint)FXWindow_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (FXint)FXWindow_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXWindow_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXWindow_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (bool)FXWindow_canFocus((FXWindow const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  FXWindow_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  FXWindow_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXWindow_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXWindow_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_enable(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  FXWindow_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_disable(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  FXWindow_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  FXWindow_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_lower(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  FXWindow_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_move(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXWindow_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_position(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXWindow_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_layout(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  FXWindow_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_recalc(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  FXWindow_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_reparent(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXWindow_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_show(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  FXWindow_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_hide(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  FXWindow_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (bool)FXWindow_isComposite((FXWindow const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_contains(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXWindow_contains((FXWindow const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  result = (bool)FXWindow_doesSaveUnder((FXWindow const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXWindow_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_tr(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXWindow_tr((FXWindow const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  FXWindow_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  FXWindow_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXWindow_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXWindow_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXWindow_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXWindow_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXWindow_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXWindow_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXWindow_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWindow_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  FXWindow_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXFrame;
+
+SWIGINTERN VALUE
+_wrap_FXFrame_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXFrame_allocate(VALUE self)
+#else
+_wrap_FXFrame_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXFrame);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXFrame(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXuint arg2 = (FXuint) FRAME_NORMAL ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) DEFAULT_PAD ;
+  FXint arg8 = (FXint) DEFAULT_PAD ;
+  FXint arg9 = (FXint) DEFAULT_PAD ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFrame *result = 0 ;
+  
+  if ((argc < 1) || (argc > 10)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXFrame", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXFrame *)new_FXFrame(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_setFrameStyle(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setFrameStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setFrameStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_getFrameStyle(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","getFrameStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  result = (FXuint)((FXFrame const *)arg1)->getFrameStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_getBorderWidth(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","getBorderWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  result = (FXint)((FXFrame const *)arg1)->getBorderWidth();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_setPadTop(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setPadTop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setPadTop(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_getPadTop(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","getPadTop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  result = (FXint)((FXFrame const *)arg1)->getPadTop();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_setPadBottom(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setPadBottom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setPadBottom(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_getPadBottom(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","getPadBottom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  result = (FXint)((FXFrame const *)arg1)->getPadBottom();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_setPadLeft(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setPadLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setPadLeft(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_getPadLeft(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","getPadLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  result = (FXint)((FXFrame const *)arg1)->getPadLeft();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_setPadRight(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setPadRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setPadRight(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_getPadRight(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","getPadRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  result = (FXint)((FXFrame const *)arg1)->getPadRight();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_setHiliteColor(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setHiliteColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setHiliteColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_getHiliteColor(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","getHiliteColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  result = (FXColor)((FXFrame const *)arg1)->getHiliteColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_setShadowColor(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setShadowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setShadowColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_getShadowColor(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","getShadowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  result = (FXColor)((FXFrame const *)arg1)->getShadowColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_setBorderColor(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setBorderColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setBorderColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_getBorderColor(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","getBorderColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  result = (FXColor)((FXFrame const *)arg1)->getBorderColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_setBaseColor(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setBaseColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setBaseColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_getBaseColor(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","getBaseColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  result = (FXColor)((FXFrame const *)arg1)->getBaseColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_save(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXFrame_save((FXFrame const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_load(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXFrame_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_create(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  FXFrame_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_detach(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  FXFrame_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_destroy(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  FXFrame_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_resize(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXFrame_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  result = (FXint)FXFrame_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  result = (FXint)FXFrame_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXFrame_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXFrame_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  result = (bool)FXFrame_canFocus((FXFrame const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  FXFrame_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  FXFrame_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXFrame_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXFrame_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_enable(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  FXFrame_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_disable(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  FXFrame_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  FXFrame_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_lower(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  FXFrame_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_move(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXFrame_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_position(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXFrame_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_layout(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  FXFrame_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_recalc(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  FXFrame_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_reparent(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXFrame_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_show(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  FXFrame_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_hide(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  FXFrame_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  result = (bool)FXFrame_isComposite((FXFrame const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_contains(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXFrame_contains((FXFrame const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  result = (bool)FXFrame_doesSaveUnder((FXFrame const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXFrame_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_tr(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXFrame_tr((FXFrame const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  FXFrame_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  FXFrame_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXFrame_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXFrame_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXFrame_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXFrame_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFrame, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXFrame_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFrame, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXFrame_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFrame, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXFrame_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFrame_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXFrame *arg1 = (FXFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFrame *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFrame * >(argp1);
+  FXFrame_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXComposite;
+
+SWIGINTERN VALUE
+_wrap_FXComposite_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_onFocusNext(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","onFocusNext", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusNext", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusNext(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_onFocusPrev(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","onFocusPrev", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusPrev", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusPrev(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_onCmdUpdate(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","onCmdUpdate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdUpdate", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onCmdUpdate(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXComposite_allocate(VALUE self)
+#else
+_wrap_FXComposite_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXComposite);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXComposite(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXuint arg2 = (FXuint) 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXComposite *result = 0 ;
+  
+  if ((argc < 1) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXComposite", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXComposite *)new_FXComposite(arg1,arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_maxChildWidth(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite const *","maxChildWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  result = (FXint)((FXComposite const *)arg1)->maxChildWidth();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_maxChildHeight(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite const *","maxChildHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  result = (FXint)((FXComposite const *)arg1)->maxChildHeight();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_save(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXComposite_save((FXComposite const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_load(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXComposite_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_create(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  FXComposite_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_detach(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  FXComposite_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_destroy(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  FXComposite_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_resize(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXComposite_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  result = (FXint)FXComposite_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  result = (FXint)FXComposite_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXComposite_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXComposite_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  result = (bool)FXComposite_canFocus((FXComposite const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  FXComposite_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  FXComposite_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXComposite_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXComposite_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_enable(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  FXComposite_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_disable(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  FXComposite_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  FXComposite_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_lower(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  FXComposite_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_move(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXComposite_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_position(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXComposite_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_layout(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  FXComposite_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_recalc(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  FXComposite_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_reparent(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXComposite_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_show(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  FXComposite_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_hide(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  FXComposite_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  result = (bool)FXComposite_isComposite((FXComposite const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_contains(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXComposite_contains((FXComposite const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  result = (bool)FXComposite_doesSaveUnder((FXComposite const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXComposite_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_tr(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXComposite_tr((FXComposite const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  FXComposite_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  FXComposite_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXComposite_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXComposite_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXComposite_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXComposite_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComposite, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXComposite_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComposite, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXComposite_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComposite, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXComposite_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComposite_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  FXComposite_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXRootWindow;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXRootWindow_allocate(VALUE self)
+#else
+_wrap_FXRootWindow_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXRootWindow);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRootWindow(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXVisual *arg2 = (FXVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXRootWindow *result = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXRootWindow", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXVisual, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVisual *","FXRootWindow", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXVisual * >(argp2);
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXRootWindow *)new_FXRootWindow(arg1,arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_save(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXRootWindow_save((FXRootWindow const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_load(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXRootWindow_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_create(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  FXRootWindow_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_detach(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  FXRootWindow_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_destroy(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  FXRootWindow_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_resize(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXRootWindow_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  result = (FXint)FXRootWindow_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  result = (FXint)FXRootWindow_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXRootWindow_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXRootWindow_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  result = (bool)FXRootWindow_canFocus((FXRootWindow const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  FXRootWindow_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  FXRootWindow_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXRootWindow_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXRootWindow_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_enable(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  FXRootWindow_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_disable(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  FXRootWindow_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  FXRootWindow_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_lower(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  FXRootWindow_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_move(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXRootWindow_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_position(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXRootWindow_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_layout(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  FXRootWindow_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_recalc(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  FXRootWindow_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_reparent(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXRootWindow_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_show(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  FXRootWindow_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_hide(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  FXRootWindow_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  result = (bool)FXRootWindow_isComposite((FXRootWindow const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_contains(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXRootWindow_contains((FXRootWindow const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  result = (bool)FXRootWindow_doesSaveUnder((FXRootWindow const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXRootWindow_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_tr(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXRootWindow_tr((FXRootWindow const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  FXRootWindow_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  FXRootWindow_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXRootWindow_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXRootWindow_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXRootWindow_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXRootWindow_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRootWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRootWindow_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRootWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRootWindow_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRootWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRootWindow_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRootWindow_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXRootWindow *arg1 = (FXRootWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRootWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRootWindow *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRootWindow * >(argp1);
+  FXRootWindow_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXShell;
+
+SWIGINTERN VALUE
+_wrap_FXShell_onLayout(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","onLayout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLayout", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onLayout(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_onConfigure(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","onConfigure", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onConfigure", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onConfigure(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_onFocusNext(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","onFocusNext", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusNext", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusNext(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_onFocusPrev(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","onFocusPrev", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusPrev", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusPrev(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXShell__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXShell *result = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXShell", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2UINT(argv[1]);
+  arg3 = NUM2INT(argv[2]);
+  arg4 = NUM2INT(argv[3]);
+  arg5 = NUM2INT(argv[4]);
+  arg6 = NUM2INT(argv[5]);
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXShell *)new_FXShell__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXShell_allocate(VALUE self)
+#else
+_wrap_FXShell_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXShell);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXShell__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXuint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXShell *result = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXShell", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2UINT(argv[1]);
+  arg3 = NUM2INT(argv[2]);
+  arg4 = NUM2INT(argv[3]);
+  arg5 = NUM2INT(argv[4]);
+  arg6 = NUM2INT(argv[5]);
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXShell *)new_FXShell__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXShell(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 6) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 6) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                return _wrap_new_FXShell__SWIG_0(nargs, args, self);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if (argc == 6) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                return _wrap_new_FXShell__SWIG_1(nargs, args, self);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "FXShell.new", 
+    "    FXShell.new(FXApp *a, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n"
+    "    FXShell.new(FXWindow *own, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_save(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXShell_save((FXShell const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_load(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXShell_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_create(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  FXShell_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_detach(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  FXShell_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_destroy(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  FXShell_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_resize(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXShell_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  result = (FXint)FXShell_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  result = (FXint)FXShell_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXShell_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXShell_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  result = (bool)FXShell_canFocus((FXShell const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  FXShell_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  FXShell_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXShell_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXShell_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_enable(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  FXShell_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_disable(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  FXShell_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  FXShell_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_lower(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  FXShell_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_move(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXShell_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_position(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXShell_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_layout(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  FXShell_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_recalc(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  FXShell_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_reparent(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXShell_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_show(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  FXShell_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_hide(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  FXShell_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  result = (bool)FXShell_isComposite((FXShell const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_contains(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXShell_contains((FXShell const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  result = (bool)FXShell_doesSaveUnder((FXShell const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXShell_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_tr(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXShell_tr((FXShell const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  FXShell_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  FXShell_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXShell_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXShell_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXShell_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXShell_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXShell, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXShell_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXShell, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXShell_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXShell, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXShell_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShell_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXShell *arg1 = (FXShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShell *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShell * >(argp1);
+  FXShell_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXPopup;
+
+SWIGINTERN VALUE
+_wrap_FXPopup_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_onFocusUp(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","onFocusUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_onFocusDown(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","onFocusDown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusDown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusDown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_onFocusLeft(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","onFocusLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusLeft", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusLeft(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_onFocusRight(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","onFocusRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusRight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusRight(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_onFocusNext(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","onFocusNext", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusNext", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusNext(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_onFocusPrev(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","onFocusPrev", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusPrev", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusPrev(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_onEnter(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","onEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_onLeave(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","onLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_onMap(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","onMap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMap", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMap(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_onButtonPress(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","onButtonPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onButtonPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onButtonPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_onButtonRelease(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","onButtonRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onButtonRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onButtonRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_onCmdUnpost(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","onCmdUnpost", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdUnpost", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdUnpost(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_onCmdChoice(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","onCmdChoice", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdChoice", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdChoice(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXPopup_allocate(VALUE self)
+#else
+_wrap_FXPopup_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXPopup);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXPopup(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXuint arg2 = (FXuint) POPUP_VERTICAL|FRAME_RAISED|FRAME_THICK ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPopup *result = 0 ;
+  
+  if ((argc < 1) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXPopup", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXPopup *)new_FXPopup(arg1,arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_getPrevActive(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPopup *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup const *","getPrevActive", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  result = (FXPopup *)((FXPopup const *)arg1)->getPrevActive();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXPopup, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_getNextActive(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPopup *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup const *","getNextActive", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  result = (FXPopup *)((FXPopup const *)arg1)->getNextActive();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXPopup, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_setFrameStyle(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","setFrameStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setFrameStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_getFrameStyle(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup const *","getFrameStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  result = (FXuint)((FXPopup const *)arg1)->getFrameStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_getBorderWidth(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup const *","getBorderWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  result = (FXint)((FXPopup const *)arg1)->getBorderWidth();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_setHiliteColor(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","setHiliteColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setHiliteColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_getHiliteColor(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup const *","getHiliteColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  result = (FXColor)((FXPopup const *)arg1)->getHiliteColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_setShadowColor(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","setShadowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setShadowColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_getShadowColor(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup const *","getShadowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  result = (FXColor)((FXPopup const *)arg1)->getShadowColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_setBorderColor(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","setBorderColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setBorderColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_getBorderColor(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup const *","getBorderColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  result = (FXColor)((FXPopup const *)arg1)->getBorderColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_setBaseColor(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","setBaseColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setBaseColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_getBaseColor(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup const *","getBaseColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  result = (FXColor)((FXPopup const *)arg1)->getBaseColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_getGrabOwner(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup const *","getGrabOwner", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  result = (FXWindow *)((FXPopup const *)arg1)->getGrabOwner();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_getOrientation(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup const *","getOrientation", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  result = (FXuint)((FXPopup const *)arg1)->getOrientation();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_setOrientation(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","setOrientation", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setOrientation(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_getShrinkWrap(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup const *","getShrinkWrap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  result = (FXbool)((FXPopup const *)arg1)->getShrinkWrap();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_setShrinkWrap(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","setShrinkWrap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->setShrinkWrap(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_save(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXPopup_save((FXPopup const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_load(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXPopup_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_create(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  FXPopup_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_detach(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  FXPopup_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_destroy(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  FXPopup_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_resize(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXPopup_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  result = (FXint)FXPopup_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  result = (FXint)FXPopup_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXPopup_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXPopup_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  result = (bool)FXPopup_canFocus((FXPopup const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  FXPopup_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  FXPopup_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXPopup_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXPopup_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_enable(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  FXPopup_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_disable(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  FXPopup_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  FXPopup_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_lower(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  FXPopup_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_move(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXPopup_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_position(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXPopup_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_layout(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  FXPopup_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_recalc(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  FXPopup_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_reparent(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXPopup_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_show(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  FXPopup_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_hide(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  FXPopup_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  result = (bool)FXPopup_isComposite((FXPopup const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_contains(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXPopup_contains((FXPopup const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  result = (bool)FXPopup_doesSaveUnder((FXPopup const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXPopup_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_tr(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXPopup_tr((FXPopup const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  FXPopup_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  FXPopup_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXPopup_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXPopup_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXPopup_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXPopup_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXPopup, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXPopup_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXPopup, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXPopup_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXPopup, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXPopup_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  FXPopup_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_popup(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 3) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","popup", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","popup", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  if (argc > 3) {
+    arg5 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg6 = NUM2INT(argv[4]);
+  }
+  FXPopup_popup(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPopup_popdown(int argc, VALUE *argv, VALUE self) {
+  FXPopup *arg1 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPopup *","popdown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPopup * >(argp1);
+  FXPopup_popdown(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXTopWindow;
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_onFocusUp(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","onFocusUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_onFocusDown(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","onFocusDown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusDown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusDown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_onFocusLeft(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","onFocusLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusLeft", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusLeft(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_onFocusRight(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","onFocusRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusRight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusRight(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_onSessionNotify(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","onSessionNotify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSessionNotify", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onSessionNotify(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_onSessionClosed(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","onSessionClosed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSessionClosed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onSessionClosed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_onCmdMaximize(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","onCmdMaximize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMaximize", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdMaximize", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdMaximize(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_onCmdMinimize(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","onCmdMinimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMinimize", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdMinimize", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdMinimize(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_onCmdRestore(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","onCmdRestore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdRestore", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdRestore", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdRestore(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_onCmdClose(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","onCmdClose", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdClose", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdClose", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdClose(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_onCmdSetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","onCmdSetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdSetStringValue", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdSetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_onCmdGetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","onCmdGetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetStringValue", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_onCmdSetIconValue(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","onCmdSetIconValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIconValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdSetIconValue", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdSetIconValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_onCmdGetIconValue(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","onCmdGetIconValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIconValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetIconValue", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetIconValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXTopWindow__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXuint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  FXint arg8 ;
+  FXint arg9 ;
+  FXint arg10 ;
+  FXint arg11 ;
+  FXint arg12 ;
+  FXint arg13 ;
+  FXint arg14 ;
+  FXint arg15 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXTopWindow *result = 0 ;
+  
+  if ((argc < 15) || (argc > 15)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 15)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXTopWindow", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","FXTopWindow", 3, argv[2] )); 
+  }
+  arg3 = reinterpret_cast< FXIcon * >(argp3);
+  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","FXTopWindow", 4, argv[3] )); 
+  }
+  arg4 = reinterpret_cast< FXIcon * >(argp4);
+  arg5 = NUM2UINT(argv[4]);
+  arg6 = NUM2INT(argv[5]);
+  arg7 = NUM2INT(argv[6]);
+  arg8 = NUM2INT(argv[7]);
+  arg9 = NUM2INT(argv[8]);
+  arg10 = NUM2INT(argv[9]);
+  arg11 = NUM2INT(argv[10]);
+  arg12 = NUM2INT(argv[11]);
+  arg13 = NUM2INT(argv[12]);
+  arg14 = NUM2INT(argv[13]);
+  arg15 = NUM2INT(argv[14]);
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXTopWindow *)new_FXTopWindow__SWIG_0(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXTopWindow_allocate(VALUE self)
+#else
+_wrap_FXTopWindow_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXTopWindow);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXTopWindow__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXuint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  FXint arg8 ;
+  FXint arg9 ;
+  FXint arg10 ;
+  FXint arg11 ;
+  FXint arg12 ;
+  FXint arg13 ;
+  FXint arg14 ;
+  FXint arg15 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXTopWindow *result = 0 ;
+  
+  if ((argc < 15) || (argc > 15)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 15)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXTopWindow", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","FXTopWindow", 3, argv[2] )); 
+  }
+  arg3 = reinterpret_cast< FXIcon * >(argp3);
+  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","FXTopWindow", 4, argv[3] )); 
+  }
+  arg4 = reinterpret_cast< FXIcon * >(argp4);
+  arg5 = NUM2UINT(argv[4]);
+  arg6 = NUM2INT(argv[5]);
+  arg7 = NUM2INT(argv[6]);
+  arg8 = NUM2INT(argv[7]);
+  arg9 = NUM2INT(argv[8]);
+  arg10 = NUM2INT(argv[9]);
+  arg11 = NUM2INT(argv[10]);
+  arg12 = NUM2INT(argv[11]);
+  arg13 = NUM2INT(argv[12]);
+  arg14 = NUM2INT(argv[13]);
+  arg15 = NUM2INT(argv[14]);
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXTopWindow *)new_FXTopWindow__SWIG_1(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXTopWindow(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[15];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 15) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 15) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXIcon, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    {
+                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
+                    }
+                    if (_v) {
+                      {
+                        _v = (TYPE(argv[9]) == T_FIXNUM || TYPE(argv[9]) == T_BIGNUM) ? 1 : 0;
+                      }
+                      if (_v) {
+                        {
+                          _v = (TYPE(argv[10]) == T_FIXNUM || TYPE(argv[10]) == T_BIGNUM) ? 1 : 0;
+                        }
+                        if (_v) {
+                          {
+                            _v = (TYPE(argv[11]) == T_FIXNUM || TYPE(argv[11]) == T_BIGNUM) ? 1 : 0;
+                          }
+                          if (_v) {
+                            {
+                              _v = (TYPE(argv[12]) == T_FIXNUM || TYPE(argv[12]) == T_BIGNUM) ? 1 : 0;
+                            }
+                            if (_v) {
+                              {
+                                _v = (TYPE(argv[13]) == T_FIXNUM || TYPE(argv[13]) == T_BIGNUM) ? 1 : 0;
+                              }
+                              if (_v) {
+                                {
+                                  _v = (TYPE(argv[14]) == T_FIXNUM || TYPE(argv[14]) == T_BIGNUM) ? 1 : 0;
+                                }
+                                if (_v) {
+                                  return _wrap_new_FXTopWindow__SWIG_0(nargs, args, self);
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if (argc == 15) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXIcon, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    {
+                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
+                    }
+                    if (_v) {
+                      {
+                        _v = (TYPE(argv[9]) == T_FIXNUM || TYPE(argv[9]) == T_BIGNUM) ? 1 : 0;
+                      }
+                      if (_v) {
+                        {
+                          _v = (TYPE(argv[10]) == T_FIXNUM || TYPE(argv[10]) == T_BIGNUM) ? 1 : 0;
+                        }
+                        if (_v) {
+                          {
+                            _v = (TYPE(argv[11]) == T_FIXNUM || TYPE(argv[11]) == T_BIGNUM) ? 1 : 0;
+                          }
+                          if (_v) {
+                            {
+                              _v = (TYPE(argv[12]) == T_FIXNUM || TYPE(argv[12]) == T_BIGNUM) ? 1 : 0;
+                            }
+                            if (_v) {
+                              {
+                                _v = (TYPE(argv[13]) == T_FIXNUM || TYPE(argv[13]) == T_BIGNUM) ? 1 : 0;
+                              }
+                              if (_v) {
+                                {
+                                  _v = (TYPE(argv[14]) == T_FIXNUM || TYPE(argv[14]) == T_BIGNUM) ? 1 : 0;
+                                }
+                                if (_v) {
+                                  return _wrap_new_FXTopWindow__SWIG_1(nargs, args, self);
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 15, "FXTopWindow.new", 
+    "    FXTopWindow.new(FXApp *a, FXString const &name, FXIcon *ic, FXIcon *mi, FXuint opts, FXint x, FXint y, FXint w, FXint h, FXint pl, FXint pr, FXint pt, FXint pb, FXint hs, FXint vs)\n"
+    "    FXTopWindow.new(FXWindow *owner, FXString const &name, FXIcon *ic, FXIcon *mi, FXuint opts, FXint x, FXint y, FXint w, FXint h, FXint pl, FXint pr, FXint pt, FXint pb, FXint hs, FXint vs)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_getWMBorders(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","getWMBorders", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  result = (VALUE)FXTopWindow_getWMBorders(arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_place(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","place", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->place(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_isMaximized(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow const *","isMaximized", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  result = (FXbool)((FXTopWindow const *)arg1)->isMaximized();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_isMinimized(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow const *","isMinimized", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  result = (FXbool)((FXTopWindow const *)arg1)->isMinimized();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_setTitle(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","setTitle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTitle((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_getTitle(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow const *","getTitle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  result = ((FXTopWindow const *)arg1)->getTitle();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_setPadTop(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","setPadTop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setPadTop(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_getPadTop(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow const *","getPadTop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  result = (FXint)((FXTopWindow const *)arg1)->getPadTop();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_setPadBottom(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","setPadBottom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setPadBottom(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_getPadBottom(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow const *","getPadBottom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  result = (FXint)((FXTopWindow const *)arg1)->getPadBottom();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_setPadLeft(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","setPadLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setPadLeft(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_getPadLeft(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow const *","getPadLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  result = (FXint)((FXTopWindow const *)arg1)->getPadLeft();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_setPadRight(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","setPadRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setPadRight(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_getPadRight(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow const *","getPadRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  result = (FXint)((FXTopWindow const *)arg1)->getPadRight();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_getHSpacing(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow const *","getHSpacing", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  result = (FXint)((FXTopWindow const *)arg1)->getHSpacing();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_getVSpacing(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow const *","getVSpacing", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  result = (FXint)((FXTopWindow const *)arg1)->getVSpacing();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_setHSpacing(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","setHSpacing", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setHSpacing(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_setVSpacing(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","setVSpacing", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setVSpacing(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_setPackingHints(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","setPackingHints", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setPackingHints(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_getPackingHints(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow const *","getPackingHints", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  result = (FXuint)((FXTopWindow const *)arg1)->getPackingHints();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_setDecorations(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","setDecorations", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setDecorations(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_getDecorations(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow const *","getDecorations", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  result = (FXuint)((FXTopWindow const *)arg1)->getDecorations();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_getIcon(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow const *","getIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  result = (FXIcon *)((FXTopWindow const *)arg1)->getIcon();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_setIcon(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","setIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  (arg1)->setIcon(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_getMiniIcon(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow const *","getMiniIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  result = (FXIcon *)((FXTopWindow const *)arg1)->getMiniIcon();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_setMiniIcon(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","setMiniIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setMiniIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  (arg1)->setMiniIcon(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_save(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTopWindow_save((FXTopWindow const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_load(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTopWindow_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_create(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  FXTopWindow_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_detach(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  FXTopWindow_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_destroy(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  FXTopWindow_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_resize(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXTopWindow_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  result = (FXint)FXTopWindow_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  result = (FXint)FXTopWindow_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXTopWindow_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXTopWindow_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  result = (bool)FXTopWindow_canFocus((FXTopWindow const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  FXTopWindow_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  FXTopWindow_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXTopWindow_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXTopWindow_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_enable(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  FXTopWindow_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_disable(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  FXTopWindow_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  FXTopWindow_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_lower(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  FXTopWindow_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_move(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXTopWindow_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_position(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXTopWindow_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_layout(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  FXTopWindow_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_recalc(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  FXTopWindow_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_reparent(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXTopWindow_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_show__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  FXTopWindow_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_hide(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  FXTopWindow_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  result = (bool)FXTopWindow_isComposite((FXTopWindow const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_contains(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXTopWindow_contains((FXTopWindow const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  result = (bool)FXTopWindow_doesSaveUnder((FXTopWindow const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXTopWindow_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_tr(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXTopWindow_tr((FXTopWindow const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  FXTopWindow_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  FXTopWindow_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXTopWindow_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXTopWindow_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXTopWindow_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXTopWindow_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTopWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTopWindow_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTopWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTopWindow_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTopWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTopWindow_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  FXTopWindow_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_show__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  FXTopWindow_show(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXTopWindow_show(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTopWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXTopWindow_show__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTopWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXTopWindow_show__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "show", 
+    "    void show()\n"
+    "    void show(FXuint placement)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_maximize(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","maximize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXTopWindow_maximize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_minimize(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","minimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXTopWindow_minimize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_restore(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXTopWindow_restore(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTopWindow_close(int argc, VALUE *argv, VALUE self) {
+  FXTopWindow *arg1 = (FXTopWindow *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTopWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTopWindow *","close", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTopWindow * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXTopWindow_close(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMainWindow;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMainWindow_allocate(VALUE self)
+#else
+_wrap_FXMainWindow_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMainWindow);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMainWindow(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXuint arg5 = (FXuint) DECOR_ALL ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) 0 ;
+  FXint arg11 = (FXint) 0 ;
+  FXint arg12 = (FXint) 0 ;
+  FXint arg13 = (FXint) 0 ;
+  FXint arg14 = (FXint) 0 ;
+  FXint arg15 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXMainWindow *result = 0 ;
+  
+  if ((argc < 2) || (argc > 15)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXMainWindow", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","FXMainWindow", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 3) {
+    res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","FXMainWindow", 4, argv[3] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  if (argc > 13) {
+    arg14 = NUM2INT(argv[13]);
+  }
+  if (argc > 14) {
+    arg15 = NUM2INT(argv[14]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXMainWindow *)new_FXMainWindow(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_save(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMainWindow_save((FXMainWindow const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_load(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMainWindow_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_create(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  FXMainWindow_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_detach(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  FXMainWindow_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_destroy(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  FXMainWindow_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_resize(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMainWindow_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  result = (FXint)FXMainWindow_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  result = (FXint)FXMainWindow_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMainWindow_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMainWindow_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  result = (bool)FXMainWindow_canFocus((FXMainWindow const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  FXMainWindow_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  FXMainWindow_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXMainWindow_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMainWindow_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_enable(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  FXMainWindow_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_disable(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  FXMainWindow_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  FXMainWindow_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_lower(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  FXMainWindow_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_move(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMainWindow_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_position(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXMainWindow_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_layout(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  FXMainWindow_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_recalc(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  FXMainWindow_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_reparent(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXMainWindow_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_show__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  FXMainWindow_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_hide(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  FXMainWindow_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  result = (bool)FXMainWindow_isComposite((FXMainWindow const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_contains(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXMainWindow_contains((FXMainWindow const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  result = (bool)FXMainWindow_doesSaveUnder((FXMainWindow const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXMainWindow_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_tr(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXMainWindow_tr((FXMainWindow const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  FXMainWindow_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  FXMainWindow_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXMainWindow_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXMainWindow_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXMainWindow_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMainWindow_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMainWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMainWindow_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMainWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMainWindow_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMainWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMainWindow_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  FXMainWindow_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_show__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  FXMainWindow_show(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMainWindow_show(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMainWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXMainWindow_show__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMainWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXMainWindow_show__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "show", 
+    "    void show()\n"
+    "    void show(FXuint placement)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_maximize(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","maximize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXMainWindow_maximize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_minimize(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","minimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXMainWindow_minimize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_restore(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXMainWindow_restore(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMainWindow_close(int argc, VALUE *argv, VALUE self) {
+  FXMainWindow *arg1 = (FXMainWindow *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMainWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMainWindow *","close", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMainWindow * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXMainWindow_close(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXSplashWindow;
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSplashWindow__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXuint arg3 = (FXuint) SPLASH_SIMPLE ;
+  FXuint arg4 = (FXuint) 5000 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXSplashWindow *result = 0 ;
+  
+  if ((argc < 2) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXSplashWindow", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","FXSplashWindow", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXSplashWindow *)new_FXSplashWindow__SWIG_0(arg1,arg2,arg3,arg4);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXSplashWindow_allocate(VALUE self)
+#else
+_wrap_FXSplashWindow_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXSplashWindow);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSplashWindow__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXuint arg3 = (FXuint) SPLASH_SIMPLE ;
+  FXuint arg4 = (FXuint) 5000 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXSplashWindow *result = 0 ;
+  
+  if ((argc < 2) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXSplashWindow", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","FXSplashWindow", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXSplashWindow *)new_FXSplashWindow__SWIG_1(arg1,arg2,arg3,arg4);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXSplashWindow(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 4) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 2) && (argc <= 4)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_new_FXSplashWindow__SWIG_0(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXSplashWindow__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_new_FXSplashWindow__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 2) && (argc <= 4)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_new_FXSplashWindow__SWIG_1(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXSplashWindow__SWIG_1(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_new_FXSplashWindow__SWIG_1(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXSplashWindow.new", 
+    "    FXSplashWindow.new(FXApp *a, FXIcon *ic, FXuint opts, FXuint ms)\n"
+    "    FXSplashWindow.new(FXWindow *own, FXIcon *ic, FXuint opts, FXuint ms)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_icone___(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","setIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  (arg1)->setIcon(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_icon(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow const *","getIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  result = (FXIcon *)((FXSplashWindow const *)arg1)->getIcon();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_delaye___(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","setDelay", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setDelay(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_delay(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow const *","getDelay", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  result = (FXuint)((FXSplashWindow const *)arg1)->getDelay();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_save(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXSplashWindow_save((FXSplashWindow const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_load(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXSplashWindow_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_create(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  FXSplashWindow_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_detach(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  FXSplashWindow_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_destroy(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  FXSplashWindow_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_resize(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXSplashWindow_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  result = (FXint)FXSplashWindow_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  result = (FXint)FXSplashWindow_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXSplashWindow_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXSplashWindow_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  result = (bool)FXSplashWindow_canFocus((FXSplashWindow const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  FXSplashWindow_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  FXSplashWindow_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXSplashWindow_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXSplashWindow_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_enable(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  FXSplashWindow_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_disable(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  FXSplashWindow_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  FXSplashWindow_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_lower(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  FXSplashWindow_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_move(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXSplashWindow_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_position(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXSplashWindow_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_layout(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  FXSplashWindow_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_recalc(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  FXSplashWindow_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_reparent(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXSplashWindow_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_show__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  FXSplashWindow_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_hide(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  FXSplashWindow_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  result = (bool)FXSplashWindow_isComposite((FXSplashWindow const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_contains(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXSplashWindow_contains((FXSplashWindow const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  result = (bool)FXSplashWindow_doesSaveUnder((FXSplashWindow const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXSplashWindow_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_tr(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXSplashWindow_tr((FXSplashWindow const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  FXSplashWindow_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  FXSplashWindow_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXSplashWindow_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXSplashWindow_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXSplashWindow_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXSplashWindow_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSplashWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSplashWindow_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSplashWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSplashWindow_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSplashWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSplashWindow_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  FXSplashWindow_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_show__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  FXSplashWindow_show(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXSplashWindow_show(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSplashWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXSplashWindow_show__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSplashWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXSplashWindow_show__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "show", 
+    "    void show()\n"
+    "    void show(FXuint placement)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_maximize(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","maximize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXSplashWindow_maximize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_minimize(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","minimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXSplashWindow_minimize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_restore(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXSplashWindow_restore(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplashWindow_close(int argc, VALUE *argv, VALUE self) {
+  FXSplashWindow *arg1 = (FXSplashWindow *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplashWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplashWindow *","close", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplashWindow * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXSplashWindow_close(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_FXCompositeTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *)  ((FXWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXPopupTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXTopWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FXShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXShell *) x));
+}
+static void *_p_FXRootWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXRootWindow *) x));
+}
+static void *_p_FXPopupTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXTopWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXRegistryTo_p_FXSettings(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXSettings *)  ((FXRegistry *) x));
+}
+static void *_p_FXFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FXPopupTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXMainWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXCompositeTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXCursor *) x));
+}
+static void *_p_FXDrawableTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXDrawable *) x));
+}
+static void *_p_FXFontTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXFont *) x));
+}
+static void *_p_FXVisualTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXVisual *) x));
+}
+static void *_p_FXCURCursorTo_p_FXCursor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXCursor *)  ((FXCURCursor *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXCursor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXCursor *)  ((FXGIFCursor *) x));
+}
+static void *_p_FXFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FXIdTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXId *) x));
+}
+static void *_p_FXPopupTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXAccelTableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXAccelTable *) x));
+}
+static void *_p_FXAppTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXApp *) x));
+}
+static void *_p_FXIconDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXIconDict *) x));
+}
+static void *_p_FXWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXCompositeTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXRootWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXFileDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXFileDict *) x));
+}
+static void *_p_FXDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDict *) x));
+}
+static void *_p_FXShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXStringDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXStringDict *) x));
+}
+static void *_p_FXRegistryTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *)(FXSettings *) ((FXRegistry *) x));
+}
+static void *_p_FXCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXDrawableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXDrawable *) x));
+}
+static void *_p_FXDelegatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDelegator *) x));
+}
+static void *_p_FXFontTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXFont *) x));
+}
+static void *_p_FXSettingsTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXSettings *) x));
+}
+static void *_p_FXVisualTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXVisual *) x));
+}
+static void *_p_FXDocumentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDocument *) x));
+}
+static void *_p_FXRecentFilesTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXRecentFiles *) x));
+}
+static void *_p_FXDebugTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDebugTarget *) x));
+}
+static void *_p_FXDataTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDataTarget *) x));
+}
+static void *_p_FXTranslatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXTranslator *) x));
+}
+static void *_p_FXFileStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXFileStream *) x));
+}
+static void *_p_FXMemoryStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXMemoryStream *) x));
+}
+static void *_p_p_FXCompositeTo_p_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow **)  ((FXComposite **) x));
+}
+static void *_p_p_FXShellTo_p_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow **) (FXComposite *) ((FXShell **) x));
+}
+static void *_p_p_FXRootWindowTo_p_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow **) (FXComposite *) ((FXRootWindow **) x));
+}
+static void *_p_p_FXPopupTo_p_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow **) (FXComposite *)(FXShell *) ((FXPopup **) x));
+}
+static void *_p_p_FXTopWindowTo_p_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow **) (FXComposite *)(FXShell *) ((FXTopWindow **) x));
+}
+static void *_p_p_FXMainWindowTo_p_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow **) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow **) x));
+}
+static void *_p_p_FXSplashWindowTo_p_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow **) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow **) x));
+}
+static void *_p_p_FXFrameTo_p_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow **)  ((FXFrame **) x));
+}
+static void *_p_FXMainWindowTo_p_FXTopWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTopWindow *)  ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXTopWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTopWindow *)  ((FXSplashWindow *) x));
+}
+static void *_p_FXCompositeTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXComposite *) x));
+}
+static void *_p_FXShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXRootWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXPopupTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXTopWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXFrame *) x));
+}
+static void *_p_FXFileDictTo_p_FXDict(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDict *)  ((FXFileDict *) x));
+}
+static void *_p_FXIconDictTo_p_FXDict(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDict *)  ((FXIconDict *) x));
+}
+static void *_p_FXRegistryTo_p_FXDict(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDict *) (FXSettings *) ((FXRegistry *) x));
+}
+static void *_p_FXStringDictTo_p_FXDict(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDict *)  ((FXStringDict *) x));
+}
+static void *_p_FXSettingsTo_p_FXDict(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDict *)  ((FXSettings *) x));
+}
+static void *_p_FXPopupTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *)  ((FXPopup *) x));
+}
+static void *_p_FXTopWindowTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *)  ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *) ((FXSplashWindow *) x));
+}
+static swig_type_info _swigt__p_FXAccelTable = {"_p_FXAccelTable", "FXAccelTable *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXApp = {"_p_FXApp", "FXApp *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXBitmap = {"_p_FXBitmap", "FXBitmap *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXCURCursor = {"_p_FXCURCursor", "FXCURCursor *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXChore = {"_p_FXChore", "FXChore *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXComposeContext = {"_p_FXComposeContext", "FXComposeContext *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXComposite = {"_p_FXComposite", "FXComposite *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXCursor = {"_p_FXCursor", "FXCursor *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDataTarget = {"_p_FXDataTarget", "FXDataTarget *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDebugTarget = {"_p_FXDebugTarget", "FXDebugTarget *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDelegator = {"_p_FXDelegator", "FXDelegator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDict = {"_p_FXDict", "FXDict *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDocument = {"_p_FXDocument", "FXDocument *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDrawable = {"_p_FXDrawable", "FXDrawable *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXEvent = {"_p_FXEvent", "FXEvent *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFileAssoc = {"_p_FXFileAssoc", "FXFileAssoc *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFileDict = {"_p_FXFileDict", "FXFileDict *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFileStream = {"_p_FXFileStream", "FXFileStream *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFont = {"_p_FXFont", "FXFont *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFontDesc = {"_p_FXFontDesc", "FXFontDesc *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFrame = {"_p_FXFrame", "FXFrame *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGIFCursor = {"_p_FXGIFCursor", "FXGIFCursor *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXID = {"_p_FXID", "FXID *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXIcon = {"_p_FXIcon", "FXIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXIconDict = {"_p_FXIconDict", "FXIconDict *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXIconSource = {"_p_FXIconSource", "FXIconSource *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXId = {"_p_FXId", "FXId *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMainWindow = {"_p_FXMainWindow", "FXMainWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMemoryStream = {"_p_FXMemoryStream", "FXMemoryStream *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMutex = {"_p_FXMutex", "FXMutex *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXObject = {"_p_FXObject", "FXObject *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXPoint = {"_p_FXPoint", "FXPoint *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXPopup = {"_p_FXPopup", "FXPopup *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRecentFiles = {"_p_FXRecentFiles", "FXRecentFiles *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRectangle = {"_p_FXRectangle", "FXRectangle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRegion = {"_p_FXRegion", "FXRegion *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRegistry = {"_p_FXRegistry", "FXRegistry *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRootWindow = {"_p_FXRootWindow", "FXRootWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXSettings = {"_p_FXSettings", "FXSettings *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXShell = {"_p_FXShell", "FXShell *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXSize = {"_p_FXSize", "FXSize *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXSplashWindow = {"_p_FXSplashWindow", "FXSplashWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXStream = {"_p_FXStream", "FXStream *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXString = {"_p_FXString", "FXString *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXStringDict = {"_p_FXStringDict", "FXStringDict *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXTextCodec = {"_p_FXTextCodec", "FXTextCodec *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXTimer = {"_p_FXTimer", "FXTimer *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXTopWindow = {"_p_FXTopWindow", "FXTopWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXTranslator = {"_p_FXTranslator", "FXTranslator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXVisual = {"_p_FXVisual", "FXVisual *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXWindow = {"_p_FXWindow", "FXWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_char = {"_p_char", "char *|FXchar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "double *|FXdouble *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_float = {"_p_float", "float *|FXfloat *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "FXint *|int *|FXInputHandle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_long = {"_p_long", "long *|FXTime *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_FXWindow = {"_p_p_FXWindow", "FXWindow **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_FXComposite = {"_p_p_FXComposite", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_p_FXShell = {"_p_p_FXShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_p_FXRootWindow = {"_p_p_FXRootWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_p_FXPopup = {"_p_p_FXPopup", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_p_FXTopWindow = {"_p_p_FXTopWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_p_FXMainWindow = {"_p_p_FXMainWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_p_FXSplashWindow = {"_p_p_FXSplashWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_p_FXFrame = {"_p_p_FXFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **|FXchar **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_short = {"_p_short", "short *|FXshort *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "FXuchar *|unsigned char *|FXbool *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "FXwchar *|FXDragType *|unsigned int *|FXuint *|FXColor *|FXSelector *|FXHotKey *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|FXuval *|FXPixel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|FXushort *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_FXAccelTable,
+  &_swigt__p_FXApp,
+  &_swigt__p_FXBitmap,
+  &_swigt__p_FXCURCursor,
+  &_swigt__p_FXChore,
+  &_swigt__p_FXComposeContext,
+  &_swigt__p_FXComposite,
+  &_swigt__p_FXCursor,
+  &_swigt__p_FXDataTarget,
+  &_swigt__p_FXDebugTarget,
+  &_swigt__p_FXDelegator,
+  &_swigt__p_FXDict,
+  &_swigt__p_FXDocument,
+  &_swigt__p_FXDrawable,
+  &_swigt__p_FXEvent,
+  &_swigt__p_FXFileAssoc,
+  &_swigt__p_FXFileDict,
+  &_swigt__p_FXFileStream,
+  &_swigt__p_FXFont,
+  &_swigt__p_FXFontDesc,
+  &_swigt__p_FXFrame,
+  &_swigt__p_FXGIFCursor,
+  &_swigt__p_FXID,
+  &_swigt__p_FXIcon,
+  &_swigt__p_FXIconDict,
+  &_swigt__p_FXIconSource,
+  &_swigt__p_FXId,
+  &_swigt__p_FXMainWindow,
+  &_swigt__p_FXMemoryStream,
+  &_swigt__p_FXMutex,
+  &_swigt__p_FXObject,
+  &_swigt__p_FXPoint,
+  &_swigt__p_FXPopup,
+  &_swigt__p_FXRecentFiles,
+  &_swigt__p_FXRectangle,
+  &_swigt__p_FXRegion,
+  &_swigt__p_FXRegistry,
+  &_swigt__p_FXRootWindow,
+  &_swigt__p_FXSettings,
+  &_swigt__p_FXShell,
+  &_swigt__p_FXSize,
+  &_swigt__p_FXSplashWindow,
+  &_swigt__p_FXStream,
+  &_swigt__p_FXString,
+  &_swigt__p_FXStringDict,
+  &_swigt__p_FXTextCodec,
+  &_swigt__p_FXTimer,
+  &_swigt__p_FXTopWindow,
+  &_swigt__p_FXTranslator,
+  &_swigt__p_FXVisual,
+  &_swigt__p_FXWindow,
+  &_swigt__p_char,
+  &_swigt__p_double,
+  &_swigt__p_float,
+  &_swigt__p_int,
+  &_swigt__p_long,
+  &_swigt__p_p_FXComposite,
+  &_swigt__p_p_FXFrame,
+  &_swigt__p_p_FXMainWindow,
+  &_swigt__p_p_FXPopup,
+  &_swigt__p_p_FXRootWindow,
+  &_swigt__p_p_FXShell,
+  &_swigt__p_p_FXSplashWindow,
+  &_swigt__p_p_FXTopWindow,
+  &_swigt__p_p_FXWindow,
+  &_swigt__p_p_char,
+  &_swigt__p_short,
+  &_swigt__p_unsigned_char,
+  &_swigt__p_unsigned_int,
+  &_swigt__p_unsigned_long,
+  &_swigt__p_unsigned_short,
+  &_swigt__p_void,
+};
+
+static swig_cast_info _swigc__p_FXAccelTable[] = {  {&_swigt__p_FXAccelTable, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXApp[] = {  {&_swigt__p_FXApp, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBitmap[] = {  {&_swigt__p_FXBitmap, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCURCursor[] = {  {&_swigt__p_FXCURCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXChore[] = {  {&_swigt__p_FXChore, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComposeContext[] = {  {&_swigt__p_FXComposeContext, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComposite[] = {  {&_swigt__p_FXComposite, 0, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXComposite, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCursor[] = {  {&_swigt__p_FXCursor, 0, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXCursor, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXCursor, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDataTarget[] = {  {&_swigt__p_FXDataTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDebugTarget[] = {  {&_swigt__p_FXDebugTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDelegator[] = {  {&_swigt__p_FXDelegator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDict[] = {  {&_swigt__p_FXDict, 0, 0, 0},  {&_swigt__p_FXFileDict, _p_FXFileDictTo_p_FXDict, 0, 0},  {&_swigt__p_FXIconDict, _p_FXIconDictTo_p_FXDict, 0, 0},  {&_swigt__p_FXRegistry, _p_FXRegistryTo_p_FXDict, 0, 0},  {&_swigt__p_FXStringDict, _p_FXStringDictTo_p_FXDict, 0, 0},  {&_swigt__p_FXSettings, _p_FXSettingsTo_p_FXDict, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDocument[] = {  {&_swigt__p_FXDocument, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDrawable[] = {  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDrawable, 0, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXDrawable, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXEvent[] = {  {&_swigt__p_FXEvent, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileAssoc[] = {  {&_swigt__p_FXFileAssoc, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileDict[] = {  {&_swigt__p_FXFileDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileStream[] = {  {&_swigt__p_FXFileStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFont[] = {  {&_swigt__p_FXFont, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFontDesc[] = {  {&_swigt__p_FXFontDesc, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFrame[] = {  {&_swigt__p_FXFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGIFCursor[] = {  {&_swigt__p_FXGIFCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXID[] = {  {&_swigt__p_FXID, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIcon[] = {  {&_swigt__p_FXIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIconDict[] = {  {&_swigt__p_FXIconDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIconSource[] = {  {&_swigt__p_FXIconSource, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXId[] = {  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXId, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXId, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXId, 0, 0},  {&_swigt__p_FXId, 0, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXId, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXId, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXId, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMainWindow[] = {  {&_swigt__p_FXMainWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMemoryStream[] = {  {&_swigt__p_FXMemoryStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMutex[] = {  {&_swigt__p_FXMutex, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXObject[] = {  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXObject, 0, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXObject, 0, 0},  {&_swigt__p_FXAccelTable, _p_FXAccelTableTo_p_FXObject, 0, 0},  {&_swigt__p_FXDict, _p_FXDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXIconDict, _p_FXIconDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileDict, _p_FXFileDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXId, _p_FXIdTo_p_FXObject, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXObject, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXStringDict, _p_FXStringDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXRegistry, _p_FXRegistryTo_p_FXObject, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXObject, 0, 0},  {&_swigt__p_FXDelegator, _p_FXDelegatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXSettings, _p_FXSettingsTo_p_FXObject, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXObject, 0, 0},  {&_swigt__p_FXApp, _p_FXAppTo_p_FXObject, 0, 0},  {&_swigt__p_FXDocument, _p_FXDocumentTo_p_FXObject, 0, 0},  {&_swigt__p_FXRecentFiles, _p_FXRecentFilesTo_p_FXObject, 0, 0},  {&_swigt__p_FXDebugTarget, _p_FXDebugTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDataTarget, _p_FXDataTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXTranslator, _p_FXTranslatorTo_p_FXObject, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPoint[] = {  {&_swigt__p_FXPoint, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPopup[] = {  {&_swigt__p_FXPopup, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRecentFiles[] = {  {&_swigt__p_FXRecentFiles, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRectangle[] = {  {&_swigt__p_FXRectangle, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegion[] = {  {&_swigt__p_FXRegion, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegistry[] = {  {&_swigt__p_FXRegistry, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRootWindow[] = {  {&_swigt__p_FXRootWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSettings[] = {  {&_swigt__p_FXRegistry, _p_FXRegistryTo_p_FXSettings, 0, 0},  {&_swigt__p_FXSettings, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShell[] = {  {&_swigt__p_FXShell, 0, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXShell, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXShell, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXShell, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXShell, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSize[] = {  {&_swigt__p_FXSize, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplashWindow[] = {  {&_swigt__p_FXSplashWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStream[] = {  {&_swigt__p_FXFileStream, _p_FXFileStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXMemoryStream, _p_FXMemoryStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXString[] = {  {&_swigt__p_FXString, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStringDict[] = {  {&_swigt__p_FXStringDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTextCodec[] = {  {&_swigt__p_FXTextCodec, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTimer[] = {  {&_swigt__p_FXTimer, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTopWindow[] = {  {&_swigt__p_FXTopWindow, 0, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXTopWindow, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXTopWindow, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTranslator[] = {  {&_swigt__p_FXTranslator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVisual[] = {  {&_swigt__p_FXVisual, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXWindow[] = {  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXWindow, 0, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXWindow, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_FXComposite[] = {{&_swigt__p_p_FXComposite, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_FXShell[] = {{&_swigt__p_p_FXShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_FXRootWindow[] = {{&_swigt__p_p_FXRootWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_FXPopup[] = {{&_swigt__p_p_FXPopup, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_FXTopWindow[] = {{&_swigt__p_p_FXTopWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_FXMainWindow[] = {{&_swigt__p_p_FXMainWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_FXSplashWindow[] = {{&_swigt__p_p_FXSplashWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_FXFrame[] = {{&_swigt__p_p_FXFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_FXWindow[] = {  {&_swigt__p_p_FXComposite, _p_p_FXCompositeTo_p_p_FXWindow, 0, 0},  {&_swigt__p_p_FXShell, _p_p_FXShellTo_p_p_FXWindow, 0, 0},  {&_swigt__p_p_FXWindow, 0, 0, 0},  {&_swigt__p_p_FXRootWindow, _p_p_FXRootWindowTo_p_p_FXWindow, 0, 0},  {&_swigt__p_p_FXPopup, _p_p_FXPopupTo_p_p_FXWindow, 0, 0},  {&_swigt__p_p_FXTopWindow, _p_p_FXTopWindowTo_p_p_FXWindow, 0, 0},  {&_swigt__p_p_FXMainWindow, _p_p_FXMainWindowTo_p_p_FXWindow, 0, 0},  {&_swigt__p_p_FXSplashWindow, _p_p_FXSplashWindowTo_p_p_FXWindow, 0, 0},  {&_swigt__p_p_FXFrame, _p_p_FXFrameTo_p_p_FXWindow, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
+
+static swig_cast_info *swig_cast_initial[] = {
+  _swigc__p_FXAccelTable,
+  _swigc__p_FXApp,
+  _swigc__p_FXBitmap,
+  _swigc__p_FXCURCursor,
+  _swigc__p_FXChore,
+  _swigc__p_FXComposeContext,
+  _swigc__p_FXComposite,
+  _swigc__p_FXCursor,
+  _swigc__p_FXDataTarget,
+  _swigc__p_FXDebugTarget,
+  _swigc__p_FXDelegator,
+  _swigc__p_FXDict,
+  _swigc__p_FXDocument,
+  _swigc__p_FXDrawable,
+  _swigc__p_FXEvent,
+  _swigc__p_FXFileAssoc,
+  _swigc__p_FXFileDict,
+  _swigc__p_FXFileStream,
+  _swigc__p_FXFont,
+  _swigc__p_FXFontDesc,
+  _swigc__p_FXFrame,
+  _swigc__p_FXGIFCursor,
+  _swigc__p_FXID,
+  _swigc__p_FXIcon,
+  _swigc__p_FXIconDict,
+  _swigc__p_FXIconSource,
+  _swigc__p_FXId,
+  _swigc__p_FXMainWindow,
+  _swigc__p_FXMemoryStream,
+  _swigc__p_FXMutex,
+  _swigc__p_FXObject,
+  _swigc__p_FXPoint,
+  _swigc__p_FXPopup,
+  _swigc__p_FXRecentFiles,
+  _swigc__p_FXRectangle,
+  _swigc__p_FXRegion,
+  _swigc__p_FXRegistry,
+  _swigc__p_FXRootWindow,
+  _swigc__p_FXSettings,
+  _swigc__p_FXShell,
+  _swigc__p_FXSize,
+  _swigc__p_FXSplashWindow,
+  _swigc__p_FXStream,
+  _swigc__p_FXString,
+  _swigc__p_FXStringDict,
+  _swigc__p_FXTextCodec,
+  _swigc__p_FXTimer,
+  _swigc__p_FXTopWindow,
+  _swigc__p_FXTranslator,
+  _swigc__p_FXVisual,
+  _swigc__p_FXWindow,
+  _swigc__p_char,
+  _swigc__p_double,
+  _swigc__p_float,
+  _swigc__p_int,
+  _swigc__p_long,
+  _swigc__p_p_FXComposite,
+  _swigc__p_p_FXFrame,
+  _swigc__p_p_FXMainWindow,
+  _swigc__p_p_FXPopup,
+  _swigc__p_p_FXRootWindow,
+  _swigc__p_p_FXShell,
+  _swigc__p_p_FXSplashWindow,
+  _swigc__p_p_FXTopWindow,
+  _swigc__p_p_FXWindow,
+  _swigc__p_p_char,
+  _swigc__p_short,
+  _swigc__p_unsigned_char,
+  _swigc__p_unsigned_int,
+  _swigc__p_unsigned_long,
+  _swigc__p_unsigned_short,
+  _swigc__p_void,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned statically to an initial
+ * array. We just loop through that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded.
+ * There are three cases to handle:
+ *  1) If the cast->type has already been loaded AND the type we are adding
+ *     casting info to has not been loaded (it is in this module), THEN we
+ *     replace the cast->type pointer with the type pointer that has already
+ *     been loaded.
+ *  2) If BOTH types (the one we are adding casting info to, and the
+ *     cast->type) are loaded, THEN the cast info has already been loaded by
+ *     the previous module so we just ignore it.
+ *  3) Finally, if cast->type has not already been loaded, then we add that
+ *     swig_cast_info to the linked list (because the cast->type) pointer will
+ *     be correct.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* c-mode */
+#endif
+#endif
+
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+  size_t i;
+  swig_module_info *module_head, *iter;
+  int init;
+
+  /* check to see if the circular list has been setup, if not, set it up */
+  if (swig_module.next==0) {
+    /* Initialize the swig_module */
+    swig_module.type_initial = swig_type_initial;
+    swig_module.cast_initial = swig_cast_initial;
+    swig_module.next = &swig_module;
+    init = 1;
+  } else {
+    init = 0;
+  }
+
+  /* Try and load any already created modules */
+  module_head = SWIG_GetModule(clientdata);
+  if (!module_head) {
+    /* This is the first module loaded for this interpreter */
+    /* so set the swig module into the interpreter */
+    SWIG_SetModule(clientdata, &swig_module);
+  } else {
+    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+    iter=module_head;
+    do {
+      if (iter==&swig_module) {
+        /* Our module is already in the list, so there's nothing more to do. */
+        return;
+      }
+      iter=iter->next;
+    } while (iter!= module_head);
+
+    /* otherwise we must add our module into the list */
+    swig_module.next = module_head->next;
+    module_head->next = &swig_module;
+  }
+
+  /* When multiple interpreters are used, a module could have already been initialized in
+     a different interpreter, but not yet have a pointer in this interpreter.
+     In this case, we do not want to continue adding types... everything should be
+     set up already */
+  if (init == 0) return;
+
+  /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+  for (i = 0; i < swig_module.size; ++i) {
+    swig_type_info *type = 0;
+    swig_type_info *ret;
+    swig_cast_info *cast;
+
+#ifdef SWIGRUNTIME_DEBUG
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+
+    /* if there is another module already loaded */
+    if (swig_module.next != &swig_module) {
+      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
+    }
+    if (type) {
+      /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+      if (swig_module.type_initial[i]->clientdata) {
+	type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+      }
+    } else {
+      type = swig_module.type_initial[i];
+    }
+
+    /* Insert casting types */
+    cast = swig_module.cast_initial[i];
+    while (cast->type) {
+
+      /* Don't need to add information already in the list */
+      ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+      if (swig_module.next != &swig_module) {
+        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+      }
+      if (ret) {
+	if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+	  cast->type = ret;
+	  ret = 0;
+	} else {
+	  /* Check for casting already in the list */
+	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+	  if (!ocast) ret = 0;
+	}
+      }
+
+      if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+        if (type->cast) {
+          type->cast->prev = cast;
+          cast->next = type->cast;
+        }
+        type->cast = cast;
+      }
+      cast++;
+    }
+    /* Set entry in modules->types array equal to the type */
+    swig_module.types[i] = type;
+  }
+  swig_module.types[i] = 0;
+
+#ifdef SWIGRUNTIME_DEBUG
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+  for (i = 0; i < swig_module.size; ++i) {
+    int j = 0;
+    swig_cast_info *cast = swig_module.cast_initial[i];
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    while (cast->type) {
+      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+      cast++;
+      ++j;
+    }
+  printf("---- Total casts: %d\n",j);
+  }
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types.  It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+  size_t i;
+  swig_cast_info *equiv;
+  static int init_run = 0;
+
+  if (init_run) return;
+  init_run = 1;
+
+  for (i = 0; i < swig_module.size; i++) {
+    if (swig_module.types[i]->clientdata) {
+      equiv = swig_module.types[i]->cast;
+      while (equiv) {
+        if (!equiv->converter) {
+          if (equiv->type && !equiv->type->clientdata)
+            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+        }
+        equiv = equiv->next;
+      }
+    }
+  }
+}
+
+#ifdef __cplusplus
+#if 0
+{ /* c-mode */
+#endif
+}
+#endif
+
+/*
+
+*/
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void Init_core(void) {
+  size_t i;
+  
+  SWIG_InitRuntime();
+  mFox = rb_define_module("Fox");
+  
+  SWIG_InitializeModule(0);
+  for (i = 0; i < swig_module.size; i++) {
+    SWIG_define_class(swig_module.types[i]);
+  }
+  
+  SWIG_RubyInitializeTrackings();
+  rb_define_module_function(mFox, "setIgnoreExceptions", VALUEFUNC(_wrap_setIgnoreExceptions), -1);
+  rb_define_const(mFox, "TRUE", SWIG_From_int(static_cast< int >(1)));
+  rb_define_const(mFox, "FALSE", SWIG_From_int(static_cast< int >(0)));
+  rb_define_const(mFox, "MAYBE", SWIG_From_int(static_cast< int >(2)));
+  rb_define_const(mFox, "NULL", SWIG_From_int(static_cast< int >(0)));
+  rb_define_const(mFox, "SEL_NONE", SWIG_From_int(static_cast< int >(SEL_NONE)));
+  rb_define_const(mFox, "SEL_KEYPRESS", SWIG_From_int(static_cast< int >(SEL_KEYPRESS)));
+  rb_define_const(mFox, "SEL_KEYRELEASE", SWIG_From_int(static_cast< int >(SEL_KEYRELEASE)));
+  rb_define_const(mFox, "SEL_LEFTBUTTONPRESS", SWIG_From_int(static_cast< int >(SEL_LEFTBUTTONPRESS)));
+  rb_define_const(mFox, "SEL_LEFTBUTTONRELEASE", SWIG_From_int(static_cast< int >(SEL_LEFTBUTTONRELEASE)));
+  rb_define_const(mFox, "SEL_MIDDLEBUTTONPRESS", SWIG_From_int(static_cast< int >(SEL_MIDDLEBUTTONPRESS)));
+  rb_define_const(mFox, "SEL_MIDDLEBUTTONRELEASE", SWIG_From_int(static_cast< int >(SEL_MIDDLEBUTTONRELEASE)));
+  rb_define_const(mFox, "SEL_RIGHTBUTTONPRESS", SWIG_From_int(static_cast< int >(SEL_RIGHTBUTTONPRESS)));
+  rb_define_const(mFox, "SEL_RIGHTBUTTONRELEASE", SWIG_From_int(static_cast< int >(SEL_RIGHTBUTTONRELEASE)));
+  rb_define_const(mFox, "SEL_MOTION", SWIG_From_int(static_cast< int >(SEL_MOTION)));
+  rb_define_const(mFox, "SEL_ENTER", SWIG_From_int(static_cast< int >(SEL_ENTER)));
+  rb_define_const(mFox, "SEL_LEAVE", SWIG_From_int(static_cast< int >(SEL_LEAVE)));
+  rb_define_const(mFox, "SEL_FOCUSIN", SWIG_From_int(static_cast< int >(SEL_FOCUSIN)));
+  rb_define_const(mFox, "SEL_FOCUSOUT", SWIG_From_int(static_cast< int >(SEL_FOCUSOUT)));
+  rb_define_const(mFox, "SEL_KEYMAP", SWIG_From_int(static_cast< int >(SEL_KEYMAP)));
+  rb_define_const(mFox, "SEL_UNGRABBED", SWIG_From_int(static_cast< int >(SEL_UNGRABBED)));
+  rb_define_const(mFox, "SEL_PAINT", SWIG_From_int(static_cast< int >(SEL_PAINT)));
+  rb_define_const(mFox, "SEL_CREATE", SWIG_From_int(static_cast< int >(SEL_CREATE)));
+  rb_define_const(mFox, "SEL_DESTROY", SWIG_From_int(static_cast< int >(SEL_DESTROY)));
+  rb_define_const(mFox, "SEL_UNMAP", SWIG_From_int(static_cast< int >(SEL_UNMAP)));
+  rb_define_const(mFox, "SEL_MAP", SWIG_From_int(static_cast< int >(SEL_MAP)));
+  rb_define_const(mFox, "SEL_CONFIGURE", SWIG_From_int(static_cast< int >(SEL_CONFIGURE)));
+  rb_define_const(mFox, "SEL_SELECTION_LOST", SWIG_From_int(static_cast< int >(SEL_SELECTION_LOST)));
+  rb_define_const(mFox, "SEL_SELECTION_GAINED", SWIG_From_int(static_cast< int >(SEL_SELECTION_GAINED)));
+  rb_define_const(mFox, "SEL_SELECTION_REQUEST", SWIG_From_int(static_cast< int >(SEL_SELECTION_REQUEST)));
+  rb_define_const(mFox, "SEL_RAISED", SWIG_From_int(static_cast< int >(SEL_RAISED)));
+  rb_define_const(mFox, "SEL_LOWERED", SWIG_From_int(static_cast< int >(SEL_LOWERED)));
+  rb_define_const(mFox, "SEL_CLOSE", SWIG_From_int(static_cast< int >(SEL_CLOSE)));
+  rb_define_const(mFox, "SEL_DELETE", SWIG_From_int(static_cast< int >(SEL_DELETE)));
+  rb_define_const(mFox, "SEL_MINIMIZE", SWIG_From_int(static_cast< int >(SEL_MINIMIZE)));
+  rb_define_const(mFox, "SEL_RESTORE", SWIG_From_int(static_cast< int >(SEL_RESTORE)));
+  rb_define_const(mFox, "SEL_MAXIMIZE", SWIG_From_int(static_cast< int >(SEL_MAXIMIZE)));
+  rb_define_const(mFox, "SEL_UPDATE", SWIG_From_int(static_cast< int >(SEL_UPDATE)));
+  rb_define_const(mFox, "SEL_COMMAND", SWIG_From_int(static_cast< int >(SEL_COMMAND)));
+  rb_define_const(mFox, "SEL_CLICKED", SWIG_From_int(static_cast< int >(SEL_CLICKED)));
+  rb_define_const(mFox, "SEL_DOUBLECLICKED", SWIG_From_int(static_cast< int >(SEL_DOUBLECLICKED)));
+  rb_define_const(mFox, "SEL_TRIPLECLICKED", SWIG_From_int(static_cast< int >(SEL_TRIPLECLICKED)));
+  rb_define_const(mFox, "SEL_MOUSEWHEEL", SWIG_From_int(static_cast< int >(SEL_MOUSEWHEEL)));
+  rb_define_const(mFox, "SEL_CHANGED", SWIG_From_int(static_cast< int >(SEL_CHANGED)));
+  rb_define_const(mFox, "SEL_VERIFY", SWIG_From_int(static_cast< int >(SEL_VERIFY)));
+  rb_define_const(mFox, "SEL_DESELECTED", SWIG_From_int(static_cast< int >(SEL_DESELECTED)));
+  rb_define_const(mFox, "SEL_SELECTED", SWIG_From_int(static_cast< int >(SEL_SELECTED)));
+  rb_define_const(mFox, "SEL_INSERTED", SWIG_From_int(static_cast< int >(SEL_INSERTED)));
+  rb_define_const(mFox, "SEL_REPLACED", SWIG_From_int(static_cast< int >(SEL_REPLACED)));
+  rb_define_const(mFox, "SEL_DELETED", SWIG_From_int(static_cast< int >(SEL_DELETED)));
+  rb_define_const(mFox, "SEL_OPENED", SWIG_From_int(static_cast< int >(SEL_OPENED)));
+  rb_define_const(mFox, "SEL_CLOSED", SWIG_From_int(static_cast< int >(SEL_CLOSED)));
+  rb_define_const(mFox, "SEL_EXPANDED", SWIG_From_int(static_cast< int >(SEL_EXPANDED)));
+  rb_define_const(mFox, "SEL_COLLAPSED", SWIG_From_int(static_cast< int >(SEL_COLLAPSED)));
+  rb_define_const(mFox, "SEL_BEGINDRAG", SWIG_From_int(static_cast< int >(SEL_BEGINDRAG)));
+  rb_define_const(mFox, "SEL_ENDDRAG", SWIG_From_int(static_cast< int >(SEL_ENDDRAG)));
+  rb_define_const(mFox, "SEL_DRAGGED", SWIG_From_int(static_cast< int >(SEL_DRAGGED)));
+  rb_define_const(mFox, "SEL_LASSOED", SWIG_From_int(static_cast< int >(SEL_LASSOED)));
+  rb_define_const(mFox, "SEL_TIMEOUT", SWIG_From_int(static_cast< int >(SEL_TIMEOUT)));
+  rb_define_const(mFox, "SEL_SIGNAL", SWIG_From_int(static_cast< int >(SEL_SIGNAL)));
+  rb_define_const(mFox, "SEL_CLIPBOARD_LOST", SWIG_From_int(static_cast< int >(SEL_CLIPBOARD_LOST)));
+  rb_define_const(mFox, "SEL_CLIPBOARD_GAINED", SWIG_From_int(static_cast< int >(SEL_CLIPBOARD_GAINED)));
+  rb_define_const(mFox, "SEL_CLIPBOARD_REQUEST", SWIG_From_int(static_cast< int >(SEL_CLIPBOARD_REQUEST)));
+  rb_define_const(mFox, "SEL_CHORE", SWIG_From_int(static_cast< int >(SEL_CHORE)));
+  rb_define_const(mFox, "SEL_FOCUS_SELF", SWIG_From_int(static_cast< int >(SEL_FOCUS_SELF)));
+  rb_define_const(mFox, "SEL_FOCUS_RIGHT", SWIG_From_int(static_cast< int >(SEL_FOCUS_RIGHT)));
+  rb_define_const(mFox, "SEL_FOCUS_LEFT", SWIG_From_int(static_cast< int >(SEL_FOCUS_LEFT)));
+  rb_define_const(mFox, "SEL_FOCUS_DOWN", SWIG_From_int(static_cast< int >(SEL_FOCUS_DOWN)));
+  rb_define_const(mFox, "SEL_FOCUS_UP", SWIG_From_int(static_cast< int >(SEL_FOCUS_UP)));
+  rb_define_const(mFox, "SEL_FOCUS_NEXT", SWIG_From_int(static_cast< int >(SEL_FOCUS_NEXT)));
+  rb_define_const(mFox, "SEL_FOCUS_PREV", SWIG_From_int(static_cast< int >(SEL_FOCUS_PREV)));
+  rb_define_const(mFox, "SEL_DND_ENTER", SWIG_From_int(static_cast< int >(SEL_DND_ENTER)));
+  rb_define_const(mFox, "SEL_DND_LEAVE", SWIG_From_int(static_cast< int >(SEL_DND_LEAVE)));
+  rb_define_const(mFox, "SEL_DND_DROP", SWIG_From_int(static_cast< int >(SEL_DND_DROP)));
+  rb_define_const(mFox, "SEL_DND_MOTION", SWIG_From_int(static_cast< int >(SEL_DND_MOTION)));
+  rb_define_const(mFox, "SEL_DND_REQUEST", SWIG_From_int(static_cast< int >(SEL_DND_REQUEST)));
+  rb_define_const(mFox, "SEL_IO_READ", SWIG_From_int(static_cast< int >(SEL_IO_READ)));
+  rb_define_const(mFox, "SEL_IO_WRITE", SWIG_From_int(static_cast< int >(SEL_IO_WRITE)));
+  rb_define_const(mFox, "SEL_IO_EXCEPT", SWIG_From_int(static_cast< int >(SEL_IO_EXCEPT)));
+  rb_define_const(mFox, "SEL_PICKED", SWIG_From_int(static_cast< int >(SEL_PICKED)));
+  rb_define_const(mFox, "SEL_QUERY_TIP", SWIG_From_int(static_cast< int >(SEL_QUERY_TIP)));
+  rb_define_const(mFox, "SEL_QUERY_HELP", SWIG_From_int(static_cast< int >(SEL_QUERY_HELP)));
+  rb_define_const(mFox, "SEL_DOCKED", SWIG_From_int(static_cast< int >(SEL_DOCKED)));
+  rb_define_const(mFox, "SEL_FLOATED", SWIG_From_int(static_cast< int >(SEL_FLOATED)));
+  rb_define_const(mFox, "SEL_SESSION_NOTIFY", SWIG_From_int(static_cast< int >(SEL_SESSION_NOTIFY)));
+  rb_define_const(mFox, "SEL_SESSION_CLOSED", SWIG_From_int(static_cast< int >(SEL_SESSION_CLOSED)));
+  rb_define_const(mFox, "SEL_LAST", SWIG_From_int(static_cast< int >(SEL_LAST)));
+  rb_define_const(mFox, "SHIFTMASK", SWIG_From_int(static_cast< int >(SHIFTMASK)));
+  rb_define_const(mFox, "CAPSLOCKMASK", SWIG_From_int(static_cast< int >(CAPSLOCKMASK)));
+  rb_define_const(mFox, "CONTROLMASK", SWIG_From_int(static_cast< int >(CONTROLMASK)));
+  rb_define_const(mFox, "ALTMASK", SWIG_From_int(static_cast< int >(ALTMASK)));
+  rb_define_const(mFox, "METAMASK", SWIG_From_int(static_cast< int >(METAMASK)));
+  rb_define_const(mFox, "NUMLOCKMASK", SWIG_From_int(static_cast< int >(NUMLOCKMASK)));
+  rb_define_const(mFox, "SCROLLLOCKMASK", SWIG_From_int(static_cast< int >(SCROLLLOCKMASK)));
+  rb_define_const(mFox, "LEFTBUTTONMASK", SWIG_From_int(static_cast< int >(LEFTBUTTONMASK)));
+  rb_define_const(mFox, "MIDDLEBUTTONMASK", SWIG_From_int(static_cast< int >(MIDDLEBUTTONMASK)));
+  rb_define_const(mFox, "RIGHTBUTTONMASK", SWIG_From_int(static_cast< int >(RIGHTBUTTONMASK)));
+  rb_define_const(mFox, "LEFTBUTTON", SWIG_From_int(static_cast< int >(LEFTBUTTON)));
+  rb_define_const(mFox, "MIDDLEBUTTON", SWIG_From_int(static_cast< int >(MIDDLEBUTTON)));
+  rb_define_const(mFox, "RIGHTBUTTON", SWIG_From_int(static_cast< int >(RIGHTBUTTON)));
+  rb_define_const(mFox, "CROSSINGNORMAL", SWIG_From_int(static_cast< int >(CROSSINGNORMAL)));
+  rb_define_const(mFox, "CROSSINGGRAB", SWIG_From_int(static_cast< int >(CROSSINGGRAB)));
+  rb_define_const(mFox, "CROSSINGUNGRAB", SWIG_From_int(static_cast< int >(CROSSINGUNGRAB)));
+  rb_define_const(mFox, "VISIBILITYTOTAL", SWIG_From_int(static_cast< int >(VISIBILITYTOTAL)));
+  rb_define_const(mFox, "VISIBILITYPARTIAL", SWIG_From_int(static_cast< int >(VISIBILITYPARTIAL)));
+  rb_define_const(mFox, "VISIBILITYNONE", SWIG_From_int(static_cast< int >(VISIBILITYNONE)));
+  rb_define_const(mFox, "FILEMATCH_FILE_NAME", SWIG_From_int(static_cast< int >(FILEMATCH_FILE_NAME)));
+  rb_define_const(mFox, "FILEMATCH_NOESCAPE", SWIG_From_int(static_cast< int >(FILEMATCH_NOESCAPE)));
+  rb_define_const(mFox, "FILEMATCH_PERIOD", SWIG_From_int(static_cast< int >(FILEMATCH_PERIOD)));
+  rb_define_const(mFox, "FILEMATCH_LEADING_DIR", SWIG_From_int(static_cast< int >(FILEMATCH_LEADING_DIR)));
+  rb_define_const(mFox, "FILEMATCH_CASEFOLD", SWIG_From_int(static_cast< int >(FILEMATCH_CASEFOLD)));
+  rb_define_const(mFox, "DRAG_REJECT", SWIG_From_int(static_cast< int >(DRAG_REJECT)));
+  rb_define_const(mFox, "DRAG_ACCEPT", SWIG_From_int(static_cast< int >(DRAG_ACCEPT)));
+  rb_define_const(mFox, "DRAG_COPY", SWIG_From_int(static_cast< int >(DRAG_COPY)));
+  rb_define_const(mFox, "DRAG_MOVE", SWIG_From_int(static_cast< int >(DRAG_MOVE)));
+  rb_define_const(mFox, "DRAG_LINK", SWIG_From_int(static_cast< int >(DRAG_LINK)));
+  rb_define_const(mFox, "DRAG_PRIVATE", SWIG_From_int(static_cast< int >(DRAG_PRIVATE)));
+  rb_define_const(mFox, "FROM_SELECTION", SWIG_From_int(static_cast< int >(FROM_SELECTION)));
+  rb_define_const(mFox, "FROM_CLIPBOARD", SWIG_From_int(static_cast< int >(FROM_CLIPBOARD)));
+  rb_define_const(mFox, "FROM_DRAGNDROP", SWIG_From_int(static_cast< int >(FROM_DRAGNDROP)));
+  rb_define_const(mFox, "EXP_NEVER", SWIG_From_int(static_cast< int >(EXP_NEVER)));
+  rb_define_const(mFox, "EXP_ALWAYS", SWIG_From_int(static_cast< int >(EXP_ALWAYS)));
+  rb_define_const(mFox, "EXP_AUTO", SWIG_From_int(static_cast< int >(EXP_AUTO)));
+  rb_define_const(mFox, "SEARCH_FORWARD", SWIG_From_int(static_cast< int >(SEARCH_FORWARD)));
+  rb_define_const(mFox, "SEARCH_BACKWARD", SWIG_From_int(static_cast< int >(SEARCH_BACKWARD)));
+  rb_define_const(mFox, "SEARCH_NOWRAP", SWIG_From_int(static_cast< int >(SEARCH_NOWRAP)));
+  rb_define_const(mFox, "SEARCH_WRAP", SWIG_From_int(static_cast< int >(SEARCH_WRAP)));
+  rb_define_const(mFox, "SEARCH_EXACT", SWIG_From_int(static_cast< int >(SEARCH_EXACT)));
+  rb_define_const(mFox, "SEARCH_IGNORECASE", SWIG_From_int(static_cast< int >(SEARCH_IGNORECASE)));
+  rb_define_const(mFox, "SEARCH_REGEX", SWIG_From_int(static_cast< int >(SEARCH_REGEX)));
+  rb_define_const(mFox, "SEARCH_PREFIX", SWIG_From_int(static_cast< int >(SEARCH_PREFIX)));
+  rb_define_module_function(mFox, "MKUINT", VALUEFUNC(_wrap_MKUINT), -1);
+  rb_define_module_function(mFox, "FXSEL", VALUEFUNC(_wrap_FXSEL), -1);
+  rb_define_module_function(mFox, "FXSELTYPE", VALUEFUNC(_wrap_FXSELTYPE), -1);
+  rb_define_module_function(mFox, "FXSELID", VALUEFUNC(_wrap_FXSELID), -1);
+  rb_define_module_function(mFox, "FXRGB", VALUEFUNC(_wrap_FXRGB), -1);
+  rb_define_module_function(mFox, "FXRGBA", VALUEFUNC(_wrap_FXRGBA), -1);
+  rb_define_module_function(mFox, "FXREDVAL", VALUEFUNC(_wrap_FXREDVAL), -1);
+  rb_define_module_function(mFox, "FXGREENVAL", VALUEFUNC(_wrap_FXGREENVAL), -1);
+  rb_define_module_function(mFox, "FXBLUEVAL", VALUEFUNC(_wrap_FXBLUEVAL), -1);
+  rb_define_module_function(mFox, "FXALPHAVAL", VALUEFUNC(_wrap_FXALPHAVAL), -1);
+  rb_define_module_function(mFox, "FXRGBACOMPVAL", VALUEFUNC(_wrap_FXRGBACOMPVAL), -1);
+  rb_define_module_function(mFox, "fxsleep", VALUEFUNC(_wrap_fxsleep), -1);
+  rb_define_module_function(mFox, "fxfilematch", VALUEFUNC(_wrap_fxfilematch), -1);
+  rb_define_module_function(mFox, "makeHiliteColor", VALUEFUNC(_wrap_makeHiliteColor), -1);
+  rb_define_module_function(mFox, "makeShadowColor", VALUEFUNC(_wrap_makeShadowColor), -1);
+  rb_define_module_function(mFox, "fxcolorfromname", VALUEFUNC(_wrap_fxcolorfromname), -1);
+  rb_define_module_function(mFox, "fxnamefromcolor", VALUEFUNC(_wrap_fxnamefromcolor), -1);
+  rb_define_module_function(mFox, "fxrgb_to_hsv", VALUEFUNC(_wrap_fxrgb_to_hsv), -1);
+  rb_define_module_function(mFox, "fxhsv_to_rgb", VALUEFUNC(_wrap_fxhsv_to_rgb), -1);
+  rb_define_module_function(mFox, "fxisconsole", VALUEFUNC(_wrap_fxisconsole), -1);
+  rb_define_module_function(mFox, "fxversion", VALUEFUNC(_wrap_fxversion), -1);
+  rb_define_singleton_method(mFox, "fxTraceLevel", VALUEFUNC(_wrap_fxTraceLevel_get), 0);
+  rb_define_singleton_method(mFox, "fxTraceLevel=", VALUEFUNC(_wrap_fxTraceLevel_set), 1);
+  rb_define_const(mFox, "FXStreamDead", SWIG_From_int(static_cast< int >(FXStreamDead)));
+  rb_define_const(mFox, "FXStreamSave", SWIG_From_int(static_cast< int >(FXStreamSave)));
+  rb_define_const(mFox, "FXStreamLoad", SWIG_From_int(static_cast< int >(FXStreamLoad)));
+  rb_define_const(mFox, "FXStreamOK", SWIG_From_int(static_cast< int >(FXStreamOK)));
+  rb_define_const(mFox, "FXStreamEnd", SWIG_From_int(static_cast< int >(FXStreamEnd)));
+  rb_define_const(mFox, "FXStreamFull", SWIG_From_int(static_cast< int >(FXStreamFull)));
+  rb_define_const(mFox, "FXStreamNoWrite", SWIG_From_int(static_cast< int >(FXStreamNoWrite)));
+  rb_define_const(mFox, "FXStreamNoRead", SWIG_From_int(static_cast< int >(FXStreamNoRead)));
+  rb_define_const(mFox, "FXStreamFormat", SWIG_From_int(static_cast< int >(FXStreamFormat)));
+  rb_define_const(mFox, "FXStreamUnknown", SWIG_From_int(static_cast< int >(FXStreamUnknown)));
+  rb_define_const(mFox, "FXStreamAlloc", SWIG_From_int(static_cast< int >(FXStreamAlloc)));
+  rb_define_const(mFox, "FXStreamFailure", SWIG_From_int(static_cast< int >(FXStreamFailure)));
+  rb_define_const(mFox, "FXFromStart", SWIG_From_int(static_cast< int >(FXFromStart)));
+  rb_define_const(mFox, "FXFromCurrent", SWIG_From_int(static_cast< int >(FXFromCurrent)));
+  rb_define_const(mFox, "FXFromEnd", SWIG_From_int(static_cast< int >(FXFromEnd)));
+  
+  SwigClassFXStream.klass = rb_define_class_under(mFox, "FXStream", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXStream, (void *) &SwigClassFXStream);
+  rb_define_alloc_func(SwigClassFXStream.klass, _wrap_FXStream_allocate);
+  rb_define_method(SwigClassFXStream.klass, "initialize", VALUEFUNC(_wrap_new_FXStream), -1);
+  rb_define_method(SwigClassFXStream.klass, "open", VALUEFUNC(_wrap_FXStream_open), -1);
+  rb_define_method(SwigClassFXStream.klass, "getSpace", VALUEFUNC(_wrap_FXStream_getSpace), -1);
+  rb_define_method(SwigClassFXStream.klass, "setSpace", VALUEFUNC(_wrap_FXStream_setSpace), -1);
+  rb_define_method(SwigClassFXStream.klass, "status", VALUEFUNC(_wrap_FXStream_status), -1);
+  rb_define_method(SwigClassFXStream.klass, "eof?", VALUEFUNC(_wrap_FXStream_eofq___), -1);
+  rb_define_method(SwigClassFXStream.klass, "setError", VALUEFUNC(_wrap_FXStream_setError), -1);
+  rb_define_method(SwigClassFXStream.klass, "direction", VALUEFUNC(_wrap_FXStream_direction), -1);
+  rb_define_method(SwigClassFXStream.klass, "container", VALUEFUNC(_wrap_FXStream_container), -1);
+  rb_define_method(SwigClassFXStream.klass, "getPosition", VALUEFUNC(_wrap_FXStream_getPosition), -1);
+  rb_define_method(SwigClassFXStream.klass, "swapBytes", VALUEFUNC(_wrap_FXStream_swapBytes), -1);
+  rb_define_method(SwigClassFXStream.klass, "setBigEndian", VALUEFUNC(_wrap_FXStream_setBigEndian), -1);
+  rb_define_method(SwigClassFXStream.klass, "isBigEndian", VALUEFUNC(_wrap_FXStream_isBigEndian), -1);
+  rb_define_method(SwigClassFXStream.klass, "close", VALUEFUNC(_wrap_FXStream_close), -1);
+  rb_define_method(SwigClassFXStream.klass, "flush", VALUEFUNC(_wrap_FXStream_flush), -1);
+  rb_define_method(SwigClassFXStream.klass, "setPosition", VALUEFUNC(_wrap_FXStream_setPosition), -1);
+  SwigClassFXStream.mark = (void (*)(void *)) FXRbStream::markfunc;
+  SwigClassFXStream.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXStream.trackObjects = 0;
+  
+  SwigClassFXFileStream.klass = rb_define_class_under(mFox, "FXFileStream", ((swig_class *) SWIGTYPE_p_FXStream->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXFileStream, (void *) &SwigClassFXFileStream);
+  rb_define_alloc_func(SwigClassFXFileStream.klass, _wrap_FXFileStream_allocate);
+  rb_define_method(SwigClassFXFileStream.klass, "initialize", VALUEFUNC(_wrap_new_FXFileStream), -1);
+  rb_define_method(SwigClassFXFileStream.klass, "open", VALUEFUNC(_wrap_FXFileStream_open), -1);
+  rb_define_method(SwigClassFXFileStream.klass, "getPosition", VALUEFUNC(_wrap_FXFileStream_getPosition), -1);
+  rb_define_method(SwigClassFXFileStream.klass, "close", VALUEFUNC(_wrap_FXFileStream_close), -1);
+  rb_define_method(SwigClassFXFileStream.klass, "flush", VALUEFUNC(_wrap_FXFileStream_flush), -1);
+  rb_define_method(SwigClassFXFileStream.klass, "setPosition", VALUEFUNC(_wrap_FXFileStream_setPosition), -1);
+  SwigClassFXFileStream.mark = (void (*)(void *)) FXRbFileStream::markfunc;
+  SwigClassFXFileStream.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXFileStream.trackObjects = 0;
+  
+  SwigClassFXMemoryStream.klass = rb_define_class_under(mFox, "FXMemoryStream", ((swig_class *) SWIGTYPE_p_FXStream->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMemoryStream, (void *) &SwigClassFXMemoryStream);
+  rb_define_alloc_func(SwigClassFXMemoryStream.klass, _wrap_FXMemoryStream_allocate);
+  rb_define_method(SwigClassFXMemoryStream.klass, "initialize", VALUEFUNC(_wrap_new_FXMemoryStream), -1);
+  rb_define_method(SwigClassFXMemoryStream.klass, "open", VALUEFUNC(_wrap_FXMemoryStream_open), -1);
+  rb_define_method(SwigClassFXMemoryStream.klass, "takeBuffer", VALUEFUNC(_wrap_FXMemoryStream_takeBuffer), -1);
+  rb_define_method(SwigClassFXMemoryStream.klass, "giveBuffer", VALUEFUNC(_wrap_FXMemoryStream_giveBuffer), -1);
+  rb_define_method(SwigClassFXMemoryStream.klass, "getPosition", VALUEFUNC(_wrap_FXMemoryStream_getPosition), -1);
+  SwigClassFXMemoryStream.mark = (void (*)(void *)) FXRbMemoryStream::markfunc;
+  SwigClassFXMemoryStream.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXMemoryStream.trackObjects = 0;
+  
+  SwigClassFXSize.klass = rb_define_class_under(mFox, "FXSize", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXSize, (void *) &SwigClassFXSize);
+  rb_define_alloc_func(SwigClassFXSize.klass, _wrap_FXSize_allocate);
+  rb_define_method(SwigClassFXSize.klass, "initialize", VALUEFUNC(_wrap_new_FXSize), -1);
+  rb_define_method(SwigClassFXSize.klass, "w=", VALUEFUNC(_wrap_FXSize_w_set), -1);
+  rb_define_method(SwigClassFXSize.klass, "w", VALUEFUNC(_wrap_FXSize_w_get), -1);
+  rb_define_method(SwigClassFXSize.klass, "h=", VALUEFUNC(_wrap_FXSize_h_set), -1);
+  rb_define_method(SwigClassFXSize.klass, "h", VALUEFUNC(_wrap_FXSize_h_get), -1);
+  rb_define_method(SwigClassFXSize.klass, "empty?", VALUEFUNC(_wrap_FXSize_emptyq___), -1);
+  rb_define_method(SwigClassFXSize.klass, "==", VALUEFUNC(_wrap_FXSize___eq__), -1);
+  rb_define_method(SwigClassFXSize.klass, "-@", VALUEFUNC(_wrap_FXSize___neg__), -1);
+  rb_define_method(SwigClassFXSize.klass, "grow!", VALUEFUNC(_wrap_FXSize_growN___), -1);
+  rb_define_method(SwigClassFXSize.klass, "shrink!", VALUEFUNC(_wrap_FXSize_shrinkN___), -1);
+  rb_define_method(SwigClassFXSize.klass, "+", VALUEFUNC(_wrap_FXSize___add__), -1);
+  rb_define_method(SwigClassFXSize.klass, "-", VALUEFUNC(_wrap_FXSize___sub__), -1);
+  rb_define_method(SwigClassFXSize.klass, "*", VALUEFUNC(_wrap_FXSize___mul__), -1);
+  rb_define_method(SwigClassFXSize.klass, "/", VALUEFUNC(_wrap_FXSize___div__), -1);
+  SwigClassFXSize.mark = 0;
+  SwigClassFXSize.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXSize.trackObjects = 0;
+  
+  SwigClassFXPoint.klass = rb_define_class_under(mFox, "FXPoint", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXPoint, (void *) &SwigClassFXPoint);
+  rb_define_alloc_func(SwigClassFXPoint.klass, _wrap_FXPoint_allocate);
+  rb_define_method(SwigClassFXPoint.klass, "initialize", VALUEFUNC(_wrap_new_FXPoint), -1);
+  rb_define_method(SwigClassFXPoint.klass, "x=", VALUEFUNC(_wrap_FXPoint_x_set), -1);
+  rb_define_method(SwigClassFXPoint.klass, "x", VALUEFUNC(_wrap_FXPoint_x_get), -1);
+  rb_define_method(SwigClassFXPoint.klass, "y=", VALUEFUNC(_wrap_FXPoint_y_set), -1);
+  rb_define_method(SwigClassFXPoint.klass, "y", VALUEFUNC(_wrap_FXPoint_y_get), -1);
+  rb_define_method(SwigClassFXPoint.klass, "==", VALUEFUNC(_wrap_FXPoint___eq__), -1);
+  rb_define_method(SwigClassFXPoint.klass, "-@", VALUEFUNC(_wrap_FXPoint___neg__), -1);
+  rb_define_method(SwigClassFXPoint.klass, "+", VALUEFUNC(_wrap_FXPoint___add__), -1);
+  rb_define_method(SwigClassFXPoint.klass, "-", VALUEFUNC(_wrap_FXPoint___sub__), -1);
+  rb_define_method(SwigClassFXPoint.klass, "*", VALUEFUNC(_wrap_FXPoint___mul__), -1);
+  rb_define_method(SwigClassFXPoint.klass, "/", VALUEFUNC(_wrap_FXPoint___div__), -1);
+  SwigClassFXPoint.mark = 0;
+  SwigClassFXPoint.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXPoint.trackObjects = 0;
+  
+  SwigClassFXRectangle.klass = rb_define_class_under(mFox, "FXRectangle", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXRectangle, (void *) &SwigClassFXRectangle);
+  rb_define_alloc_func(SwigClassFXRectangle.klass, _wrap_FXRectangle_allocate);
+  rb_define_method(SwigClassFXRectangle.klass, "initialize", VALUEFUNC(_wrap_new_FXRectangle), -1);
+  rb_define_method(SwigClassFXRectangle.klass, "x=", VALUEFUNC(_wrap_FXRectangle_x_set), -1);
+  rb_define_method(SwigClassFXRectangle.klass, "x", VALUEFUNC(_wrap_FXRectangle_x_get), -1);
+  rb_define_method(SwigClassFXRectangle.klass, "y=", VALUEFUNC(_wrap_FXRectangle_y_set), -1);
+  rb_define_method(SwigClassFXRectangle.klass, "y", VALUEFUNC(_wrap_FXRectangle_y_get), -1);
+  rb_define_method(SwigClassFXRectangle.klass, "w=", VALUEFUNC(_wrap_FXRectangle_w_set), -1);
+  rb_define_method(SwigClassFXRectangle.klass, "w", VALUEFUNC(_wrap_FXRectangle_w_get), -1);
+  rb_define_method(SwigClassFXRectangle.klass, "h=", VALUEFUNC(_wrap_FXRectangle_h_set), -1);
+  rb_define_method(SwigClassFXRectangle.klass, "h", VALUEFUNC(_wrap_FXRectangle_h_get), -1);
+  rb_define_method(SwigClassFXRectangle.klass, "==", VALUEFUNC(_wrap_FXRectangle___eq__), -1);
+  rb_define_method(SwigClassFXRectangle.klass, "contains?", VALUEFUNC(_wrap_FXRectangle_containsq___), -1);
+  rb_define_method(SwigClassFXRectangle.klass, "overlaps?", VALUEFUNC(_wrap_FXRectangle_overlapsq___), -1);
+  rb_define_method(SwigClassFXRectangle.klass, "move!", VALUEFUNC(_wrap_FXRectangle_moveN___), -1);
+  rb_define_method(SwigClassFXRectangle.klass, "grow!", VALUEFUNC(_wrap_FXRectangle_growN___), -1);
+  rb_define_method(SwigClassFXRectangle.klass, "shrink!", VALUEFUNC(_wrap_FXRectangle_shrinkN___), -1);
+  rb_define_method(SwigClassFXRectangle.klass, "tl", VALUEFUNC(_wrap_FXRectangle_tl), -1);
+  rb_define_method(SwigClassFXRectangle.klass, "tr", VALUEFUNC(_wrap_FXRectangle_tr), -1);
+  rb_define_method(SwigClassFXRectangle.klass, "bl", VALUEFUNC(_wrap_FXRectangle_bl), -1);
+  rb_define_method(SwigClassFXRectangle.klass, "br", VALUEFUNC(_wrap_FXRectangle_br), -1);
+  rb_define_method(SwigClassFXRectangle.klass, "+", VALUEFUNC(_wrap_FXRectangle___add__), -1);
+  rb_define_method(SwigClassFXRectangle.klass, "*", VALUEFUNC(_wrap_FXRectangle___mul__), -1);
+  SwigClassFXRectangle.mark = 0;
+  SwigClassFXRectangle.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXRectangle.trackObjects = 0;
+  
+  SwigClassFXRegion.klass = rb_define_class_under(mFox, "FXRegion", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXRegion, (void *) &SwigClassFXRegion);
+  rb_define_alloc_func(SwigClassFXRegion.klass, _wrap_FXRegion_allocate);
+  rb_define_method(SwigClassFXRegion.klass, "initialize", VALUEFUNC(_wrap_new_FXRegion), -1);
+  rb_define_method(SwigClassFXRegion.klass, "empty?", VALUEFUNC(_wrap_FXRegion_emptyq___), -1);
+  rb_define_method(SwigClassFXRegion.klass, "contains?", VALUEFUNC(_wrap_FXRegion_containsq___), -1);
+  rb_define_method(SwigClassFXRegion.klass, "bounds", VALUEFUNC(_wrap_FXRegion_bounds), -1);
+  rb_define_method(SwigClassFXRegion.klass, "offset!", VALUEFUNC(_wrap_FXRegion_offsetN___), -1);
+  rb_define_method(SwigClassFXRegion.klass, "+", VALUEFUNC(_wrap_FXRegion___add__), -1);
+  rb_define_method(SwigClassFXRegion.klass, "*", VALUEFUNC(_wrap_FXRegion___mul__), -1);
+  rb_define_method(SwigClassFXRegion.klass, "-", VALUEFUNC(_wrap_FXRegion___sub__), -1);
+  rb_define_method(SwigClassFXRegion.klass, "^", VALUEFUNC(_wrap_FXRegion___xor__), -1);
+  rb_define_method(SwigClassFXRegion.klass, "==", VALUEFUNC(_wrap_FXRegion___eq__), -1);
+  rb_define_method(SwigClassFXRegion.klass, "reset", VALUEFUNC(_wrap_FXRegion_reset), -1);
+  SwigClassFXRegion.mark = 0;
+  SwigClassFXRegion.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXRegion.trackObjects = 0;
+  rb_define_const(mFox, "MINKEY", SWIG_From_int(static_cast< int >(MINKEY)));
+  rb_define_const(mFox, "MAXKEY", SWIG_From_int(static_cast< int >(MAXKEY)));
+  rb_define_const(mFox, "MINTYPE", SWIG_From_int(static_cast< int >(MINTYPE)));
+  rb_define_const(mFox, "MAXTYPE", SWIG_From_int(static_cast< int >(MAXTYPE)));
+  
+  SwigClassFXObject.klass = rb_define_class_under(mFox, "FXObject", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXObject, (void *) &SwigClassFXObject);
+  rb_define_alloc_func(SwigClassFXObject.klass, _wrap_FXObject_allocate);
+  rb_define_method(SwigClassFXObject.klass, "initialize", VALUEFUNC(_wrap_new_FXObject), -1);
+  rb_define_method(SwigClassFXObject.klass, "handle", VALUEFUNC(_wrap_FXObject_handle), -1);
+  rb_define_method(SwigClassFXObject.klass, "tryHandle", VALUEFUNC(_wrap_FXObject_tryHandle), -1);
+  rb_define_method(SwigClassFXObject.klass, "save", VALUEFUNC(_wrap_FXObject_save), -1);
+  rb_define_method(SwigClassFXObject.klass, "load", VALUEFUNC(_wrap_FXObject_load), -1);
+  SwigClassFXObject.mark = (void (*)(void *)) FXRbObject::markfunc;
+  SwigClassFXObject.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXObject.trackObjects = 0;
+  
+  SWIGTYPE_p_FXObject->dcast = (swig_dycast_func) FXObject_dynamic_cast;
+  
+  
+  SwigClassFXAccelTable.klass = rb_define_class_under(mFox, "FXAccelTable", ((swig_class *) SWIGTYPE_p_FXObject->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXAccelTable, (void *) &SwigClassFXAccelTable);
+  rb_define_alloc_func(SwigClassFXAccelTable.klass, _wrap_FXAccelTable_allocate);
+  rb_define_method(SwigClassFXAccelTable.klass, "initialize", VALUEFUNC(_wrap_new_FXAccelTable), -1);
+  rb_define_method(SwigClassFXAccelTable.klass, "onKeyPress", VALUEFUNC(_wrap_FXAccelTable_onKeyPress), -1);
+  rb_define_method(SwigClassFXAccelTable.klass, "onKeyRelease", VALUEFUNC(_wrap_FXAccelTable_onKeyRelease), -1);
+  rb_define_method(SwigClassFXAccelTable.klass, "addAccel", VALUEFUNC(_wrap_FXAccelTable_addAccel), -1);
+  rb_define_method(SwigClassFXAccelTable.klass, "removeAccel", VALUEFUNC(_wrap_FXAccelTable_removeAccel), -1);
+  rb_define_method(SwigClassFXAccelTable.klass, "hasAccel", VALUEFUNC(_wrap_FXAccelTable_hasAccel), -1);
+  rb_define_method(SwigClassFXAccelTable.klass, "targetOfAccel", VALUEFUNC(_wrap_FXAccelTable_targetOfAccel), -1);
+  rb_define_method(SwigClassFXAccelTable.klass, "save", VALUEFUNC(_wrap_FXAccelTable_save), -1);
+  rb_define_method(SwigClassFXAccelTable.klass, "load", VALUEFUNC(_wrap_FXAccelTable_load), -1);
+  SwigClassFXAccelTable.mark = (void (*)(void *)) FXRbAccelTable::markfunc;
+  SwigClassFXAccelTable.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXAccelTable.trackObjects = 0;
+  rb_define_module_function(mFox, "parseAccel", VALUEFUNC(_wrap_parseAccel), -1);
+  rb_define_module_function(mFox, "unparseAccel", VALUEFUNC(_wrap_unparseAccel), -1);
+  rb_define_module_function(mFox, "parseHotKey", VALUEFUNC(_wrap_parseHotKey), -1);
+  rb_define_module_function(mFox, "findHotKey", VALUEFUNC(_wrap_findHotKey), -1);
+  rb_define_module_function(mFox, "stripHotKey", VALUEFUNC(_wrap_stripHotKey), -1);
+  rb_define_const(mFox, "INPUT_NONE", SWIG_From_int(static_cast< int >(INPUT_NONE)));
+  rb_define_const(mFox, "INPUT_READ", SWIG_From_int(static_cast< int >(INPUT_READ)));
+  rb_define_const(mFox, "INPUT_WRITE", SWIG_From_int(static_cast< int >(INPUT_WRITE)));
+  rb_define_const(mFox, "INPUT_EXCEPT", SWIG_From_int(static_cast< int >(INPUT_EXCEPT)));
+  rb_define_const(mFox, "MODAL_FOR_NONE", SWIG_From_int(static_cast< int >(MODAL_FOR_NONE)));
+  rb_define_const(mFox, "MODAL_FOR_WINDOW", SWIG_From_int(static_cast< int >(MODAL_FOR_WINDOW)));
+  rb_define_const(mFox, "MODAL_FOR_POPUP", SWIG_From_int(static_cast< int >(MODAL_FOR_POPUP)));
+  rb_define_const(mFox, "DEF_ARROW_CURSOR", SWIG_From_int(static_cast< int >(DEF_ARROW_CURSOR)));
+  rb_define_const(mFox, "DEF_RARROW_CURSOR", SWIG_From_int(static_cast< int >(DEF_RARROW_CURSOR)));
+  rb_define_const(mFox, "DEF_TEXT_CURSOR", SWIG_From_int(static_cast< int >(DEF_TEXT_CURSOR)));
+  rb_define_const(mFox, "DEF_HSPLIT_CURSOR", SWIG_From_int(static_cast< int >(DEF_HSPLIT_CURSOR)));
+  rb_define_const(mFox, "DEF_VSPLIT_CURSOR", SWIG_From_int(static_cast< int >(DEF_VSPLIT_CURSOR)));
+  rb_define_const(mFox, "DEF_XSPLIT_CURSOR", SWIG_From_int(static_cast< int >(DEF_XSPLIT_CURSOR)));
+  rb_define_const(mFox, "DEF_SWATCH_CURSOR", SWIG_From_int(static_cast< int >(DEF_SWATCH_CURSOR)));
+  rb_define_const(mFox, "DEF_MOVE_CURSOR", SWIG_From_int(static_cast< int >(DEF_MOVE_CURSOR)));
+  rb_define_const(mFox, "DEF_DRAGH_CURSOR", SWIG_From_int(static_cast< int >(DEF_DRAGH_CURSOR)));
+  rb_define_const(mFox, "DEF_DRAGV_CURSOR", SWIG_From_int(static_cast< int >(DEF_DRAGV_CURSOR)));
+  rb_define_const(mFox, "DEF_DRAGTL_CURSOR", SWIG_From_int(static_cast< int >(DEF_DRAGTL_CURSOR)));
+  rb_define_const(mFox, "DEF_DRAGBR_CURSOR", SWIG_From_int(static_cast< int >(DEF_DRAGBR_CURSOR)));
+  rb_define_const(mFox, "DEF_DRAGTR_CURSOR", SWIG_From_int(static_cast< int >(DEF_DRAGTR_CURSOR)));
+  rb_define_const(mFox, "DEF_DRAGBL_CURSOR", SWIG_From_int(static_cast< int >(DEF_DRAGBL_CURSOR)));
+  rb_define_const(mFox, "DEF_DNDSTOP_CURSOR", SWIG_From_int(static_cast< int >(DEF_DNDSTOP_CURSOR)));
+  rb_define_const(mFox, "DEF_DNDCOPY_CURSOR", SWIG_From_int(static_cast< int >(DEF_DNDCOPY_CURSOR)));
+  rb_define_const(mFox, "DEF_DNDMOVE_CURSOR", SWIG_From_int(static_cast< int >(DEF_DNDMOVE_CURSOR)));
+  rb_define_const(mFox, "DEF_DNDLINK_CURSOR", SWIG_From_int(static_cast< int >(DEF_DNDLINK_CURSOR)));
+  rb_define_const(mFox, "DEF_CROSSHAIR_CURSOR", SWIG_From_int(static_cast< int >(DEF_CROSSHAIR_CURSOR)));
+  rb_define_const(mFox, "DEF_CORNERNE_CURSOR", SWIG_From_int(static_cast< int >(DEF_CORNERNE_CURSOR)));
+  rb_define_const(mFox, "DEF_CORNERNW_CURSOR", SWIG_From_int(static_cast< int >(DEF_CORNERNW_CURSOR)));
+  rb_define_const(mFox, "DEF_CORNERSE_CURSOR", SWIG_From_int(static_cast< int >(DEF_CORNERSE_CURSOR)));
+  rb_define_const(mFox, "DEF_CORNERSW_CURSOR", SWIG_From_int(static_cast< int >(DEF_CORNERSW_CURSOR)));
+  rb_define_const(mFox, "DEF_HELP_CURSOR", SWIG_From_int(static_cast< int >(DEF_HELP_CURSOR)));
+  rb_define_const(mFox, "DEF_HAND_CURSOR", SWIG_From_int(static_cast< int >(DEF_HAND_CURSOR)));
+  rb_define_const(mFox, "DEF_ROTATE_CURSOR", SWIG_From_int(static_cast< int >(DEF_ROTATE_CURSOR)));
+  rb_define_const(mFox, "DEF_WAIT_CURSOR", SWIG_From_int(static_cast< int >(DEF_WAIT_CURSOR)));
+  
+  SwigClassFXEvent.klass = rb_define_class_under(mFox, "FXEvent", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXEvent, (void *) &SwigClassFXEvent);
+  rb_define_alloc_func(SwigClassFXEvent.klass, _wrap_FXEvent_allocate);
+  rb_define_method(SwigClassFXEvent.klass, "initialize", VALUEFUNC(_wrap_new_FXEvent), -1);
+  rb_define_method(SwigClassFXEvent.klass, "type=", VALUEFUNC(_wrap_FXEvent_type_set), -1);
+  rb_define_method(SwigClassFXEvent.klass, "type", VALUEFUNC(_wrap_FXEvent_type_get), -1);
+  rb_define_method(SwigClassFXEvent.klass, "time=", VALUEFUNC(_wrap_FXEvent_time_set), -1);
+  rb_define_method(SwigClassFXEvent.klass, "time", VALUEFUNC(_wrap_FXEvent_time_get), -1);
+  rb_define_method(SwigClassFXEvent.klass, "win_x=", VALUEFUNC(_wrap_FXEvent_win_x_set), -1);
+  rb_define_method(SwigClassFXEvent.klass, "win_x", VALUEFUNC(_wrap_FXEvent_win_x_get), -1);
+  rb_define_method(SwigClassFXEvent.klass, "win_y=", VALUEFUNC(_wrap_FXEvent_win_y_set), -1);
+  rb_define_method(SwigClassFXEvent.klass, "win_y", VALUEFUNC(_wrap_FXEvent_win_y_get), -1);
+  rb_define_method(SwigClassFXEvent.klass, "root_x=", VALUEFUNC(_wrap_FXEvent_root_x_set), -1);
+  rb_define_method(SwigClassFXEvent.klass, "root_x", VALUEFUNC(_wrap_FXEvent_root_x_get), -1);
+  rb_define_method(SwigClassFXEvent.klass, "root_y=", VALUEFUNC(_wrap_FXEvent_root_y_set), -1);
+  rb_define_method(SwigClassFXEvent.klass, "root_y", VALUEFUNC(_wrap_FXEvent_root_y_get), -1);
+  rb_define_method(SwigClassFXEvent.klass, "state=", VALUEFUNC(_wrap_FXEvent_state_set), -1);
+  rb_define_method(SwigClassFXEvent.klass, "state", VALUEFUNC(_wrap_FXEvent_state_get), -1);
+  rb_define_method(SwigClassFXEvent.klass, "code=", VALUEFUNC(_wrap_FXEvent_code_set), -1);
+  rb_define_method(SwigClassFXEvent.klass, "code", VALUEFUNC(_wrap_FXEvent_code_get), -1);
+  rb_define_method(SwigClassFXEvent.klass, "text=", VALUEFUNC(_wrap_FXEvent_text_set), -1);
+  rb_define_method(SwigClassFXEvent.klass, "text", VALUEFUNC(_wrap_FXEvent_text_get), -1);
+  rb_define_method(SwigClassFXEvent.klass, "last_x=", VALUEFUNC(_wrap_FXEvent_last_x_set), -1);
+  rb_define_method(SwigClassFXEvent.klass, "last_x", VALUEFUNC(_wrap_FXEvent_last_x_get), -1);
+  rb_define_method(SwigClassFXEvent.klass, "last_y=", VALUEFUNC(_wrap_FXEvent_last_y_set), -1);
+  rb_define_method(SwigClassFXEvent.klass, "last_y", VALUEFUNC(_wrap_FXEvent_last_y_get), -1);
+  rb_define_method(SwigClassFXEvent.klass, "click_x=", VALUEFUNC(_wrap_FXEvent_click_x_set), -1);
+  rb_define_method(SwigClassFXEvent.klass, "click_x", VALUEFUNC(_wrap_FXEvent_click_x_get), -1);
+  rb_define_method(SwigClassFXEvent.klass, "click_y=", VALUEFUNC(_wrap_FXEvent_click_y_set), -1);
+  rb_define_method(SwigClassFXEvent.klass, "click_y", VALUEFUNC(_wrap_FXEvent_click_y_get), -1);
+  rb_define_method(SwigClassFXEvent.klass, "rootclick_x=", VALUEFUNC(_wrap_FXEvent_rootclick_x_set), -1);
+  rb_define_method(SwigClassFXEvent.klass, "rootclick_x", VALUEFUNC(_wrap_FXEvent_rootclick_x_get), -1);
+  rb_define_method(SwigClassFXEvent.klass, "rootclick_y=", VALUEFUNC(_wrap_FXEvent_rootclick_y_set), -1);
+  rb_define_method(SwigClassFXEvent.klass, "rootclick_y", VALUEFUNC(_wrap_FXEvent_rootclick_y_get), -1);
+  rb_define_method(SwigClassFXEvent.klass, "click_time=", VALUEFUNC(_wrap_FXEvent_click_time_set), -1);
+  rb_define_method(SwigClassFXEvent.klass, "click_time", VALUEFUNC(_wrap_FXEvent_click_time_get), -1);
+  rb_define_method(SwigClassFXEvent.klass, "click_button=", VALUEFUNC(_wrap_FXEvent_click_button_set), -1);
+  rb_define_method(SwigClassFXEvent.klass, "click_button", VALUEFUNC(_wrap_FXEvent_click_button_get), -1);
+  rb_define_method(SwigClassFXEvent.klass, "click_count=", VALUEFUNC(_wrap_FXEvent_click_count_set), -1);
+  rb_define_method(SwigClassFXEvent.klass, "click_count", VALUEFUNC(_wrap_FXEvent_click_count_get), -1);
+  rb_define_method(SwigClassFXEvent.klass, "moved=", VALUEFUNC(_wrap_FXEvent_moved_set), -1);
+  rb_define_method(SwigClassFXEvent.klass, "moved", VALUEFUNC(_wrap_FXEvent_moved_get), -1);
+  rb_define_method(SwigClassFXEvent.klass, "rect=", VALUEFUNC(_wrap_FXEvent_rect_set), -1);
+  rb_define_method(SwigClassFXEvent.klass, "rect", VALUEFUNC(_wrap_FXEvent_rect_get), -1);
+  rb_define_method(SwigClassFXEvent.klass, "synthetic=", VALUEFUNC(_wrap_FXEvent_synthetic_set), -1);
+  rb_define_method(SwigClassFXEvent.klass, "synthetic", VALUEFUNC(_wrap_FXEvent_synthetic_get), -1);
+  rb_define_method(SwigClassFXEvent.klass, "target=", VALUEFUNC(_wrap_FXEvent_target_set), -1);
+  rb_define_method(SwigClassFXEvent.klass, "target", VALUEFUNC(_wrap_FXEvent_target_get), -1);
+  SwigClassFXEvent.mark = 0;
+  SwigClassFXEvent.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXEvent.trackObjects = 0;
+  
+  SwigClassFXChore.klass = rb_define_class_under(mFox, "FXChore", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXChore, (void *) &SwigClassFXChore);
+  rb_undef_alloc_func(SwigClassFXChore.klass);
+  SwigClassFXChore.mark = 0;
+  SwigClassFXChore.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXChore.trackObjects = 0;
+  
+  SwigClassFXTimer.klass = rb_define_class_under(mFox, "FXTimer", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXTimer, (void *) &SwigClassFXTimer);
+  rb_undef_alloc_func(SwigClassFXTimer.klass);
+  SwigClassFXTimer.mark = 0;
+  SwigClassFXTimer.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXTimer.trackObjects = 0;
+  
+  SwigClassFXApp.klass = rb_define_class_under(mFox, "FXApp", ((swig_class *) SWIGTYPE_p_FXObject->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXApp, (void *) &SwigClassFXApp);
+  rb_define_alloc_func(SwigClassFXApp.klass, _wrap_FXApp_allocate);
+  rb_define_method(SwigClassFXApp.klass, "initialize", VALUEFUNC(_wrap_new_FXApp), -1);
+  rb_define_method(SwigClassFXApp.klass, "onCmdQuit", VALUEFUNC(_wrap_FXApp_onCmdQuit), -1);
+  rb_define_method(SwigClassFXApp.klass, "onCmdDump", VALUEFUNC(_wrap_FXApp_onCmdDump), -1);
+  rb_define_method(SwigClassFXApp.klass, "onCmdHover", VALUEFUNC(_wrap_FXApp_onCmdHover), -1);
+  rb_define_const(SwigClassFXApp.klass, "ID_QUIT", SWIG_From_int(static_cast< int >(FXApp::ID_QUIT)));
+  rb_define_const(SwigClassFXApp.klass, "ID_DUMP", SWIG_From_int(static_cast< int >(FXApp::ID_DUMP)));
+  rb_define_const(SwigClassFXApp.klass, "ID_HOVER", SWIG_From_int(static_cast< int >(FXApp::ID_HOVER)));
+  rb_define_const(SwigClassFXApp.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXApp::ID_LAST)));
+  rb_define_singleton_method(SwigClassFXApp.klass, "copyright", VALUEFUNC(_wrap_FXApp_copyright), -1);
+  rb_define_method(SwigClassFXApp.klass, "getAppName", VALUEFUNC(_wrap_FXApp_getAppName), -1);
+  rb_define_method(SwigClassFXApp.klass, "getVendorName", VALUEFUNC(_wrap_FXApp_getVendorName), -1);
+  rb_define_method(SwigClassFXApp.klass, "openDisplay", VALUEFUNC(_wrap_FXApp_openDisplay), -1);
+  rb_define_method(SwigClassFXApp.klass, "closeDisplay", VALUEFUNC(_wrap_FXApp_closeDisplay), -1);
+  rb_define_method(SwigClassFXApp.klass, "getDisplay", VALUEFUNC(_wrap_FXApp_getDisplay), -1);
+  rb_define_method(SwigClassFXApp.klass, "isInitialized", VALUEFUNC(_wrap_FXApp_isInitialized), -1);
+  rb_define_method(SwigClassFXApp.klass, "getArgc", VALUEFUNC(_wrap_FXApp_getArgc), -1);
+  rb_define_method(SwigClassFXApp.klass, "getArgv", VALUEFUNC(_wrap_FXApp_getArgv), -1);
+  rb_define_method(SwigClassFXApp.klass, "hasInputMethod?", VALUEFUNC(_wrap_FXApp_hasInputMethodq___), -1);
+  rb_define_method(SwigClassFXApp.klass, "getDefaultVisual", VALUEFUNC(_wrap_FXApp_getDefaultVisual), -1);
+  rb_define_method(SwigClassFXApp.klass, "setDefaultVisual", VALUEFUNC(_wrap_FXApp_setDefaultVisual), -1);
+  rb_define_method(SwigClassFXApp.klass, "getMonoVisual", VALUEFUNC(_wrap_FXApp_getMonoVisual), -1);
+  rb_define_method(SwigClassFXApp.klass, "getRootWindow", VALUEFUNC(_wrap_FXApp_getRootWindow), -1);
+  rb_define_method(SwigClassFXApp.klass, "setRootWindow", VALUEFUNC(_wrap_FXApp_setRootWindow), -1);
+  rb_define_method(SwigClassFXApp.klass, "focusWindow", VALUEFUNC(_wrap_FXApp_focusWindow), -1);
+  rb_define_method(SwigClassFXApp.klass, "getCursorWindow", VALUEFUNC(_wrap_FXApp_getCursorWindow), -1);
+  rb_define_method(SwigClassFXApp.klass, "activeWindow", VALUEFUNC(_wrap_FXApp_activeWindow), -1);
+  rb_define_method(SwigClassFXApp.klass, "getPopupWindow", VALUEFUNC(_wrap_FXApp_getPopupWindow), -1);
+  rb_define_method(SwigClassFXApp.klass, "findWindowWithId", VALUEFUNC(_wrap_FXApp_findWindowWithId), -1);
+  rb_define_method(SwigClassFXApp.klass, "findWindowAt", VALUEFUNC(_wrap_FXApp_findWindowAt), -1);
+  rb_define_method(SwigClassFXApp.klass, "addTimeout", VALUEFUNC(_wrap_FXApp_addTimeout), -1);
+  rb_define_method(SwigClassFXApp.klass, "removeTimeout", VALUEFUNC(_wrap_FXApp_removeTimeout), -1);
+  rb_define_method(SwigClassFXApp.klass, "hasTimeout?", VALUEFUNC(_wrap_FXApp_hasTimeoutq___), -1);
+  rb_define_method(SwigClassFXApp.klass, "remainingTimeout", VALUEFUNC(_wrap_FXApp_remainingTimeout), -1);
+  rb_define_method(SwigClassFXApp.klass, "handleTimeouts", VALUEFUNC(_wrap_FXApp_handleTimeouts), -1);
+  rb_define_method(SwigClassFXApp.klass, "addChore", VALUEFUNC(_wrap_FXApp_addChore), -1);
+  rb_define_method(SwigClassFXApp.klass, "removeChore", VALUEFUNC(_wrap_FXApp_removeChore), -1);
+  rb_define_method(SwigClassFXApp.klass, "hasChore?", VALUEFUNC(_wrap_FXApp_hasChoreq___), -1);
+  rb_define_method(SwigClassFXApp.klass, "addSignal", VALUEFUNC(_wrap_FXApp_addSignal), -1);
+  rb_define_method(SwigClassFXApp.klass, "removeSignal", VALUEFUNC(_wrap_FXApp_removeSignal), -1);
+  rb_define_method(SwigClassFXApp.klass, "addInput", VALUEFUNC(_wrap_FXApp_addInput), -1);
+  rb_define_method(SwigClassFXApp.klass, "removeInput", VALUEFUNC(_wrap_FXApp_removeInput), -1);
+  rb_define_method(SwigClassFXApp.klass, "getKeyState", VALUEFUNC(_wrap_FXApp_getKeyState), -1);
+  rb_define_method(SwigClassFXApp.klass, "peekEvent", VALUEFUNC(_wrap_FXApp_peekEvent), -1);
+  rb_define_method(SwigClassFXApp.klass, "isModal", VALUEFUNC(_wrap_FXApp_isModal), -1);
+  rb_define_method(SwigClassFXApp.klass, "getModalWindow", VALUEFUNC(_wrap_FXApp_getModalWindow), -1);
+  rb_define_method(SwigClassFXApp.klass, "getModality", VALUEFUNC(_wrap_FXApp_getModality), -1);
+  rb_define_method(SwigClassFXApp.klass, "stop", VALUEFUNC(_wrap_FXApp_stop), -1);
+  rb_define_method(SwigClassFXApp.klass, "stopModal", VALUEFUNC(_wrap_FXApp_stopModal), -1);
+  rb_define_method(SwigClassFXApp.klass, "forceRefresh", VALUEFUNC(_wrap_FXApp_forceRefresh), -1);
+  rb_define_method(SwigClassFXApp.klass, "refresh", VALUEFUNC(_wrap_FXApp_refresh), -1);
+  rb_define_method(SwigClassFXApp.klass, "flush", VALUEFUNC(_wrap_FXApp_flush), -1);
+  rb_define_method(SwigClassFXApp.klass, "repaint", VALUEFUNC(_wrap_FXApp_repaint), -1);
+  rb_define_method(SwigClassFXApp.klass, "reg", VALUEFUNC(_wrap_FXApp_reg), -1);
+  rb_define_method(SwigClassFXApp.klass, "registerDragType", VALUEFUNC(_wrap_FXApp_registerDragType), -1);
+  rb_define_method(SwigClassFXApp.klass, "getDragTypeName", VALUEFUNC(_wrap_FXApp_getDragTypeName), -1);
+  rb_define_method(SwigClassFXApp.klass, "getDragWindow", VALUEFUNC(_wrap_FXApp_getDragWindow), -1);
+  rb_define_method(SwigClassFXApp.klass, "beep", VALUEFUNC(_wrap_FXApp_beep), -1);
+  rb_define_singleton_method(SwigClassFXApp.klass, "instance", VALUEFUNC(_wrap_FXApp_instance), -1);
+  rb_define_method(SwigClassFXApp.klass, "setNormalFont", VALUEFUNC(_wrap_FXApp_setNormalFont), -1);
+  rb_define_method(SwigClassFXApp.klass, "getNormalFont", VALUEFUNC(_wrap_FXApp_getNormalFont), -1);
+  rb_define_method(SwigClassFXApp.klass, "beginWaitCursor", VALUEFUNC(_wrap_FXApp_beginWaitCursor), -1);
+  rb_define_method(SwigClassFXApp.klass, "endWaitCursor", VALUEFUNC(_wrap_FXApp_endWaitCursor), -1);
+  rb_define_method(SwigClassFXApp.klass, "setWaitCursor", VALUEFUNC(_wrap_FXApp_setWaitCursor), -1);
+  rb_define_method(SwigClassFXApp.klass, "getWaitCursor", VALUEFUNC(_wrap_FXApp_getWaitCursor), -1);
+  rb_define_method(SwigClassFXApp.klass, "getDefaultCursor", VALUEFUNC(_wrap_FXApp_getDefaultCursor), -1);
+  rb_define_method(SwigClassFXApp.klass, "setDefaultCursor", VALUEFUNC(_wrap_FXApp_setDefaultCursor), -1);
+  rb_define_method(SwigClassFXApp.klass, "writeWindow", VALUEFUNC(_wrap_FXApp_writeWindow), -1);
+  rb_define_method(SwigClassFXApp.klass, "readWindow", VALUEFUNC(_wrap_FXApp_readWindow), -1);
+  rb_define_method(SwigClassFXApp.klass, "mutex", VALUEFUNC(_wrap_FXApp_mutex), -1);
+  rb_define_method(SwigClassFXApp.klass, "setTranslator", VALUEFUNC(_wrap_FXApp_setTranslator), -1);
+  rb_define_method(SwigClassFXApp.klass, "getTranslator", VALUEFUNC(_wrap_FXApp_getTranslator), -1);
+  rb_define_method(SwigClassFXApp.klass, "getTypingSpeed", VALUEFUNC(_wrap_FXApp_getTypingSpeed), -1);
+  rb_define_method(SwigClassFXApp.klass, "getClickSpeed", VALUEFUNC(_wrap_FXApp_getClickSpeed), -1);
+  rb_define_method(SwigClassFXApp.klass, "getScrollSpeed", VALUEFUNC(_wrap_FXApp_getScrollSpeed), -1);
+  rb_define_method(SwigClassFXApp.klass, "getScrollDelay", VALUEFUNC(_wrap_FXApp_getScrollDelay), -1);
+  rb_define_method(SwigClassFXApp.klass, "getBlinkSpeed", VALUEFUNC(_wrap_FXApp_getBlinkSpeed), -1);
+  rb_define_method(SwigClassFXApp.klass, "getAnimSpeed", VALUEFUNC(_wrap_FXApp_getAnimSpeed), -1);
+  rb_define_method(SwigClassFXApp.klass, "getMenuPause", VALUEFUNC(_wrap_FXApp_getMenuPause), -1);
+  rb_define_method(SwigClassFXApp.klass, "getTooltipPause", VALUEFUNC(_wrap_FXApp_getTooltipPause), -1);
+  rb_define_method(SwigClassFXApp.klass, "getTooltipTime", VALUEFUNC(_wrap_FXApp_getTooltipTime), -1);
+  rb_define_method(SwigClassFXApp.klass, "getDragDelta", VALUEFUNC(_wrap_FXApp_getDragDelta), -1);
+  rb_define_method(SwigClassFXApp.klass, "getWheelLines", VALUEFUNC(_wrap_FXApp_getWheelLines), -1);
+  rb_define_method(SwigClassFXApp.klass, "scrollBarSize", VALUEFUNC(_wrap_FXApp_scrollBarSize), -1);
+  rb_define_method(SwigClassFXApp.klass, "setTypingSpeed", VALUEFUNC(_wrap_FXApp_setTypingSpeed), -1);
+  rb_define_method(SwigClassFXApp.klass, "setClickSpeed", VALUEFUNC(_wrap_FXApp_setClickSpeed), -1);
+  rb_define_method(SwigClassFXApp.klass, "setScrollSpeed", VALUEFUNC(_wrap_FXApp_setScrollSpeed), -1);
+  rb_define_method(SwigClassFXApp.klass, "setScrollDelay", VALUEFUNC(_wrap_FXApp_setScrollDelay), -1);
+  rb_define_method(SwigClassFXApp.klass, "setBlinkSpeed", VALUEFUNC(_wrap_FXApp_setBlinkSpeed), -1);
+  rb_define_method(SwigClassFXApp.klass, "setAnimSpeed", VALUEFUNC(_wrap_FXApp_setAnimSpeed), -1);
+  rb_define_method(SwigClassFXApp.klass, "setMenuPause", VALUEFUNC(_wrap_FXApp_setMenuPause), -1);
+  rb_define_method(SwigClassFXApp.klass, "setTooltipPause", VALUEFUNC(_wrap_FXApp_setTooltipPause), -1);
+  rb_define_method(SwigClassFXApp.klass, "setTooltipTime", VALUEFUNC(_wrap_FXApp_setTooltipTime), -1);
+  rb_define_method(SwigClassFXApp.klass, "setDragDelta", VALUEFUNC(_wrap_FXApp_setDragDelta), -1);
+  rb_define_method(SwigClassFXApp.klass, "setWheelLines", VALUEFUNC(_wrap_FXApp_setWheelLines), -1);
+  rb_define_method(SwigClassFXApp.klass, "scrollBarSize=", VALUEFUNC(_wrap_FXApp_scrollBarSizee___), -1);
+  rb_define_method(SwigClassFXApp.klass, "getBorderColor", VALUEFUNC(_wrap_FXApp_getBorderColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "getBaseColor", VALUEFUNC(_wrap_FXApp_getBaseColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "getHiliteColor", VALUEFUNC(_wrap_FXApp_getHiliteColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "getShadowColor", VALUEFUNC(_wrap_FXApp_getShadowColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "getBackColor", VALUEFUNC(_wrap_FXApp_getBackColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "getForeColor", VALUEFUNC(_wrap_FXApp_getForeColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "getSelforeColor", VALUEFUNC(_wrap_FXApp_getSelforeColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "getSelbackColor", VALUEFUNC(_wrap_FXApp_getSelbackColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "getTipforeColor", VALUEFUNC(_wrap_FXApp_getTipforeColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "getTipbackColor", VALUEFUNC(_wrap_FXApp_getTipbackColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "getSelMenuTextColor", VALUEFUNC(_wrap_FXApp_getSelMenuTextColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "getSelMenuBackColor", VALUEFUNC(_wrap_FXApp_getSelMenuBackColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "setBorderColor", VALUEFUNC(_wrap_FXApp_setBorderColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "setBaseColor", VALUEFUNC(_wrap_FXApp_setBaseColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "setHiliteColor", VALUEFUNC(_wrap_FXApp_setHiliteColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "setShadowColor", VALUEFUNC(_wrap_FXApp_setShadowColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "setBackColor", VALUEFUNC(_wrap_FXApp_setBackColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "setForeColor", VALUEFUNC(_wrap_FXApp_setForeColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "setSelforeColor", VALUEFUNC(_wrap_FXApp_setSelforeColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "setSelbackColor", VALUEFUNC(_wrap_FXApp_setSelbackColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "setTipforeColor", VALUEFUNC(_wrap_FXApp_setTipforeColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "setTipbackColor", VALUEFUNC(_wrap_FXApp_setTipbackColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "setSelMenuTextColor", VALUEFUNC(_wrap_FXApp_setSelMenuTextColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "setSelMenuBackColor", VALUEFUNC(_wrap_FXApp_setSelMenuBackColor), -1);
+  rb_define_method(SwigClassFXApp.klass, "dumpWidgets", VALUEFUNC(_wrap_FXApp_dumpWidgets), -1);
+  rb_define_method(SwigClassFXApp.klass, "getWindowCount", VALUEFUNC(_wrap_FXApp_getWindowCount), -1);
+  rb_define_method(SwigClassFXApp.klass, "save", VALUEFUNC(_wrap_FXApp_save), -1);
+  rb_define_method(SwigClassFXApp.klass, "load", VALUEFUNC(_wrap_FXApp_load), -1);
+  rb_define_method(SwigClassFXApp.klass, "create", VALUEFUNC(_wrap_FXApp_create), -1);
+  rb_define_method(SwigClassFXApp.klass, "destroy", VALUEFUNC(_wrap_FXApp_destroy), -1);
+  rb_define_method(SwigClassFXApp.klass, "detach", VALUEFUNC(_wrap_FXApp_detach), -1);
+  rb_define_method(SwigClassFXApp.klass, "run", VALUEFUNC(_wrap_FXApp_run), -1);
+  rb_define_method(SwigClassFXApp.klass, "runOneEvent", VALUEFUNC(_wrap_FXApp_runOneEvent), -1);
+  rb_define_method(SwigClassFXApp.klass, "runUntil", VALUEFUNC(_wrap_FXApp_runUntil), -1);
+  rb_define_method(SwigClassFXApp.klass, "runWhileEvents", VALUEFUNC(_wrap_FXApp_runWhileEvents), -1);
+  rb_define_method(SwigClassFXApp.klass, "runModalWhileEvents", VALUEFUNC(_wrap_FXApp_runModalWhileEvents), -1);
+  rb_define_method(SwigClassFXApp.klass, "runModal", VALUEFUNC(_wrap_FXApp_runModal), -1);
+  rb_define_method(SwigClassFXApp.klass, "runModalFor", VALUEFUNC(_wrap_FXApp_runModalFor), -1);
+  rb_define_method(SwigClassFXApp.klass, "runModalWhileShown", VALUEFUNC(_wrap_FXApp_runModalWhileShown), -1);
+  rb_define_method(SwigClassFXApp.klass, "runPopup", VALUEFUNC(_wrap_FXApp_runPopup), -1);
+  rb_define_method(SwigClassFXApp.klass, "init", VALUEFUNC(_wrap_FXApp_init), -1);
+  rb_define_method(SwigClassFXApp.klass, "exit", VALUEFUNC(_wrap_FXApp_exit), -1);
+  rb_define_method(SwigClassFXApp.klass, "threadsEnabled=", VALUEFUNC(_wrap_FXApp_threadsEnablede___), -1);
+  rb_define_method(SwigClassFXApp.klass, "threadsEnabled?", VALUEFUNC(_wrap_FXApp_threadsEnabledq___), -1);
+  rb_define_method(SwigClassFXApp.klass, "setSleepTime", VALUEFUNC(_wrap_FXApp_setSleepTime), -1);
+  rb_define_method(SwigClassFXApp.klass, "getSleepTime", VALUEFUNC(_wrap_FXApp_getSleepTime), -1);
+  SwigClassFXApp.mark = (void (*)(void *)) FXRbApp::markfunc;
+  SwigClassFXApp.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXApp.trackObjects = 0;
+  
+  SwigClassFXDataTarget.klass = rb_define_class_under(mFox, "FXDataTarget", ((swig_class *) SWIGTYPE_p_FXObject->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXDataTarget, (void *) &SwigClassFXDataTarget);
+  rb_define_alloc_func(SwigClassFXDataTarget.klass, _wrap_FXDataTarget_allocate);
+  rb_define_method(SwigClassFXDataTarget.klass, "initialize", VALUEFUNC(_wrap_new_FXDataTarget), -1);
+  rb_define_method(SwigClassFXDataTarget.klass, "onCmdValue", VALUEFUNC(_wrap_FXDataTarget_onCmdValue), -1);
+  rb_define_method(SwigClassFXDataTarget.klass, "onUpdValue", VALUEFUNC(_wrap_FXDataTarget_onUpdValue), -1);
+  rb_define_method(SwigClassFXDataTarget.klass, "onCmdOption", VALUEFUNC(_wrap_FXDataTarget_onCmdOption), -1);
+  rb_define_method(SwigClassFXDataTarget.klass, "onUpdOption", VALUEFUNC(_wrap_FXDataTarget_onUpdOption), -1);
+  rb_define_const(SwigClassFXDataTarget.klass, "DT_VOID", SWIG_From_int(static_cast< int >(FXDataTarget::DT_VOID)));
+  rb_define_const(SwigClassFXDataTarget.klass, "DT_CHAR", SWIG_From_int(static_cast< int >(FXDataTarget::DT_CHAR)));
+  rb_define_const(SwigClassFXDataTarget.klass, "DT_UCHAR", SWIG_From_int(static_cast< int >(FXDataTarget::DT_UCHAR)));
+  rb_define_const(SwigClassFXDataTarget.klass, "DT_SHORT", SWIG_From_int(static_cast< int >(FXDataTarget::DT_SHORT)));
+  rb_define_const(SwigClassFXDataTarget.klass, "DT_USHORT", SWIG_From_int(static_cast< int >(FXDataTarget::DT_USHORT)));
+  rb_define_const(SwigClassFXDataTarget.klass, "DT_INT", SWIG_From_int(static_cast< int >(FXDataTarget::DT_INT)));
+  rb_define_const(SwigClassFXDataTarget.klass, "DT_UINT", SWIG_From_int(static_cast< int >(FXDataTarget::DT_UINT)));
+  rb_define_const(SwigClassFXDataTarget.klass, "DT_LONG", SWIG_From_int(static_cast< int >(FXDataTarget::DT_LONG)));
+  rb_define_const(SwigClassFXDataTarget.klass, "DT_ULONG", SWIG_From_int(static_cast< int >(FXDataTarget::DT_ULONG)));
+  rb_define_const(SwigClassFXDataTarget.klass, "DT_FLOAT", SWIG_From_int(static_cast< int >(FXDataTarget::DT_FLOAT)));
+  rb_define_const(SwigClassFXDataTarget.klass, "DT_DOUBLE", SWIG_From_int(static_cast< int >(FXDataTarget::DT_DOUBLE)));
+  rb_define_const(SwigClassFXDataTarget.klass, "DT_STRING", SWIG_From_int(static_cast< int >(FXDataTarget::DT_STRING)));
+  rb_define_const(SwigClassFXDataTarget.klass, "DT_LAST", SWIG_From_int(static_cast< int >(FXDataTarget::DT_LAST)));
+  rb_define_const(SwigClassFXDataTarget.klass, "ID_VALUE", SWIG_From_int(static_cast< int >(FXDataTarget::ID_VALUE)));
+  rb_define_const(SwigClassFXDataTarget.klass, "ID_OPTION", SWIG_From_int(static_cast< int >(FXDataTarget::ID_OPTION)));
+  rb_define_const(SwigClassFXDataTarget.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXDataTarget::ID_LAST)));
+  rb_define_method(SwigClassFXDataTarget.klass, "setTarget", VALUEFUNC(_wrap_FXDataTarget_setTarget), -1);
+  rb_define_method(SwigClassFXDataTarget.klass, "getTarget", VALUEFUNC(_wrap_FXDataTarget_getTarget), -1);
+  rb_define_method(SwigClassFXDataTarget.klass, "setSelector", VALUEFUNC(_wrap_FXDataTarget_setSelector), -1);
+  rb_define_method(SwigClassFXDataTarget.klass, "getSelector", VALUEFUNC(_wrap_FXDataTarget_getSelector), -1);
+  rb_define_method(SwigClassFXDataTarget.klass, "getType", VALUEFUNC(_wrap_FXDataTarget_getType), -1);
+  rb_define_method(SwigClassFXDataTarget.klass, "getValue", VALUEFUNC(_wrap_FXDataTarget_getValue), -1);
+  rb_define_method(SwigClassFXDataTarget.klass, "setValue", VALUEFUNC(_wrap_FXDataTarget_setValue), -1);
+  rb_define_method(SwigClassFXDataTarget.klass, "save", VALUEFUNC(_wrap_FXDataTarget_save), -1);
+  rb_define_method(SwigClassFXDataTarget.klass, "load", VALUEFUNC(_wrap_FXDataTarget_load), -1);
+  SwigClassFXDataTarget.mark = (void (*)(void *)) FXRbDataTarget::markfunc;
+  SwigClassFXDataTarget.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXDataTarget.trackObjects = 0;
+  
+  SwigClassFXDebugTarget.klass = rb_define_class_under(mFox, "FXDebugTarget", ((swig_class *) SWIGTYPE_p_FXObject->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXDebugTarget, (void *) &SwigClassFXDebugTarget);
+  rb_define_alloc_func(SwigClassFXDebugTarget.klass, _wrap_FXDebugTarget_allocate);
+  rb_define_method(SwigClassFXDebugTarget.klass, "initialize", VALUEFUNC(_wrap_new_FXDebugTarget), -1);
+  rb_define_singleton_method(SwigClassFXDebugTarget.klass, "messageTypeName", VALUEFUNC(_wrap_FXDebugTarget_messageTypeName), -1);
+  rb_define_method(SwigClassFXDebugTarget.klass, "onMessage", VALUEFUNC(_wrap_FXDebugTarget_onMessage), -1);
+  rb_define_method(SwigClassFXDebugTarget.klass, "save", VALUEFUNC(_wrap_FXDebugTarget_save), -1);
+  rb_define_method(SwigClassFXDebugTarget.klass, "load", VALUEFUNC(_wrap_FXDebugTarget_load), -1);
+  SwigClassFXDebugTarget.mark = (void (*)(void *)) FXRbDebugTarget::markfunc;
+  SwigClassFXDebugTarget.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXDebugTarget.trackObjects = 0;
+  
+  SwigClassFXDelegator.klass = rb_define_class_under(mFox, "FXDelegator", ((swig_class *) SWIGTYPE_p_FXObject->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXDelegator, (void *) &SwigClassFXDelegator);
+  rb_define_alloc_func(SwigClassFXDelegator.klass, _wrap_FXDelegator_allocate);
+  rb_define_method(SwigClassFXDelegator.klass, "initialize", VALUEFUNC(_wrap_new_FXDelegator), -1);
+  rb_define_method(SwigClassFXDelegator.klass, "getDelegate", VALUEFUNC(_wrap_FXDelegator_getDelegate), -1);
+  rb_define_method(SwigClassFXDelegator.klass, "setDelegate", VALUEFUNC(_wrap_FXDelegator_setDelegate), -1);
+  rb_define_method(SwigClassFXDelegator.klass, "save", VALUEFUNC(_wrap_FXDelegator_save), -1);
+  rb_define_method(SwigClassFXDelegator.klass, "load", VALUEFUNC(_wrap_FXDelegator_load), -1);
+  SwigClassFXDelegator.mark = (void (*)(void *)) FXRbDelegator::markfunc;
+  SwigClassFXDelegator.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXDelegator.trackObjects = 0;
+  
+  SwigClassFXTranslator.klass = rb_define_class_under(mFox, "FXTranslator", ((swig_class *) SWIGTYPE_p_FXObject->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXTranslator, (void *) &SwigClassFXTranslator);
+  rb_define_alloc_func(SwigClassFXTranslator.klass, _wrap_FXTranslator_allocate);
+  rb_define_method(SwigClassFXTranslator.klass, "initialize", VALUEFUNC(_wrap_new_FXTranslator), -1);
+  rb_define_method(SwigClassFXTranslator.klass, "getApp", VALUEFUNC(_wrap_FXTranslator_getApp), -1);
+  rb_define_method(SwigClassFXTranslator.klass, "setTextCodec", VALUEFUNC(_wrap_FXTranslator_setTextCodec), -1);
+  rb_define_method(SwigClassFXTranslator.klass, "getTextCodec", VALUEFUNC(_wrap_FXTranslator_getTextCodec), -1);
+  rb_define_method(SwigClassFXTranslator.klass, "save", VALUEFUNC(_wrap_FXTranslator_save), -1);
+  rb_define_method(SwigClassFXTranslator.klass, "load", VALUEFUNC(_wrap_FXTranslator_load), -1);
+  rb_define_method(SwigClassFXTranslator.klass, "tr", VALUEFUNC(_wrap_FXTranslator_tr), -1);
+  SwigClassFXTranslator.mark = 0;
+  SwigClassFXTranslator.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXTranslator.trackObjects = 0;
+  
+  SwigClassFXDict.klass = rb_define_class_under(mFox, "FXDict", ((swig_class *) SWIGTYPE_p_FXObject->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXDict, (void *) &SwigClassFXDict);
+  rb_define_alloc_func(SwigClassFXDict.klass, _wrap_FXDict_allocate);
+  rb_define_method(SwigClassFXDict.klass, "initialize", VALUEFUNC(_wrap_new_FXDict), -1);
+  rb_define_method(SwigClassFXDict.klass, "getTotalSize", VALUEFUNC(_wrap_FXDict_getTotalSize), -1);
+  rb_define_method(SwigClassFXDict.klass, "setTotalSize", VALUEFUNC(_wrap_FXDict_setTotalSize), -1);
+  rb_define_method(SwigClassFXDict.klass, "length", VALUEFUNC(_wrap_FXDict_length), -1);
+  rb_define_method(SwigClassFXDict.klass, "remove", VALUEFUNC(_wrap_FXDict_remove), -1);
+  rb_define_method(SwigClassFXDict.klass, "key", VALUEFUNC(_wrap_FXDict_key), -1);
+  rb_define_method(SwigClassFXDict.klass, "mark", VALUEFUNC(_wrap_FXDict_mark), -1);
+  rb_define_method(SwigClassFXDict.klass, "first", VALUEFUNC(_wrap_FXDict_first), -1);
+  rb_define_method(SwigClassFXDict.klass, "last", VALUEFUNC(_wrap_FXDict_last), -1);
+  rb_define_method(SwigClassFXDict.klass, "next", VALUEFUNC(_wrap_FXDict_next), -1);
+  rb_define_method(SwigClassFXDict.klass, "prev", VALUEFUNC(_wrap_FXDict_prev), -1);
+  rb_define_method(SwigClassFXDict.klass, "clear", VALUEFUNC(_wrap_FXDict_clear), -1);
+  rb_define_method(SwigClassFXDict.klass, "has_key?", VALUEFUNC(_wrap_FXDict_has_keyq___), -1);
+  rb_define_method(SwigClassFXDict.klass, "save", VALUEFUNC(_wrap_FXDict_save), -1);
+  rb_define_method(SwigClassFXDict.klass, "load", VALUEFUNC(_wrap_FXDict_load), -1);
+  SwigClassFXDict.mark = (void (*)(void *)) FXRbDict::markfunc;
+  SwigClassFXDict.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXDict.trackObjects = 0;
+  
+  SWIGTYPE_p_FXDict->dcast = (swig_dycast_func) FXDict_dynamic_cast;
+  
+  
+  SwigClassFXFileAssoc.klass = rb_define_class_under(mFox, "FXFileAssoc", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXFileAssoc, (void *) &SwigClassFXFileAssoc);
+  rb_define_alloc_func(SwigClassFXFileAssoc.klass, _wrap_FXFileAssoc_allocate);
+  rb_define_method(SwigClassFXFileAssoc.klass, "initialize", VALUEFUNC(_wrap_new_FXFileAssoc), -1);
+  rb_define_method(SwigClassFXFileAssoc.klass, "command=", VALUEFUNC(_wrap_FXFileAssoc_command_set), -1);
+  rb_define_method(SwigClassFXFileAssoc.klass, "command", VALUEFUNC(_wrap_FXFileAssoc_command_get), -1);
+  rb_define_method(SwigClassFXFileAssoc.klass, "extension=", VALUEFUNC(_wrap_FXFileAssoc_extension_set), -1);
+  rb_define_method(SwigClassFXFileAssoc.klass, "extension", VALUEFUNC(_wrap_FXFileAssoc_extension_get), -1);
+  rb_define_method(SwigClassFXFileAssoc.klass, "mimetype=", VALUEFUNC(_wrap_FXFileAssoc_mimetype_set), -1);
+  rb_define_method(SwigClassFXFileAssoc.klass, "mimetype", VALUEFUNC(_wrap_FXFileAssoc_mimetype_get), -1);
+  rb_define_method(SwigClassFXFileAssoc.klass, "bigicon=", VALUEFUNC(_wrap_FXFileAssoc_bigicon_set), -1);
+  rb_define_method(SwigClassFXFileAssoc.klass, "bigicon", VALUEFUNC(_wrap_FXFileAssoc_bigicon_get), -1);
+  rb_define_method(SwigClassFXFileAssoc.klass, "bigiconopen=", VALUEFUNC(_wrap_FXFileAssoc_bigiconopen_set), -1);
+  rb_define_method(SwigClassFXFileAssoc.klass, "bigiconopen", VALUEFUNC(_wrap_FXFileAssoc_bigiconopen_get), -1);
+  rb_define_method(SwigClassFXFileAssoc.klass, "miniicon=", VALUEFUNC(_wrap_FXFileAssoc_miniicon_set), -1);
+  rb_define_method(SwigClassFXFileAssoc.klass, "miniicon", VALUEFUNC(_wrap_FXFileAssoc_miniicon_get), -1);
+  rb_define_method(SwigClassFXFileAssoc.klass, "miniiconopen=", VALUEFUNC(_wrap_FXFileAssoc_miniiconopen_set), -1);
+  rb_define_method(SwigClassFXFileAssoc.klass, "miniiconopen", VALUEFUNC(_wrap_FXFileAssoc_miniiconopen_get), -1);
+  rb_define_method(SwigClassFXFileAssoc.klass, "dragtype=", VALUEFUNC(_wrap_FXFileAssoc_dragtype_set), -1);
+  rb_define_method(SwigClassFXFileAssoc.klass, "dragtype", VALUEFUNC(_wrap_FXFileAssoc_dragtype_get), -1);
+  rb_define_method(SwigClassFXFileAssoc.klass, "flags=", VALUEFUNC(_wrap_FXFileAssoc_flags_set), -1);
+  rb_define_method(SwigClassFXFileAssoc.klass, "flags", VALUEFUNC(_wrap_FXFileAssoc_flags_get), -1);
+  SwigClassFXFileAssoc.mark = 0;
+  SwigClassFXFileAssoc.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXFileAssoc.trackObjects = 0;
+  
+  SwigClassFXFileDict.klass = rb_define_class_under(mFox, "FXFileDict", ((swig_class *) SWIGTYPE_p_FXDict->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXFileDict, (void *) &SwigClassFXFileDict);
+  rb_define_alloc_func(SwigClassFXFileDict.klass, _wrap_FXFileDict_allocate);
+  rb_define_method(SwigClassFXFileDict.klass, "initialize", VALUEFUNC(_wrap_new_FXFileDict), -1);
+  rb_define_singleton_method(SwigClassFXFileDict.klass, "defaultExecBinding", VALUEFUNC(_wrap_FXFileDict_defaultExecBinding), -1);
+  rb_define_singleton_method(SwigClassFXFileDict.klass, "defaultDirBinding", VALUEFUNC(_wrap_FXFileDict_defaultDirBinding), -1);
+  rb_define_singleton_method(SwigClassFXFileDict.klass, "defaultFileBinding", VALUEFUNC(_wrap_FXFileDict_defaultFileBinding), -1);
+  rb_define_method(SwigClassFXFileDict.klass, "setSettings", VALUEFUNC(_wrap_FXFileDict_setSettings), -1);
+  rb_define_method(SwigClassFXFileDict.klass, "getSettings", VALUEFUNC(_wrap_FXFileDict_getSettings), -1);
+  rb_define_method(SwigClassFXFileDict.klass, "setIconDict", VALUEFUNC(_wrap_FXFileDict_setIconDict), -1);
+  rb_define_method(SwigClassFXFileDict.klass, "getIconDict", VALUEFUNC(_wrap_FXFileDict_getIconDict), -1);
+  rb_define_method(SwigClassFXFileDict.klass, "setIconPath", VALUEFUNC(_wrap_FXFileDict_setIconPath), -1);
+  rb_define_method(SwigClassFXFileDict.klass, "getIconPath", VALUEFUNC(_wrap_FXFileDict_getIconPath), -1);
+  rb_define_method(SwigClassFXFileDict.klass, "replace", VALUEFUNC(_wrap_FXFileDict_replace), -1);
+  rb_define_method(SwigClassFXFileDict.klass, "remove", VALUEFUNC(_wrap_FXFileDict_remove), -1);
+  rb_define_method(SwigClassFXFileDict.klass, "find", VALUEFUNC(_wrap_FXFileDict_find), -1);
+  rb_define_method(SwigClassFXFileDict.klass, "save", VALUEFUNC(_wrap_FXFileDict_save), -1);
+  rb_define_method(SwigClassFXFileDict.klass, "load", VALUEFUNC(_wrap_FXFileDict_load), -1);
+  rb_define_method(SwigClassFXFileDict.klass, "findFileBinding", VALUEFUNC(_wrap_FXFileDict_findFileBinding), -1);
+  rb_define_method(SwigClassFXFileDict.klass, "findDirBinding", VALUEFUNC(_wrap_FXFileDict_findDirBinding), -1);
+  rb_define_method(SwigClassFXFileDict.klass, "findExecBinding", VALUEFUNC(_wrap_FXFileDict_findExecBinding), -1);
+  SwigClassFXFileDict.mark = (void (*)(void *)) FXRbFileDict::markfunc;
+  SwigClassFXFileDict.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXFileDict.trackObjects = 0;
+  
+  SwigClassFXIconDict.klass = rb_define_class_under(mFox, "FXIconDict", ((swig_class *) SWIGTYPE_p_FXDict->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXIconDict, (void *) &SwigClassFXIconDict);
+  rb_define_alloc_func(SwigClassFXIconDict.klass, _wrap_FXIconDict_allocate);
+  rb_define_method(SwigClassFXIconDict.klass, "initialize", VALUEFUNC(_wrap_new_FXIconDict), -1);
+  rb_define_singleton_method(SwigClassFXIconDict.klass, "defaultIconPath", VALUEFUNC(_wrap_FXIconDict_defaultIconPath), -1);
+  rb_define_method(SwigClassFXIconDict.klass, "iconSource=", VALUEFUNC(_wrap_FXIconDict_iconSourcee___), -1);
+  rb_define_method(SwigClassFXIconDict.klass, "iconSource", VALUEFUNC(_wrap_FXIconDict_iconSource), -1);
+  rb_define_method(SwigClassFXIconDict.klass, "iconPath=", VALUEFUNC(_wrap_FXIconDict_iconPathe___), -1);
+  rb_define_method(SwigClassFXIconDict.klass, "iconPath", VALUEFUNC(_wrap_FXIconDict_iconPath), -1);
+  rb_define_method(SwigClassFXIconDict.klass, "insert", VALUEFUNC(_wrap_FXIconDict_insert), -1);
+  rb_define_method(SwigClassFXIconDict.klass, "remove", VALUEFUNC(_wrap_FXIconDict_remove), -1);
+  rb_define_method(SwigClassFXIconDict.klass, "find", VALUEFUNC(_wrap_FXIconDict_find), -1);
+  SwigClassFXIconDict.mark = (void (*)(void *)) FXRbIconDict::markfunc;
+  SwigClassFXIconDict.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXIconDict.trackObjects = 0;
+  
+  SwigClassFXStringDict.klass = rb_define_class_under(mFox, "FXStringDict", ((swig_class *) SWIGTYPE_p_FXDict->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXStringDict, (void *) &SwigClassFXStringDict);
+  rb_define_alloc_func(SwigClassFXStringDict.klass, _wrap_FXStringDict_allocate);
+  rb_define_method(SwigClassFXStringDict.klass, "initialize", VALUEFUNC(_wrap_new_FXStringDict), -1);
+  rb_define_method(SwigClassFXStringDict.klass, "insert", VALUEFUNC(_wrap_FXStringDict_insert), -1);
+  rb_define_method(SwigClassFXStringDict.klass, "replace", VALUEFUNC(_wrap_FXStringDict_replace), -1);
+  rb_define_method(SwigClassFXStringDict.klass, "remove", VALUEFUNC(_wrap_FXStringDict_remove), -1);
+  rb_define_method(SwigClassFXStringDict.klass, "find", VALUEFUNC(_wrap_FXStringDict_find), -1);
+  rb_define_method(SwigClassFXStringDict.klass, "data", VALUEFUNC(_wrap_FXStringDict_data), -1);
+  rb_define_method(SwigClassFXStringDict.klass, "save", VALUEFUNC(_wrap_FXStringDict_save), -1);
+  rb_define_method(SwigClassFXStringDict.klass, "load", VALUEFUNC(_wrap_FXStringDict_load), -1);
+  SwigClassFXStringDict.mark = (void (*)(void *)) FXRbStringDict::markfunc;
+  SwigClassFXStringDict.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXStringDict.trackObjects = 0;
+  
+  SwigClassFXSettings.klass = rb_define_class_under(mFox, "FXSettings", ((swig_class *) SWIGTYPE_p_FXDict->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXSettings, (void *) &SwigClassFXSettings);
+  rb_define_alloc_func(SwigClassFXSettings.klass, _wrap_FXSettings_allocate);
+  rb_define_method(SwigClassFXSettings.klass, "initialize", VALUEFUNC(_wrap_new_FXSettings), -1);
+  rb_define_method(SwigClassFXSettings.klass, "parseFile", VALUEFUNC(_wrap_FXSettings_parseFile), -1);
+  rb_define_method(SwigClassFXSettings.klass, "unparseFile", VALUEFUNC(_wrap_FXSettings_unparseFile), -1);
+  rb_define_method(SwigClassFXSettings.klass, "data", VALUEFUNC(_wrap_FXSettings_data), -1);
+  rb_define_method(SwigClassFXSettings.klass, "find", VALUEFUNC(_wrap_FXSettings_find), -1);
+  rb_define_method(SwigClassFXSettings.klass, "readStringEntry", VALUEFUNC(_wrap_FXSettings_readStringEntry), -1);
+  rb_define_method(SwigClassFXSettings.klass, "readIntEntry", VALUEFUNC(_wrap_FXSettings_readIntEntry), -1);
+  rb_define_method(SwigClassFXSettings.klass, "readUnsignedEntry", VALUEFUNC(_wrap_FXSettings_readUnsignedEntry), -1);
+  rb_define_method(SwigClassFXSettings.klass, "readRealEntry", VALUEFUNC(_wrap_FXSettings_readRealEntry), -1);
+  rb_define_method(SwigClassFXSettings.klass, "readColorEntry", VALUEFUNC(_wrap_FXSettings_readColorEntry), -1);
+  rb_define_method(SwigClassFXSettings.klass, "writeStringEntry", VALUEFUNC(_wrap_FXSettings_writeStringEntry), -1);
+  rb_define_method(SwigClassFXSettings.klass, "writeIntEntry", VALUEFUNC(_wrap_FXSettings_writeIntEntry), -1);
+  rb_define_method(SwigClassFXSettings.klass, "writeUnsignedEntry", VALUEFUNC(_wrap_FXSettings_writeUnsignedEntry), -1);
+  rb_define_method(SwigClassFXSettings.klass, "writeRealEntry", VALUEFUNC(_wrap_FXSettings_writeRealEntry), -1);
+  rb_define_method(SwigClassFXSettings.klass, "writeColorEntry", VALUEFUNC(_wrap_FXSettings_writeColorEntry), -1);
+  rb_define_method(SwigClassFXSettings.klass, "deleteEntry", VALUEFUNC(_wrap_FXSettings_deleteEntry), -1);
+  rb_define_method(SwigClassFXSettings.klass, "existingEntry", VALUEFUNC(_wrap_FXSettings_existingEntry), -1);
+  rb_define_method(SwigClassFXSettings.klass, "deleteSection", VALUEFUNC(_wrap_FXSettings_deleteSection), -1);
+  rb_define_method(SwigClassFXSettings.klass, "existingSection", VALUEFUNC(_wrap_FXSettings_existingSection), -1);
+  rb_define_method(SwigClassFXSettings.klass, "clear", VALUEFUNC(_wrap_FXSettings_clear), -1);
+  rb_define_method(SwigClassFXSettings.klass, "setModified", VALUEFUNC(_wrap_FXSettings_setModified), -1);
+  rb_define_method(SwigClassFXSettings.klass, "isModified", VALUEFUNC(_wrap_FXSettings_isModified), -1);
+  rb_define_method(SwigClassFXSettings.klass, "save", VALUEFUNC(_wrap_FXSettings_save), -1);
+  rb_define_method(SwigClassFXSettings.klass, "load", VALUEFUNC(_wrap_FXSettings_load), -1);
+  SwigClassFXSettings.mark = (void (*)(void *)) FXRbSettings::markfunc;
+  SwigClassFXSettings.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXSettings.trackObjects = 0;
+  
+  SWIGTYPE_p_FXSettings->dcast = (swig_dycast_func) FXSettings_dynamic_cast;
+  
+  
+  SwigClassFXRegistry.klass = rb_define_class_under(mFox, "FXRegistry", ((swig_class *) SWIGTYPE_p_FXSettings->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXRegistry, (void *) &SwigClassFXRegistry);
+  rb_define_alloc_func(SwigClassFXRegistry.klass, _wrap_FXRegistry_allocate);
+  rb_define_method(SwigClassFXRegistry.klass, "initialize", VALUEFUNC(_wrap_new_FXRegistry), -1);
+  rb_define_method(SwigClassFXRegistry.klass, "read", VALUEFUNC(_wrap_FXRegistry_read), -1);
+  rb_define_method(SwigClassFXRegistry.klass, "write", VALUEFUNC(_wrap_FXRegistry_write), -1);
+  rb_define_method(SwigClassFXRegistry.klass, "getAppKey", VALUEFUNC(_wrap_FXRegistry_getAppKey), -1);
+  rb_define_method(SwigClassFXRegistry.klass, "getVendorKey", VALUEFUNC(_wrap_FXRegistry_getVendorKey), -1);
+  rb_define_method(SwigClassFXRegistry.klass, "setAsciiMode", VALUEFUNC(_wrap_FXRegistry_setAsciiMode), -1);
+  rb_define_method(SwigClassFXRegistry.klass, "getAsciiMode", VALUEFUNC(_wrap_FXRegistry_getAsciiMode), -1);
+  rb_define_method(SwigClassFXRegistry.klass, "save", VALUEFUNC(_wrap_FXRegistry_save), -1);
+  rb_define_method(SwigClassFXRegistry.klass, "load", VALUEFUNC(_wrap_FXRegistry_load), -1);
+  SwigClassFXRegistry.mark = (void (*)(void *)) FXRbRegistry::markfunc;
+  SwigClassFXRegistry.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXRegistry.trackObjects = 0;
+  
+  SwigClassFXDocument.klass = rb_define_class_under(mFox, "FXDocument", ((swig_class *) SWIGTYPE_p_FXObject->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXDocument, (void *) &SwigClassFXDocument);
+  rb_define_alloc_func(SwigClassFXDocument.klass, _wrap_FXDocument_allocate);
+  rb_define_method(SwigClassFXDocument.klass, "initialize", VALUEFUNC(_wrap_new_FXDocument), -1);
+  rb_define_method(SwigClassFXDocument.klass, "onUpdTitle", VALUEFUNC(_wrap_FXDocument_onUpdTitle), -1);
+  rb_define_method(SwigClassFXDocument.klass, "onUpdFilename", VALUEFUNC(_wrap_FXDocument_onUpdFilename), -1);
+  rb_define_const(SwigClassFXDocument.klass, "ID_TITLE", SWIG_From_int(static_cast< int >(FXDocument::ID_TITLE)));
+  rb_define_const(SwigClassFXDocument.klass, "ID_FILENAME", SWIG_From_int(static_cast< int >(FXDocument::ID_FILENAME)));
+  rb_define_const(SwigClassFXDocument.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXDocument::ID_LAST)));
+  rb_define_method(SwigClassFXDocument.klass, "isModified", VALUEFUNC(_wrap_FXDocument_isModified), -1);
+  rb_define_method(SwigClassFXDocument.klass, "setModified", VALUEFUNC(_wrap_FXDocument_setModified), -1);
+  rb_define_method(SwigClassFXDocument.klass, "setTitle", VALUEFUNC(_wrap_FXDocument_setTitle), -1);
+  rb_define_method(SwigClassFXDocument.klass, "getTitle", VALUEFUNC(_wrap_FXDocument_getTitle), -1);
+  rb_define_method(SwigClassFXDocument.klass, "setFilename", VALUEFUNC(_wrap_FXDocument_setFilename), -1);
+  rb_define_method(SwigClassFXDocument.klass, "getFilename", VALUEFUNC(_wrap_FXDocument_getFilename), -1);
+  rb_define_method(SwigClassFXDocument.klass, "save", VALUEFUNC(_wrap_FXDocument_save), -1);
+  rb_define_method(SwigClassFXDocument.klass, "load", VALUEFUNC(_wrap_FXDocument_load), -1);
+  SwigClassFXDocument.mark = (void (*)(void *)) FXRbDocument::markfunc;
+  SwigClassFXDocument.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXDocument.trackObjects = 0;
+  
+  SwigClassFXRecentFiles.klass = rb_define_class_under(mFox, "FXRecentFiles", ((swig_class *) SWIGTYPE_p_FXObject->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXRecentFiles, (void *) &SwigClassFXRecentFiles);
+  rb_define_alloc_func(SwigClassFXRecentFiles.klass, _wrap_FXRecentFiles_allocate);
+  rb_define_method(SwigClassFXRecentFiles.klass, "initialize", VALUEFUNC(_wrap_new_FXRecentFiles), -1);
+  rb_define_method(SwigClassFXRecentFiles.klass, "onCmdClear", VALUEFUNC(_wrap_FXRecentFiles_onCmdClear), -1);
+  rb_define_method(SwigClassFXRecentFiles.klass, "onCmdFile", VALUEFUNC(_wrap_FXRecentFiles_onCmdFile), -1);
+  rb_define_method(SwigClassFXRecentFiles.klass, "onUpdFile", VALUEFUNC(_wrap_FXRecentFiles_onUpdFile), -1);
+  rb_define_method(SwigClassFXRecentFiles.klass, "onUpdAnyFiles", VALUEFUNC(_wrap_FXRecentFiles_onUpdAnyFiles), -1);
+  rb_define_const(SwigClassFXRecentFiles.klass, "ID_CLEAR", SWIG_From_int(static_cast< int >(FXRecentFiles::ID_CLEAR)));
+  rb_define_const(SwigClassFXRecentFiles.klass, "ID_ANYFILES", SWIG_From_int(static_cast< int >(FXRecentFiles::ID_ANYFILES)));
+  rb_define_const(SwigClassFXRecentFiles.klass, "ID_FILE_1", SWIG_From_int(static_cast< int >(FXRecentFiles::ID_FILE_1)));
+  rb_define_const(SwigClassFXRecentFiles.klass, "ID_FILE_2", SWIG_From_int(static_cast< int >(FXRecentFiles::ID_FILE_2)));
+  rb_define_const(SwigClassFXRecentFiles.klass, "ID_FILE_3", SWIG_From_int(static_cast< int >(FXRecentFiles::ID_FILE_3)));
+  rb_define_const(SwigClassFXRecentFiles.klass, "ID_FILE_4", SWIG_From_int(static_cast< int >(FXRecentFiles::ID_FILE_4)));
+  rb_define_const(SwigClassFXRecentFiles.klass, "ID_FILE_5", SWIG_From_int(static_cast< int >(FXRecentFiles::ID_FILE_5)));
+  rb_define_const(SwigClassFXRecentFiles.klass, "ID_FILE_6", SWIG_From_int(static_cast< int >(FXRecentFiles::ID_FILE_6)));
+  rb_define_const(SwigClassFXRecentFiles.klass, "ID_FILE_7", SWIG_From_int(static_cast< int >(FXRecentFiles::ID_FILE_7)));
+  rb_define_const(SwigClassFXRecentFiles.klass, "ID_FILE_8", SWIG_From_int(static_cast< int >(FXRecentFiles::ID_FILE_8)));
+  rb_define_const(SwigClassFXRecentFiles.klass, "ID_FILE_9", SWIG_From_int(static_cast< int >(FXRecentFiles::ID_FILE_9)));
+  rb_define_const(SwigClassFXRecentFiles.klass, "ID_FILE_10", SWIG_From_int(static_cast< int >(FXRecentFiles::ID_FILE_10)));
+  rb_define_const(SwigClassFXRecentFiles.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXRecentFiles::ID_LAST)));
+  rb_define_method(SwigClassFXRecentFiles.klass, "app", VALUEFUNC(_wrap_FXRecentFiles_app), -1);
+  rb_define_method(SwigClassFXRecentFiles.klass, "setMaxFiles", VALUEFUNC(_wrap_FXRecentFiles_setMaxFiles), -1);
+  rb_define_method(SwigClassFXRecentFiles.klass, "getMaxFiles", VALUEFUNC(_wrap_FXRecentFiles_getMaxFiles), -1);
+  rb_define_method(SwigClassFXRecentFiles.klass, "setGroupName", VALUEFUNC(_wrap_FXRecentFiles_setGroupName), -1);
+  rb_define_method(SwigClassFXRecentFiles.klass, "getGroupName", VALUEFUNC(_wrap_FXRecentFiles_getGroupName), -1);
+  rb_define_method(SwigClassFXRecentFiles.klass, "setTarget", VALUEFUNC(_wrap_FXRecentFiles_setTarget), -1);
+  rb_define_method(SwigClassFXRecentFiles.klass, "getTarget", VALUEFUNC(_wrap_FXRecentFiles_getTarget), -1);
+  rb_define_method(SwigClassFXRecentFiles.klass, "setSelector", VALUEFUNC(_wrap_FXRecentFiles_setSelector), -1);
+  rb_define_method(SwigClassFXRecentFiles.klass, "getSelector", VALUEFUNC(_wrap_FXRecentFiles_getSelector), -1);
+  rb_define_method(SwigClassFXRecentFiles.klass, "getFile", VALUEFUNC(_wrap_FXRecentFiles_getFile), -1);
+  rb_define_method(SwigClassFXRecentFiles.klass, "setFile", VALUEFUNC(_wrap_FXRecentFiles_setFile), -1);
+  rb_define_method(SwigClassFXRecentFiles.klass, "appendFile", VALUEFUNC(_wrap_FXRecentFiles_appendFile), -1);
+  rb_define_method(SwigClassFXRecentFiles.klass, "removeFile", VALUEFUNC(_wrap_FXRecentFiles_removeFile), -1);
+  rb_define_method(SwigClassFXRecentFiles.klass, "clear", VALUEFUNC(_wrap_FXRecentFiles_clear), -1);
+  rb_define_method(SwigClassFXRecentFiles.klass, "save", VALUEFUNC(_wrap_FXRecentFiles_save), -1);
+  rb_define_method(SwigClassFXRecentFiles.klass, "load", VALUEFUNC(_wrap_FXRecentFiles_load), -1);
+  SwigClassFXRecentFiles.mark = (void (*)(void *)) FXRbRecentFiles::markfunc;
+  SwigClassFXRecentFiles.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXRecentFiles.trackObjects = 0;
+  
+  SwigClassFXId.klass = rb_define_class_under(mFox, "FXId", ((swig_class *) SWIGTYPE_p_FXObject->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXId, (void *) &SwigClassFXId);
+  rb_undef_alloc_func(SwigClassFXId.klass);
+  rb_define_method(SwigClassFXId.klass, "getApp", VALUEFUNC(_wrap_FXId_getApp), -1);
+  rb_define_method(SwigClassFXId.klass, "xid", VALUEFUNC(_wrap_FXId_xid), -1);
+  rb_define_method(SwigClassFXId.klass, "created?", VALUEFUNC(_wrap_FXId_createdq___), -1);
+  rb_define_method(SwigClassFXId.klass, "setUserData", VALUEFUNC(_wrap_FXId_setUserData), -1);
+  rb_define_method(SwigClassFXId.klass, "getUserData", VALUEFUNC(_wrap_FXId_getUserData), -1);
+  rb_define_method(SwigClassFXId.klass, "save", VALUEFUNC(_wrap_FXId_save), -1);
+  rb_define_method(SwigClassFXId.klass, "load", VALUEFUNC(_wrap_FXId_load), -1);
+  rb_define_method(SwigClassFXId.klass, "create", VALUEFUNC(_wrap_FXId_create), -1);
+  rb_define_method(SwigClassFXId.klass, "detach", VALUEFUNC(_wrap_FXId_detach), -1);
+  rb_define_method(SwigClassFXId.klass, "destroy", VALUEFUNC(_wrap_FXId_destroy), -1);
+  SwigClassFXId.mark = (void (*)(void *)) FXRbId::markfunc;
+  SwigClassFXId.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXId.trackObjects = 0;
+  
+  SWIGTYPE_p_FXId->dcast = (swig_dycast_func) FXId_dynamic_cast;
+  
+  rb_define_const(mFox, "CURSOR_ARROW", SWIG_From_int(static_cast< int >(CURSOR_ARROW)));
+  rb_define_const(mFox, "CURSOR_RARROW", SWIG_From_int(static_cast< int >(CURSOR_RARROW)));
+  rb_define_const(mFox, "CURSOR_IBEAM", SWIG_From_int(static_cast< int >(CURSOR_IBEAM)));
+  rb_define_const(mFox, "CURSOR_WATCH", SWIG_From_int(static_cast< int >(CURSOR_WATCH)));
+  rb_define_const(mFox, "CURSOR_CROSS", SWIG_From_int(static_cast< int >(CURSOR_CROSS)));
+  rb_define_const(mFox, "CURSOR_UPDOWN", SWIG_From_int(static_cast< int >(CURSOR_UPDOWN)));
+  rb_define_const(mFox, "CURSOR_LEFTRIGHT", SWIG_From_int(static_cast< int >(CURSOR_LEFTRIGHT)));
+  rb_define_const(mFox, "CURSOR_MOVE", SWIG_From_int(static_cast< int >(CURSOR_MOVE)));
+  rb_define_const(mFox, "CURSOR_KEEP", SWIG_From_int(static_cast< int >(CURSOR_KEEP)));
+  rb_define_const(mFox, "CURSOR_OWNED", SWIG_From_int(static_cast< int >(CURSOR_OWNED)));
+  
+  SwigClassFXCursor.klass = rb_define_class_under(mFox, "FXCursor", ((swig_class *) SWIGTYPE_p_FXId->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXCursor, (void *) &SwigClassFXCursor);
+  rb_define_alloc_func(SwigClassFXCursor.klass, _wrap_FXCursor_allocate);
+  rb_define_method(SwigClassFXCursor.klass, "initialize", VALUEFUNC(_wrap_new_FXCursor), -1);
+  rb_define_method(SwigClassFXCursor.klass, "getWidth", VALUEFUNC(_wrap_FXCursor_getWidth), -1);
+  rb_define_method(SwigClassFXCursor.klass, "getHeight", VALUEFUNC(_wrap_FXCursor_getHeight), -1);
+  rb_define_method(SwigClassFXCursor.klass, "setHotX", VALUEFUNC(_wrap_FXCursor_setHotX), -1);
+  rb_define_method(SwigClassFXCursor.klass, "getHotX", VALUEFUNC(_wrap_FXCursor_getHotX), -1);
+  rb_define_method(SwigClassFXCursor.klass, "setHotY", VALUEFUNC(_wrap_FXCursor_setHotY), -1);
+  rb_define_method(SwigClassFXCursor.klass, "getHotY", VALUEFUNC(_wrap_FXCursor_getHotY), -1);
+  rb_define_method(SwigClassFXCursor.klass, "isColor", VALUEFUNC(_wrap_FXCursor_isColor), -1);
+  rb_define_method(SwigClassFXCursor.klass, "save", VALUEFUNC(_wrap_FXCursor_save), -1);
+  rb_define_method(SwigClassFXCursor.klass, "load", VALUEFUNC(_wrap_FXCursor_load), -1);
+  rb_define_method(SwigClassFXCursor.klass, "create", VALUEFUNC(_wrap_FXCursor_create), -1);
+  rb_define_method(SwigClassFXCursor.klass, "detach", VALUEFUNC(_wrap_FXCursor_detach), -1);
+  rb_define_method(SwigClassFXCursor.klass, "destroy", VALUEFUNC(_wrap_FXCursor_destroy), -1);
+  rb_define_method(SwigClassFXCursor.klass, "savePixels", VALUEFUNC(_wrap_FXCursor_savePixels), -1);
+  rb_define_method(SwigClassFXCursor.klass, "loadPixels", VALUEFUNC(_wrap_FXCursor_loadPixels), -1);
+  SwigClassFXCursor.mark = (void (*)(void *)) FXRbCursor::markfunc;
+  SwigClassFXCursor.destroy = (void (*)(void *)) FXRbCursor::freefunc;
+  SwigClassFXCursor.trackObjects = 0;
+  
+  SWIGTYPE_p_FXCursor->dcast = (swig_dycast_func) FXCursor_dynamic_cast;
+  
+  
+  SwigClassFXCURCursor.klass = rb_define_class_under(mFox, "FXCURCursor", ((swig_class *) SWIGTYPE_p_FXCursor->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXCURCursor, (void *) &SwigClassFXCURCursor);
+  rb_define_alloc_func(SwigClassFXCURCursor.klass, _wrap_FXCURCursor_allocate);
+  rb_define_method(SwigClassFXCURCursor.klass, "initialize", VALUEFUNC(_wrap_new_FXCURCursor), -1);
+  rb_define_singleton_method(SwigClassFXCURCursor.klass, "fileExt", VALUEFUNC(_wrap_FXCURCursor_fileExt), -1);
+  rb_define_method(SwigClassFXCURCursor.klass, "save", VALUEFUNC(_wrap_FXCURCursor_save), -1);
+  rb_define_method(SwigClassFXCURCursor.klass, "load", VALUEFUNC(_wrap_FXCURCursor_load), -1);
+  rb_define_method(SwigClassFXCURCursor.klass, "create", VALUEFUNC(_wrap_FXCURCursor_create), -1);
+  rb_define_method(SwigClassFXCURCursor.klass, "detach", VALUEFUNC(_wrap_FXCURCursor_detach), -1);
+  rb_define_method(SwigClassFXCURCursor.klass, "destroy", VALUEFUNC(_wrap_FXCURCursor_destroy), -1);
+  rb_define_method(SwigClassFXCURCursor.klass, "savePixels", VALUEFUNC(_wrap_FXCURCursor_savePixels), -1);
+  rb_define_method(SwigClassFXCURCursor.klass, "loadPixels", VALUEFUNC(_wrap_FXCURCursor_loadPixels), -1);
+  SwigClassFXCURCursor.mark = (void (*)(void *)) FXRbCURCursor::markfunc;
+  SwigClassFXCURCursor.destroy = (void (*)(void *)) FXRbCURCursor::freefunc;
+  SwigClassFXCURCursor.trackObjects = 0;
+  
+  SwigClassFXGIFCursor.klass = rb_define_class_under(mFox, "FXGIFCursor", ((swig_class *) SWIGTYPE_p_FXCursor->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXGIFCursor, (void *) &SwigClassFXGIFCursor);
+  rb_define_alloc_func(SwigClassFXGIFCursor.klass, _wrap_FXGIFCursor_allocate);
+  rb_define_method(SwigClassFXGIFCursor.klass, "initialize", VALUEFUNC(_wrap_new_FXGIFCursor), -1);
+  rb_define_singleton_method(SwigClassFXGIFCursor.klass, "fileExt", VALUEFUNC(_wrap_FXGIFCursor_fileExt), -1);
+  rb_define_method(SwigClassFXGIFCursor.klass, "save", VALUEFUNC(_wrap_FXGIFCursor_save), -1);
+  rb_define_method(SwigClassFXGIFCursor.klass, "load", VALUEFUNC(_wrap_FXGIFCursor_load), -1);
+  rb_define_method(SwigClassFXGIFCursor.klass, "create", VALUEFUNC(_wrap_FXGIFCursor_create), -1);
+  rb_define_method(SwigClassFXGIFCursor.klass, "detach", VALUEFUNC(_wrap_FXGIFCursor_detach), -1);
+  rb_define_method(SwigClassFXGIFCursor.klass, "destroy", VALUEFUNC(_wrap_FXGIFCursor_destroy), -1);
+  rb_define_method(SwigClassFXGIFCursor.klass, "savePixels", VALUEFUNC(_wrap_FXGIFCursor_savePixels), -1);
+  rb_define_method(SwigClassFXGIFCursor.klass, "loadPixels", VALUEFUNC(_wrap_FXGIFCursor_loadPixels), -1);
+  SwigClassFXGIFCursor.mark = (void (*)(void *)) FXRbGIFCursor::markfunc;
+  SwigClassFXGIFCursor.destroy = (void (*)(void *)) FXRbGIFCursor::freefunc;
+  SwigClassFXGIFCursor.trackObjects = 0;
+  rb_define_module_function(mFox, "fxsaveGIF", VALUEFUNC(_wrap_fxsaveGIF), -1);
+  rb_define_module_function(mFox, "fxloadGIF", VALUEFUNC(_wrap_fxloadGIF), -1);
+  rb_define_module_function(mFox, "fxcheckGIF", VALUEFUNC(_wrap_fxcheckGIF), -1);
+  
+  SwigClassFXDrawable.klass = rb_define_class_under(mFox, "FXDrawable", ((swig_class *) SWIGTYPE_p_FXId->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXDrawable, (void *) &SwigClassFXDrawable);
+  rb_define_alloc_func(SwigClassFXDrawable.klass, _wrap_FXDrawable_allocate);
+  rb_define_method(SwigClassFXDrawable.klass, "initialize", VALUEFUNC(_wrap_new_FXDrawable), -1);
+  rb_define_method(SwigClassFXDrawable.klass, "getWidth", VALUEFUNC(_wrap_FXDrawable_getWidth), -1);
+  rb_define_method(SwigClassFXDrawable.klass, "getHeight", VALUEFUNC(_wrap_FXDrawable_getHeight), -1);
+  rb_define_method(SwigClassFXDrawable.klass, "getVisual", VALUEFUNC(_wrap_FXDrawable_getVisual), -1);
+  rb_define_method(SwigClassFXDrawable.klass, "setVisual", VALUEFUNC(_wrap_FXDrawable_setVisual), -1);
+  rb_define_method(SwigClassFXDrawable.klass, "save", VALUEFUNC(_wrap_FXDrawable_save), -1);
+  rb_define_method(SwigClassFXDrawable.klass, "load", VALUEFUNC(_wrap_FXDrawable_load), -1);
+  rb_define_method(SwigClassFXDrawable.klass, "create", VALUEFUNC(_wrap_FXDrawable_create), -1);
+  rb_define_method(SwigClassFXDrawable.klass, "detach", VALUEFUNC(_wrap_FXDrawable_detach), -1);
+  rb_define_method(SwigClassFXDrawable.klass, "destroy", VALUEFUNC(_wrap_FXDrawable_destroy), -1);
+  rb_define_method(SwigClassFXDrawable.klass, "resize", VALUEFUNC(_wrap_FXDrawable_resize), -1);
+  SwigClassFXDrawable.mark = (void (*)(void *)) FXRbDrawable::markfunc;
+  SwigClassFXDrawable.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXDrawable.trackObjects = 0;
+  
+  SWIGTYPE_p_FXDrawable->dcast = (swig_dycast_func) FXDrawable_dynamic_cast;
+  
+  rb_define_const(mFox, "VISUAL_DEFAULT", SWIG_From_int(static_cast< int >(VISUAL_DEFAULT)));
+  rb_define_const(mFox, "VISUAL_MONOCHROME", SWIG_From_int(static_cast< int >(VISUAL_MONOCHROME)));
+  rb_define_const(mFox, "VISUAL_BEST", SWIG_From_int(static_cast< int >(VISUAL_BEST)));
+  rb_define_const(mFox, "VISUAL_INDEXCOLOR", SWIG_From_int(static_cast< int >(VISUAL_INDEXCOLOR)));
+  rb_define_const(mFox, "VISUAL_GRAYSCALE", SWIG_From_int(static_cast< int >(VISUAL_GRAYSCALE)));
+  rb_define_const(mFox, "VISUAL_TRUECOLOR", SWIG_From_int(static_cast< int >(VISUAL_TRUECOLOR)));
+  rb_define_const(mFox, "VISUAL_OWNCOLORMAP", SWIG_From_int(static_cast< int >(VISUAL_OWNCOLORMAP)));
+  rb_define_const(mFox, "VISUAL_DOUBLEBUFFER", SWIG_From_int(static_cast< int >(VISUAL_DOUBLEBUFFER)));
+  rb_define_const(mFox, "VISUAL_STEREO", SWIG_From_int(static_cast< int >(VISUAL_STEREO)));
+  rb_define_const(mFox, "VISUAL_NOACCEL", SWIG_From_int(static_cast< int >(VISUAL_NOACCEL)));
+  rb_define_const(mFox, "VISUAL_SWAP_COPY", SWIG_From_int(static_cast< int >(VISUAL_SWAP_COPY)));
+  rb_define_const(mFox, "VISUALTYPE_UNKNOWN", SWIG_From_int(static_cast< int >(VISUALTYPE_UNKNOWN)));
+  rb_define_const(mFox, "VISUALTYPE_MONO", SWIG_From_int(static_cast< int >(VISUALTYPE_MONO)));
+  rb_define_const(mFox, "VISUALTYPE_TRUE", SWIG_From_int(static_cast< int >(VISUALTYPE_TRUE)));
+  rb_define_const(mFox, "VISUALTYPE_INDEX", SWIG_From_int(static_cast< int >(VISUALTYPE_INDEX)));
+  rb_define_const(mFox, "VISUALTYPE_GRAY", SWIG_From_int(static_cast< int >(VISUALTYPE_GRAY)));
+  
+  SwigClassFXVisual.klass = rb_define_class_under(mFox, "FXVisual", ((swig_class *) SWIGTYPE_p_FXId->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXVisual, (void *) &SwigClassFXVisual);
+  rb_define_alloc_func(SwigClassFXVisual.klass, _wrap_FXVisual_allocate);
+  rb_define_method(SwigClassFXVisual.klass, "initialize", VALUEFUNC(_wrap_new_FXVisual), -1);
+  rb_define_method(SwigClassFXVisual.klass, "visualType", VALUEFUNC(_wrap_FXVisual_visualType), -1);
+  rb_define_method(SwigClassFXVisual.klass, "getFlags", VALUEFUNC(_wrap_FXVisual_getFlags), -1);
+  rb_define_method(SwigClassFXVisual.klass, "getDepth", VALUEFUNC(_wrap_FXVisual_getDepth), -1);
+  rb_define_method(SwigClassFXVisual.klass, "getNumColors", VALUEFUNC(_wrap_FXVisual_getNumColors), -1);
+  rb_define_method(SwigClassFXVisual.klass, "getNumRed", VALUEFUNC(_wrap_FXVisual_getNumRed), -1);
+  rb_define_method(SwigClassFXVisual.klass, "getNumGreen", VALUEFUNC(_wrap_FXVisual_getNumGreen), -1);
+  rb_define_method(SwigClassFXVisual.klass, "getNumBlue", VALUEFUNC(_wrap_FXVisual_getNumBlue), -1);
+  rb_define_method(SwigClassFXVisual.klass, "getPixel", VALUEFUNC(_wrap_FXVisual_getPixel), -1);
+  rb_define_method(SwigClassFXVisual.klass, "getColor", VALUEFUNC(_wrap_FXVisual_getColor), -1);
+  rb_define_method(SwigClassFXVisual.klass, "setMaxColors", VALUEFUNC(_wrap_FXVisual_setMaxColors), -1);
+  rb_define_method(SwigClassFXVisual.klass, "getMaxColors", VALUEFUNC(_wrap_FXVisual_getMaxColors), -1);
+  rb_define_method(SwigClassFXVisual.klass, "save", VALUEFUNC(_wrap_FXVisual_save), -1);
+  rb_define_method(SwigClassFXVisual.klass, "load", VALUEFUNC(_wrap_FXVisual_load), -1);
+  rb_define_method(SwigClassFXVisual.klass, "create", VALUEFUNC(_wrap_FXVisual_create), -1);
+  rb_define_method(SwigClassFXVisual.klass, "detach", VALUEFUNC(_wrap_FXVisual_detach), -1);
+  rb_define_method(SwigClassFXVisual.klass, "destroy", VALUEFUNC(_wrap_FXVisual_destroy), -1);
+  SwigClassFXVisual.mark = (void (*)(void *)) FXRbVisual::markfunc;
+  SwigClassFXVisual.destroy = (void (*)(void *)) FXRbVisual::freefunc;
+  SwigClassFXVisual.trackObjects = 0;
+  
+  SWIGTYPE_p_FXVisual->dcast = (swig_dycast_func) FXVisual_dynamic_cast;
+  
+  rb_define_const(mFox, "FONTENCODING_DEFAULT", SWIG_From_int(static_cast< int >(FONTENCODING_DEFAULT)));
+  rb_define_const(mFox, "FONTENCODING_ISO_8859_1", SWIG_From_int(static_cast< int >(FONTENCODING_ISO_8859_1)));
+  rb_define_const(mFox, "FONTENCODING_ISO_8859_2", SWIG_From_int(static_cast< int >(FONTENCODING_ISO_8859_2)));
+  rb_define_const(mFox, "FONTENCODING_ISO_8859_3", SWIG_From_int(static_cast< int >(FONTENCODING_ISO_8859_3)));
+  rb_define_const(mFox, "FONTENCODING_ISO_8859_4", SWIG_From_int(static_cast< int >(FONTENCODING_ISO_8859_4)));
+  rb_define_const(mFox, "FONTENCODING_ISO_8859_5", SWIG_From_int(static_cast< int >(FONTENCODING_ISO_8859_5)));
+  rb_define_const(mFox, "FONTENCODING_ISO_8859_6", SWIG_From_int(static_cast< int >(FONTENCODING_ISO_8859_6)));
+  rb_define_const(mFox, "FONTENCODING_ISO_8859_7", SWIG_From_int(static_cast< int >(FONTENCODING_ISO_8859_7)));
+  rb_define_const(mFox, "FONTENCODING_ISO_8859_8", SWIG_From_int(static_cast< int >(FONTENCODING_ISO_8859_8)));
+  rb_define_const(mFox, "FONTENCODING_ISO_8859_9", SWIG_From_int(static_cast< int >(FONTENCODING_ISO_8859_9)));
+  rb_define_const(mFox, "FONTENCODING_ISO_8859_10", SWIG_From_int(static_cast< int >(FONTENCODING_ISO_8859_10)));
+  rb_define_const(mFox, "FONTENCODING_ISO_8859_11", SWIG_From_int(static_cast< int >(FONTENCODING_ISO_8859_11)));
+  rb_define_const(mFox, "FONTENCODING_ISO_8859_13", SWIG_From_int(static_cast< int >(FONTENCODING_ISO_8859_13)));
+  rb_define_const(mFox, "FONTENCODING_ISO_8859_14", SWIG_From_int(static_cast< int >(FONTENCODING_ISO_8859_14)));
+  rb_define_const(mFox, "FONTENCODING_ISO_8859_15", SWIG_From_int(static_cast< int >(FONTENCODING_ISO_8859_15)));
+  rb_define_const(mFox, "FONTENCODING_ISO_8859_16", SWIG_From_int(static_cast< int >(FONTENCODING_ISO_8859_16)));
+  rb_define_const(mFox, "FONTENCODING_KOI8", SWIG_From_int(static_cast< int >(FONTENCODING_KOI8)));
+  rb_define_const(mFox, "FONTENCODING_KOI8_R", SWIG_From_int(static_cast< int >(FONTENCODING_KOI8_R)));
+  rb_define_const(mFox, "FONTENCODING_KOI8_U", SWIG_From_int(static_cast< int >(FONTENCODING_KOI8_U)));
+  rb_define_const(mFox, "FONTENCODING_KOI8_UNIFIED", SWIG_From_int(static_cast< int >(FONTENCODING_KOI8_UNIFIED)));
+  rb_define_const(mFox, "FONTENCODING_CP437", SWIG_From_int(static_cast< int >(FONTENCODING_CP437)));
+  rb_define_const(mFox, "FONTENCODING_CP850", SWIG_From_int(static_cast< int >(FONTENCODING_CP850)));
+  rb_define_const(mFox, "FONTENCODING_CP851", SWIG_From_int(static_cast< int >(FONTENCODING_CP851)));
+  rb_define_const(mFox, "FONTENCODING_CP852", SWIG_From_int(static_cast< int >(FONTENCODING_CP852)));
+  rb_define_const(mFox, "FONTENCODING_CP855", SWIG_From_int(static_cast< int >(FONTENCODING_CP855)));
+  rb_define_const(mFox, "FONTENCODING_CP856", SWIG_From_int(static_cast< int >(FONTENCODING_CP856)));
+  rb_define_const(mFox, "FONTENCODING_CP857", SWIG_From_int(static_cast< int >(FONTENCODING_CP857)));
+  rb_define_const(mFox, "FONTENCODING_CP860", SWIG_From_int(static_cast< int >(FONTENCODING_CP860)));
+  rb_define_const(mFox, "FONTENCODING_CP861", SWIG_From_int(static_cast< int >(FONTENCODING_CP861)));
+  rb_define_const(mFox, "FONTENCODING_CP862", SWIG_From_int(static_cast< int >(FONTENCODING_CP862)));
+  rb_define_const(mFox, "FONTENCODING_CP863", SWIG_From_int(static_cast< int >(FONTENCODING_CP863)));
+  rb_define_const(mFox, "FONTENCODING_CP864", SWIG_From_int(static_cast< int >(FONTENCODING_CP864)));
+  rb_define_const(mFox, "FONTENCODING_CP865", SWIG_From_int(static_cast< int >(FONTENCODING_CP865)));
+  rb_define_const(mFox, "FONTENCODING_CP866", SWIG_From_int(static_cast< int >(FONTENCODING_CP866)));
+  rb_define_const(mFox, "FONTENCODING_CP869", SWIG_From_int(static_cast< int >(FONTENCODING_CP869)));
+  rb_define_const(mFox, "FONTENCODING_CP870", SWIG_From_int(static_cast< int >(FONTENCODING_CP870)));
+  rb_define_const(mFox, "FONTENCODING_CP1250", SWIG_From_int(static_cast< int >(FONTENCODING_CP1250)));
+  rb_define_const(mFox, "FONTENCODING_CP1251", SWIG_From_int(static_cast< int >(FONTENCODING_CP1251)));
+  rb_define_const(mFox, "FONTENCODING_CP1252", SWIG_From_int(static_cast< int >(FONTENCODING_CP1252)));
+  rb_define_const(mFox, "FONTENCODING_CP1253", SWIG_From_int(static_cast< int >(FONTENCODING_CP1253)));
+  rb_define_const(mFox, "FONTENCODING_CP1254", SWIG_From_int(static_cast< int >(FONTENCODING_CP1254)));
+  rb_define_const(mFox, "FONTENCODING_CP1255", SWIG_From_int(static_cast< int >(FONTENCODING_CP1255)));
+  rb_define_const(mFox, "FONTENCODING_CP1256", SWIG_From_int(static_cast< int >(FONTENCODING_CP1256)));
+  rb_define_const(mFox, "FONTENCODING_CP1257", SWIG_From_int(static_cast< int >(FONTENCODING_CP1257)));
+  rb_define_const(mFox, "FONTENCODING_CP1258", SWIG_From_int(static_cast< int >(FONTENCODING_CP1258)));
+  rb_define_const(mFox, "FONTENCODING_CP874", SWIG_From_int(static_cast< int >(FONTENCODING_CP874)));
+  rb_define_const(mFox, "FONTENCODING_UNICODE", SWIG_From_int(static_cast< int >(FONTENCODING_UNICODE)));
+  rb_define_const(mFox, "FONTENCODING_LATIN1", SWIG_From_int(static_cast< int >(FONTENCODING_LATIN1)));
+  rb_define_const(mFox, "FONTENCODING_LATIN2", SWIG_From_int(static_cast< int >(FONTENCODING_LATIN2)));
+  rb_define_const(mFox, "FONTENCODING_LATIN3", SWIG_From_int(static_cast< int >(FONTENCODING_LATIN3)));
+  rb_define_const(mFox, "FONTENCODING_LATIN4", SWIG_From_int(static_cast< int >(FONTENCODING_LATIN4)));
+  rb_define_const(mFox, "FONTENCODING_LATIN5", SWIG_From_int(static_cast< int >(FONTENCODING_LATIN5)));
+  rb_define_const(mFox, "FONTENCODING_LATIN6", SWIG_From_int(static_cast< int >(FONTENCODING_LATIN6)));
+  rb_define_const(mFox, "FONTENCODING_LATIN7", SWIG_From_int(static_cast< int >(FONTENCODING_LATIN7)));
+  rb_define_const(mFox, "FONTENCODING_LATIN8", SWIG_From_int(static_cast< int >(FONTENCODING_LATIN8)));
+  rb_define_const(mFox, "FONTENCODING_LATIN9", SWIG_From_int(static_cast< int >(FONTENCODING_LATIN9)));
+  rb_define_const(mFox, "FONTENCODING_LATIN10", SWIG_From_int(static_cast< int >(FONTENCODING_LATIN10)));
+  rb_define_const(mFox, "FONTENCODING_USASCII", SWIG_From_int(static_cast< int >(FONTENCODING_USASCII)));
+  rb_define_const(mFox, "FONTENCODING_WESTEUROPE", SWIG_From_int(static_cast< int >(FONTENCODING_WESTEUROPE)));
+  rb_define_const(mFox, "FONTENCODING_EASTEUROPE", SWIG_From_int(static_cast< int >(FONTENCODING_EASTEUROPE)));
+  rb_define_const(mFox, "FONTENCODING_SOUTHEUROPE", SWIG_From_int(static_cast< int >(FONTENCODING_SOUTHEUROPE)));
+  rb_define_const(mFox, "FONTENCODING_NORTHEUROPE", SWIG_From_int(static_cast< int >(FONTENCODING_NORTHEUROPE)));
+  rb_define_const(mFox, "FONTENCODING_CYRILLIC", SWIG_From_int(static_cast< int >(FONTENCODING_CYRILLIC)));
+  rb_define_const(mFox, "FONTENCODING_RUSSIAN", SWIG_From_int(static_cast< int >(FONTENCODING_RUSSIAN)));
+  rb_define_const(mFox, "FONTENCODING_ARABIC", SWIG_From_int(static_cast< int >(FONTENCODING_ARABIC)));
+  rb_define_const(mFox, "FONTENCODING_GREEK", SWIG_From_int(static_cast< int >(FONTENCODING_GREEK)));
+  rb_define_const(mFox, "FONTENCODING_HEBREW", SWIG_From_int(static_cast< int >(FONTENCODING_HEBREW)));
+  rb_define_const(mFox, "FONTENCODING_TURKISH", SWIG_From_int(static_cast< int >(FONTENCODING_TURKISH)));
+  rb_define_const(mFox, "FONTENCODING_NORDIC", SWIG_From_int(static_cast< int >(FONTENCODING_NORDIC)));
+  rb_define_const(mFox, "FONTENCODING_THAI", SWIG_From_int(static_cast< int >(FONTENCODING_THAI)));
+  rb_define_const(mFox, "FONTENCODING_BALTIC", SWIG_From_int(static_cast< int >(FONTENCODING_BALTIC)));
+  rb_define_const(mFox, "FONTENCODING_CELTIC", SWIG_From_int(static_cast< int >(FONTENCODING_CELTIC)));
+  
+  SwigClassFXFontDesc.klass = rb_define_class_under(mFox, "FXFontDesc", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXFontDesc, (void *) &SwigClassFXFontDesc);
+  rb_define_alloc_func(SwigClassFXFontDesc.klass, _wrap_FXFontDesc_allocate);
+  rb_define_method(SwigClassFXFontDesc.klass, "initialize", VALUEFUNC(_wrap_new_FXFontDesc), -1);
+  rb_define_method(SwigClassFXFontDesc.klass, "face=", VALUEFUNC(_wrap_FXFontDesc_face_set), -1);
+  rb_define_method(SwigClassFXFontDesc.klass, "face", VALUEFUNC(_wrap_FXFontDesc_face_get), -1);
+  rb_define_method(SwigClassFXFontDesc.klass, "size=", VALUEFUNC(_wrap_FXFontDesc_size_set), -1);
+  rb_define_method(SwigClassFXFontDesc.klass, "size", VALUEFUNC(_wrap_FXFontDesc_size_get), -1);
+  rb_define_method(SwigClassFXFontDesc.klass, "weight=", VALUEFUNC(_wrap_FXFontDesc_weight_set), -1);
+  rb_define_method(SwigClassFXFontDesc.klass, "weight", VALUEFUNC(_wrap_FXFontDesc_weight_get), -1);
+  rb_define_method(SwigClassFXFontDesc.klass, "slant=", VALUEFUNC(_wrap_FXFontDesc_slant_set), -1);
+  rb_define_method(SwigClassFXFontDesc.klass, "slant", VALUEFUNC(_wrap_FXFontDesc_slant_get), -1);
+  rb_define_method(SwigClassFXFontDesc.klass, "setwidth=", VALUEFUNC(_wrap_FXFontDesc_setwidth_set), -1);
+  rb_define_method(SwigClassFXFontDesc.klass, "setwidth", VALUEFUNC(_wrap_FXFontDesc_setwidth_get), -1);
+  rb_define_method(SwigClassFXFontDesc.klass, "encoding=", VALUEFUNC(_wrap_FXFontDesc_encoding_set), -1);
+  rb_define_method(SwigClassFXFontDesc.klass, "encoding", VALUEFUNC(_wrap_FXFontDesc_encoding_get), -1);
+  rb_define_method(SwigClassFXFontDesc.klass, "flags=", VALUEFUNC(_wrap_FXFontDesc_flags_set), -1);
+  rb_define_method(SwigClassFXFontDesc.klass, "flags", VALUEFUNC(_wrap_FXFontDesc_flags_get), -1);
+  SwigClassFXFontDesc.mark = 0;
+  SwigClassFXFontDesc.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXFontDesc.trackObjects = 0;
+  
+  SwigClassFXFont.klass = rb_define_class_under(mFox, "FXFont", ((swig_class *) SWIGTYPE_p_FXId->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXFont, (void *) &SwigClassFXFont);
+  rb_define_alloc_func(SwigClassFXFont.klass, _wrap_FXFont_allocate);
+  rb_define_method(SwigClassFXFont.klass, "initialize", VALUEFUNC(_wrap_new_FXFont), -1);
+  rb_define_const(SwigClassFXFont.klass, "Fixed", SWIG_From_int(static_cast< int >(FXFont::Fixed)));
+  rb_define_const(SwigClassFXFont.klass, "Variable", SWIG_From_int(static_cast< int >(FXFont::Variable)));
+  rb_define_const(SwigClassFXFont.klass, "Decorative", SWIG_From_int(static_cast< int >(FXFont::Decorative)));
+  rb_define_const(SwigClassFXFont.klass, "Modern", SWIG_From_int(static_cast< int >(FXFont::Modern)));
+  rb_define_const(SwigClassFXFont.klass, "Roman", SWIG_From_int(static_cast< int >(FXFont::Roman)));
+  rb_define_const(SwigClassFXFont.klass, "Script", SWIG_From_int(static_cast< int >(FXFont::Script)));
+  rb_define_const(SwigClassFXFont.klass, "Swiss", SWIG_From_int(static_cast< int >(FXFont::Swiss)));
+  rb_define_const(SwigClassFXFont.klass, "System", SWIG_From_int(static_cast< int >(FXFont::System)));
+  rb_define_const(SwigClassFXFont.klass, "X11", SWIG_From_int(static_cast< int >(FXFont::X11)));
+  rb_define_const(SwigClassFXFont.klass, "Scalable", SWIG_From_int(static_cast< int >(FXFont::Scalable)));
+  rb_define_const(SwigClassFXFont.klass, "Polymorphic", SWIG_From_int(static_cast< int >(FXFont::Polymorphic)));
+  rb_define_const(SwigClassFXFont.klass, "Rotatable", SWIG_From_int(static_cast< int >(FXFont::Rotatable)));
+  rb_define_const(SwigClassFXFont.klass, "ReverseOblique", SWIG_From_int(static_cast< int >(FXFont::ReverseOblique)));
+  rb_define_const(SwigClassFXFont.klass, "ReverseItalic", SWIG_From_int(static_cast< int >(FXFont::ReverseItalic)));
+  rb_define_const(SwigClassFXFont.klass, "Straight", SWIG_From_int(static_cast< int >(FXFont::Straight)));
+  rb_define_const(SwigClassFXFont.klass, "Italic", SWIG_From_int(static_cast< int >(FXFont::Italic)));
+  rb_define_const(SwigClassFXFont.klass, "Oblique", SWIG_From_int(static_cast< int >(FXFont::Oblique)));
+  rb_define_const(SwigClassFXFont.klass, "Thin", SWIG_From_int(static_cast< int >(FXFont::Thin)));
+  rb_define_const(SwigClassFXFont.klass, "ExtraLight", SWIG_From_int(static_cast< int >(FXFont::ExtraLight)));
+  rb_define_const(SwigClassFXFont.klass, "Light", SWIG_From_int(static_cast< int >(FXFont::Light)));
+  rb_define_const(SwigClassFXFont.klass, "Normal", SWIG_From_int(static_cast< int >(FXFont::Normal)));
+  rb_define_const(SwigClassFXFont.klass, "Medium", SWIG_From_int(static_cast< int >(FXFont::Medium)));
+  rb_define_const(SwigClassFXFont.klass, "DemiBold", SWIG_From_int(static_cast< int >(FXFont::DemiBold)));
+  rb_define_const(SwigClassFXFont.klass, "Bold", SWIG_From_int(static_cast< int >(FXFont::Bold)));
+  rb_define_const(SwigClassFXFont.klass, "ExtraBold", SWIG_From_int(static_cast< int >(FXFont::ExtraBold)));
+  rb_define_const(SwigClassFXFont.klass, "Black", SWIG_From_int(static_cast< int >(FXFont::Black)));
+  rb_define_const(SwigClassFXFont.klass, "UltraCondensed", SWIG_From_int(static_cast< int >(FXFont::UltraCondensed)));
+  rb_define_const(SwigClassFXFont.klass, "ExtraCondensed", SWIG_From_int(static_cast< int >(FXFont::ExtraCondensed)));
+  rb_define_const(SwigClassFXFont.klass, "Condensed", SWIG_From_int(static_cast< int >(FXFont::Condensed)));
+  rb_define_const(SwigClassFXFont.klass, "SemiCondensed", SWIG_From_int(static_cast< int >(FXFont::SemiCondensed)));
+  rb_define_const(SwigClassFXFont.klass, "NonExpanded", SWIG_From_int(static_cast< int >(FXFont::NonExpanded)));
+  rb_define_const(SwigClassFXFont.klass, "SemiExpanded", SWIG_From_int(static_cast< int >(FXFont::SemiExpanded)));
+  rb_define_const(SwigClassFXFont.klass, "Expanded", SWIG_From_int(static_cast< int >(FXFont::Expanded)));
+  rb_define_const(SwigClassFXFont.klass, "ExtraExpanded", SWIG_From_int(static_cast< int >(FXFont::ExtraExpanded)));
+  rb_define_const(SwigClassFXFont.klass, "UltraExpanded", SWIG_From_int(static_cast< int >(FXFont::UltraExpanded)));
+  rb_define_method(SwigClassFXFont.klass, "family", VALUEFUNC(_wrap_FXFont_family), -1);
+  rb_define_method(SwigClassFXFont.klass, "foundry", VALUEFUNC(_wrap_FXFont_foundry), -1);
+  rb_define_method(SwigClassFXFont.klass, "getName", VALUEFUNC(_wrap_FXFont_getName), -1);
+  rb_define_method(SwigClassFXFont.klass, "getActualName", VALUEFUNC(_wrap_FXFont_getActualName), -1);
+  rb_define_method(SwigClassFXFont.klass, "getSize", VALUEFUNC(_wrap_FXFont_getSize), -1);
+  rb_define_method(SwigClassFXFont.klass, "getActualSize", VALUEFUNC(_wrap_FXFont_getActualSize), -1);
+  rb_define_method(SwigClassFXFont.klass, "getWeight", VALUEFUNC(_wrap_FXFont_getWeight), -1);
+  rb_define_method(SwigClassFXFont.klass, "getActualWeight", VALUEFUNC(_wrap_FXFont_getActualWeight), -1);
+  rb_define_method(SwigClassFXFont.klass, "getSlant", VALUEFUNC(_wrap_FXFont_getSlant), -1);
+  rb_define_method(SwigClassFXFont.klass, "getActualSlant", VALUEFUNC(_wrap_FXFont_getActualSlant), -1);
+  rb_define_method(SwigClassFXFont.klass, "getEncoding", VALUEFUNC(_wrap_FXFont_getEncoding), -1);
+  rb_define_method(SwigClassFXFont.klass, "getActualEncoding", VALUEFUNC(_wrap_FXFont_getActualEncoding), -1);
+  rb_define_method(SwigClassFXFont.klass, "getSetWidth", VALUEFUNC(_wrap_FXFont_getSetWidth), -1);
+  rb_define_method(SwigClassFXFont.klass, "getActualSetWidth", VALUEFUNC(_wrap_FXFont_getActualSetWidth), -1);
+  rb_define_method(SwigClassFXFont.klass, "getHints", VALUEFUNC(_wrap_FXFont_getHints), -1);
+  rb_define_method(SwigClassFXFont.klass, "flags", VALUEFUNC(_wrap_FXFont_flags), -1);
+  rb_define_method(SwigClassFXFont.klass, "getFontDesc", VALUEFUNC(_wrap_FXFont_getFontDesc), -1);
+  rb_define_method(SwigClassFXFont.klass, "angle", VALUEFUNC(_wrap_FXFont_angle), -1);
+  rb_define_method(SwigClassFXFont.klass, "font", VALUEFUNC(_wrap_FXFont_font), -1);
+  rb_define_singleton_method(SwigClassFXFont.klass, "listFonts", VALUEFUNC(_wrap_FXFont_listFonts), -1);
+  rb_define_method(SwigClassFXFont.klass, "save", VALUEFUNC(_wrap_FXFont_save), -1);
+  rb_define_method(SwigClassFXFont.klass, "load", VALUEFUNC(_wrap_FXFont_load), -1);
+  rb_define_method(SwigClassFXFont.klass, "create", VALUEFUNC(_wrap_FXFont_create), -1);
+  rb_define_method(SwigClassFXFont.klass, "detach", VALUEFUNC(_wrap_FXFont_detach), -1);
+  rb_define_method(SwigClassFXFont.klass, "destroy", VALUEFUNC(_wrap_FXFont_destroy), -1);
+  rb_define_method(SwigClassFXFont.klass, "setFontDesc", VALUEFUNC(_wrap_FXFont_setFontDesc), -1);
+  rb_define_method(SwigClassFXFont.klass, "setAngle", VALUEFUNC(_wrap_FXFont_setAngle), -1);
+  rb_define_method(SwigClassFXFont.klass, "setFont", VALUEFUNC(_wrap_FXFont_setFont), -1);
+  rb_define_method(SwigClassFXFont.klass, "isFontMono", VALUEFUNC(_wrap_FXFont_isFontMono), -1);
+  rb_define_method(SwigClassFXFont.klass, "hasChar", VALUEFUNC(_wrap_FXFont_hasChar), -1);
+  rb_define_method(SwigClassFXFont.klass, "getMinChar", VALUEFUNC(_wrap_FXFont_getMinChar), -1);
+  rb_define_method(SwigClassFXFont.klass, "getMaxChar", VALUEFUNC(_wrap_FXFont_getMaxChar), -1);
+  rb_define_method(SwigClassFXFont.klass, "leftBearing", VALUEFUNC(_wrap_FXFont_leftBearing), -1);
+  rb_define_method(SwigClassFXFont.klass, "rightBearing", VALUEFUNC(_wrap_FXFont_rightBearing), -1);
+  rb_define_method(SwigClassFXFont.klass, "getFontWidth", VALUEFUNC(_wrap_FXFont_getFontWidth), -1);
+  rb_define_method(SwigClassFXFont.klass, "getFontHeight", VALUEFUNC(_wrap_FXFont_getFontHeight), -1);
+  rb_define_method(SwigClassFXFont.klass, "getFontAscent", VALUEFUNC(_wrap_FXFont_getFontAscent), -1);
+  rb_define_method(SwigClassFXFont.klass, "getFontDescent", VALUEFUNC(_wrap_FXFont_getFontDescent), -1);
+  rb_define_method(SwigClassFXFont.klass, "getFontLeading", VALUEFUNC(_wrap_FXFont_getFontLeading), -1);
+  rb_define_method(SwigClassFXFont.klass, "getFontSpacing", VALUEFUNC(_wrap_FXFont_getFontSpacing), -1);
+  rb_define_method(SwigClassFXFont.klass, "getCharWidth", VALUEFUNC(_wrap_FXFont_getCharWidth), -1);
+  rb_define_method(SwigClassFXFont.klass, "getTextWidth", VALUEFUNC(_wrap_FXFont_getTextWidth), -1);
+  rb_define_method(SwigClassFXFont.klass, "getTextHeight", VALUEFUNC(_wrap_FXFont_getTextHeight), -1);
+  SwigClassFXFont.mark = (void (*)(void *)) FXRbFont::markfunc;
+  SwigClassFXFont.destroy = (void (*)(void *)) FXRbFont::freefunc;
+  SwigClassFXFont.trackObjects = 0;
+  rb_define_const(mFox, "LAYOUT_NORMAL", SWIG_From_int(static_cast< int >(LAYOUT_NORMAL)));
+  rb_define_const(mFox, "LAYOUT_SIDE_TOP", SWIG_From_int(static_cast< int >(LAYOUT_SIDE_TOP)));
+  rb_define_const(mFox, "LAYOUT_SIDE_BOTTOM", SWIG_From_int(static_cast< int >(LAYOUT_SIDE_BOTTOM)));
+  rb_define_const(mFox, "LAYOUT_SIDE_LEFT", SWIG_From_int(static_cast< int >(LAYOUT_SIDE_LEFT)));
+  rb_define_const(mFox, "LAYOUT_SIDE_RIGHT", SWIG_From_int(static_cast< int >(LAYOUT_SIDE_RIGHT)));
+  rb_define_const(mFox, "LAYOUT_FILL_COLUMN", SWIG_From_int(static_cast< int >(LAYOUT_FILL_COLUMN)));
+  rb_define_const(mFox, "LAYOUT_FILL_ROW", SWIG_From_int(static_cast< int >(LAYOUT_FILL_ROW)));
+  rb_define_const(mFox, "LAYOUT_LEFT", SWIG_From_int(static_cast< int >(LAYOUT_LEFT)));
+  rb_define_const(mFox, "LAYOUT_RIGHT", SWIG_From_int(static_cast< int >(LAYOUT_RIGHT)));
+  rb_define_const(mFox, "LAYOUT_CENTER_X", SWIG_From_int(static_cast< int >(LAYOUT_CENTER_X)));
+  rb_define_const(mFox, "LAYOUT_FIX_X", SWIG_From_int(static_cast< int >(LAYOUT_FIX_X)));
+  rb_define_const(mFox, "LAYOUT_TOP", SWIG_From_int(static_cast< int >(LAYOUT_TOP)));
+  rb_define_const(mFox, "LAYOUT_BOTTOM", SWIG_From_int(static_cast< int >(LAYOUT_BOTTOM)));
+  rb_define_const(mFox, "LAYOUT_CENTER_Y", SWIG_From_int(static_cast< int >(LAYOUT_CENTER_Y)));
+  rb_define_const(mFox, "LAYOUT_FIX_Y", SWIG_From_int(static_cast< int >(LAYOUT_FIX_Y)));
+  rb_define_const(mFox, "LAYOUT_DOCK_SAME", SWIG_From_int(static_cast< int >(LAYOUT_DOCK_SAME)));
+  rb_define_const(mFox, "LAYOUT_DOCK_NEXT", SWIG_From_int(static_cast< int >(LAYOUT_DOCK_NEXT)));
+  rb_define_const(mFox, "LAYOUT_RESERVED_1", SWIG_From_int(static_cast< int >(LAYOUT_RESERVED_1)));
+  rb_define_const(mFox, "LAYOUT_FIX_WIDTH", SWIG_From_int(static_cast< int >(LAYOUT_FIX_WIDTH)));
+  rb_define_const(mFox, "LAYOUT_FIX_HEIGHT", SWIG_From_int(static_cast< int >(LAYOUT_FIX_HEIGHT)));
+  rb_define_const(mFox, "LAYOUT_MIN_WIDTH", SWIG_From_int(static_cast< int >(LAYOUT_MIN_WIDTH)));
+  rb_define_const(mFox, "LAYOUT_MIN_HEIGHT", SWIG_From_int(static_cast< int >(LAYOUT_MIN_HEIGHT)));
+  rb_define_const(mFox, "LAYOUT_FILL_X", SWIG_From_int(static_cast< int >(LAYOUT_FILL_X)));
+  rb_define_const(mFox, "LAYOUT_FILL_Y", SWIG_From_int(static_cast< int >(LAYOUT_FILL_Y)));
+  rb_define_const(mFox, "LAYOUT_FILL", SWIG_From_int(static_cast< int >(LAYOUT_FILL)));
+  rb_define_const(mFox, "LAYOUT_EXPLICIT", SWIG_From_int(static_cast< int >(LAYOUT_EXPLICIT)));
+  rb_define_const(mFox, "FRAME_NONE", SWIG_From_int(static_cast< int >(FRAME_NONE)));
+  rb_define_const(mFox, "FRAME_SUNKEN", SWIG_From_int(static_cast< int >(FRAME_SUNKEN)));
+  rb_define_const(mFox, "FRAME_RAISED", SWIG_From_int(static_cast< int >(FRAME_RAISED)));
+  rb_define_const(mFox, "FRAME_THICK", SWIG_From_int(static_cast< int >(FRAME_THICK)));
+  rb_define_const(mFox, "FRAME_GROOVE", SWIG_From_int(static_cast< int >(FRAME_GROOVE)));
+  rb_define_const(mFox, "FRAME_RIDGE", SWIG_From_int(static_cast< int >(FRAME_RIDGE)));
+  rb_define_const(mFox, "FRAME_LINE", SWIG_From_int(static_cast< int >(FRAME_LINE)));
+  rb_define_const(mFox, "FRAME_NORMAL", SWIG_From_int(static_cast< int >(FRAME_NORMAL)));
+  rb_define_const(mFox, "PACK_NORMAL", SWIG_From_int(static_cast< int >(PACK_NORMAL)));
+  rb_define_const(mFox, "PACK_UNIFORM_HEIGHT", SWIG_From_int(static_cast< int >(PACK_UNIFORM_HEIGHT)));
+  rb_define_const(mFox, "PACK_UNIFORM_WIDTH", SWIG_From_int(static_cast< int >(PACK_UNIFORM_WIDTH)));
+  
+  SwigClassFXWindow.klass = rb_define_class_under(mFox, "FXWindow", ((swig_class *) SWIGTYPE_p_FXDrawable->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXWindow, (void *) &SwigClassFXWindow);
+  rb_define_alloc_func(SwigClassFXWindow.klass, _wrap_FXWindow_allocate);
+  rb_define_method(SwigClassFXWindow.klass, "initialize", VALUEFUNC(_wrap_new_FXWindow), -1);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "octetType", VALUEFUNC(_wrap_FXWindow_octetType_get), 0);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "octetType=", VALUEFUNC(_wrap_FXWindow_octetType_set), 1);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "deleteType", VALUEFUNC(_wrap_FXWindow_deleteType_get), 0);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "deleteType=", VALUEFUNC(_wrap_FXWindow_deleteType_set), 1);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "textType", VALUEFUNC(_wrap_FXWindow_textType_get), 0);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "textType=", VALUEFUNC(_wrap_FXWindow_textType_set), 1);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "utf8Type", VALUEFUNC(_wrap_FXWindow_utf8Type_get), 0);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "utf8Type=", VALUEFUNC(_wrap_FXWindow_utf8Type_set), 1);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "utf16Type", VALUEFUNC(_wrap_FXWindow_utf16Type_get), 0);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "utf16Type=", VALUEFUNC(_wrap_FXWindow_utf16Type_set), 1);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "colorType", VALUEFUNC(_wrap_FXWindow_colorType_get), 0);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "colorType=", VALUEFUNC(_wrap_FXWindow_colorType_set), 1);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "urilistType", VALUEFUNC(_wrap_FXWindow_urilistType_get), 0);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "urilistType=", VALUEFUNC(_wrap_FXWindow_urilistType_set), 1);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "stringType", VALUEFUNC(_wrap_FXWindow_stringType_get), 0);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "imageType", VALUEFUNC(_wrap_FXWindow_imageType_get), 0);
+  rb_define_method(SwigClassFXWindow.klass, "onPaint", VALUEFUNC(_wrap_FXWindow_onPaint), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onMap", VALUEFUNC(_wrap_FXWindow_onMap), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onUnmap", VALUEFUNC(_wrap_FXWindow_onUnmap), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onConfigure", VALUEFUNC(_wrap_FXWindow_onConfigure), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onUpdate", VALUEFUNC(_wrap_FXWindow_onUpdate), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onMotion", VALUEFUNC(_wrap_FXWindow_onMotion), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onMouseWheel", VALUEFUNC(_wrap_FXWindow_onMouseWheel), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onEnter", VALUEFUNC(_wrap_FXWindow_onEnter), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onLeave", VALUEFUNC(_wrap_FXWindow_onLeave), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXWindow_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXWindow_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onMiddleBtnPress", VALUEFUNC(_wrap_FXWindow_onMiddleBtnPress), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onMiddleBtnRelease", VALUEFUNC(_wrap_FXWindow_onMiddleBtnRelease), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onRightBtnPress", VALUEFUNC(_wrap_FXWindow_onRightBtnPress), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onRightBtnRelease", VALUEFUNC(_wrap_FXWindow_onRightBtnRelease), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onBeginDrag", VALUEFUNC(_wrap_FXWindow_onBeginDrag), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onEndDrag", VALUEFUNC(_wrap_FXWindow_onEndDrag), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onDragged", VALUEFUNC(_wrap_FXWindow_onDragged), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onKeyPress", VALUEFUNC(_wrap_FXWindow_onKeyPress), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onKeyRelease", VALUEFUNC(_wrap_FXWindow_onKeyRelease), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onUngrabbed", VALUEFUNC(_wrap_FXWindow_onUngrabbed), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onDestroy", VALUEFUNC(_wrap_FXWindow_onDestroy), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onFocusSelf", VALUEFUNC(_wrap_FXWindow_onFocusSelf), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onFocusIn", VALUEFUNC(_wrap_FXWindow_onFocusIn), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onFocusOut", VALUEFUNC(_wrap_FXWindow_onFocusOut), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onSelectionLost", VALUEFUNC(_wrap_FXWindow_onSelectionLost), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onSelectionGained", VALUEFUNC(_wrap_FXWindow_onSelectionGained), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onSelectionRequest", VALUEFUNC(_wrap_FXWindow_onSelectionRequest), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onClipboardLost", VALUEFUNC(_wrap_FXWindow_onClipboardLost), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onClipboardGained", VALUEFUNC(_wrap_FXWindow_onClipboardGained), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onClipboardRequest", VALUEFUNC(_wrap_FXWindow_onClipboardRequest), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onDNDEnter", VALUEFUNC(_wrap_FXWindow_onDNDEnter), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onDNDLeave", VALUEFUNC(_wrap_FXWindow_onDNDLeave), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onDNDMotion", VALUEFUNC(_wrap_FXWindow_onDNDMotion), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onDNDDrop", VALUEFUNC(_wrap_FXWindow_onDNDDrop), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onDNDRequest", VALUEFUNC(_wrap_FXWindow_onDNDRequest), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onQueryHelp", VALUEFUNC(_wrap_FXWindow_onQueryHelp), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onQueryTip", VALUEFUNC(_wrap_FXWindow_onQueryTip), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onCmdShow", VALUEFUNC(_wrap_FXWindow_onCmdShow), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onCmdHide", VALUEFUNC(_wrap_FXWindow_onCmdHide), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onUpdToggleShown", VALUEFUNC(_wrap_FXWindow_onUpdToggleShown), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onCmdToggleShown", VALUEFUNC(_wrap_FXWindow_onCmdToggleShown), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onCmdRaise", VALUEFUNC(_wrap_FXWindow_onCmdRaise), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onCmdLower", VALUEFUNC(_wrap_FXWindow_onCmdLower), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onCmdEnable", VALUEFUNC(_wrap_FXWindow_onCmdEnable), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onCmdDisable", VALUEFUNC(_wrap_FXWindow_onCmdDisable), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onUpdToggleEnabled", VALUEFUNC(_wrap_FXWindow_onUpdToggleEnabled), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onCmdToggleEnabled", VALUEFUNC(_wrap_FXWindow_onCmdToggleEnabled), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onCmdUpdate", VALUEFUNC(_wrap_FXWindow_onCmdUpdate), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onUpdYes", VALUEFUNC(_wrap_FXWindow_onUpdYes), -1);
+  rb_define_method(SwigClassFXWindow.klass, "onCmdDelete", VALUEFUNC(_wrap_FXWindow_onCmdDelete), -1);
+  rb_define_const(SwigClassFXWindow.klass, "ID_NONE", SWIG_From_int(static_cast< int >(FXWindow::ID_NONE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_HIDE", SWIG_From_int(static_cast< int >(FXWindow::ID_HIDE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_SHOW", SWIG_From_int(static_cast< int >(FXWindow::ID_SHOW)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_TOGGLESHOWN", SWIG_From_int(static_cast< int >(FXWindow::ID_TOGGLESHOWN)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_LOWER", SWIG_From_int(static_cast< int >(FXWindow::ID_LOWER)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_RAISE", SWIG_From_int(static_cast< int >(FXWindow::ID_RAISE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_DELETE", SWIG_From_int(static_cast< int >(FXWindow::ID_DELETE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_DISABLE", SWIG_From_int(static_cast< int >(FXWindow::ID_DISABLE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_ENABLE", SWIG_From_int(static_cast< int >(FXWindow::ID_ENABLE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_TOGGLEENABLED", SWIG_From_int(static_cast< int >(FXWindow::ID_TOGGLEENABLED)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_UNCHECK", SWIG_From_int(static_cast< int >(FXWindow::ID_UNCHECK)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_CHECK", SWIG_From_int(static_cast< int >(FXWindow::ID_CHECK)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_UNKNOWN", SWIG_From_int(static_cast< int >(FXWindow::ID_UNKNOWN)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_UPDATE", SWIG_From_int(static_cast< int >(FXWindow::ID_UPDATE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_AUTOSCROLL", SWIG_From_int(static_cast< int >(FXWindow::ID_AUTOSCROLL)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_TIPTIMER", SWIG_From_int(static_cast< int >(FXWindow::ID_TIPTIMER)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_HSCROLLED", SWIG_From_int(static_cast< int >(FXWindow::ID_HSCROLLED)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_VSCROLLED", SWIG_From_int(static_cast< int >(FXWindow::ID_VSCROLLED)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_SETVALUE", SWIG_From_int(static_cast< int >(FXWindow::ID_SETVALUE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_SETINTVALUE", SWIG_From_int(static_cast< int >(FXWindow::ID_SETINTVALUE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_SETREALVALUE", SWIG_From_int(static_cast< int >(FXWindow::ID_SETREALVALUE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_SETSTRINGVALUE", SWIG_From_int(static_cast< int >(FXWindow::ID_SETSTRINGVALUE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_SETICONVALUE", SWIG_From_int(static_cast< int >(FXWindow::ID_SETICONVALUE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_SETINTRANGE", SWIG_From_int(static_cast< int >(FXWindow::ID_SETINTRANGE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_SETREALRANGE", SWIG_From_int(static_cast< int >(FXWindow::ID_SETREALRANGE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_GETINTVALUE", SWIG_From_int(static_cast< int >(FXWindow::ID_GETINTVALUE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_GETREALVALUE", SWIG_From_int(static_cast< int >(FXWindow::ID_GETREALVALUE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_GETSTRINGVALUE", SWIG_From_int(static_cast< int >(FXWindow::ID_GETSTRINGVALUE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_GETICONVALUE", SWIG_From_int(static_cast< int >(FXWindow::ID_GETICONVALUE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_GETINTRANGE", SWIG_From_int(static_cast< int >(FXWindow::ID_GETINTRANGE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_GETREALRANGE", SWIG_From_int(static_cast< int >(FXWindow::ID_GETREALRANGE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_SETHELPSTRING", SWIG_From_int(static_cast< int >(FXWindow::ID_SETHELPSTRING)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_GETHELPSTRING", SWIG_From_int(static_cast< int >(FXWindow::ID_GETHELPSTRING)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_SETTIPSTRING", SWIG_From_int(static_cast< int >(FXWindow::ID_SETTIPSTRING)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_GETTIPSTRING", SWIG_From_int(static_cast< int >(FXWindow::ID_GETTIPSTRING)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_QUERY_MENU", SWIG_From_int(static_cast< int >(FXWindow::ID_QUERY_MENU)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_HOTKEY", SWIG_From_int(static_cast< int >(FXWindow::ID_HOTKEY)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_ACCEL", SWIG_From_int(static_cast< int >(FXWindow::ID_ACCEL)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_UNPOST", SWIG_From_int(static_cast< int >(FXWindow::ID_UNPOST)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_POST", SWIG_From_int(static_cast< int >(FXWindow::ID_POST)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_MDI_TILEHORIZONTAL", SWIG_From_int(static_cast< int >(FXWindow::ID_MDI_TILEHORIZONTAL)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_MDI_TILEVERTICAL", SWIG_From_int(static_cast< int >(FXWindow::ID_MDI_TILEVERTICAL)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_MDI_CASCADE", SWIG_From_int(static_cast< int >(FXWindow::ID_MDI_CASCADE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_MDI_MAXIMIZE", SWIG_From_int(static_cast< int >(FXWindow::ID_MDI_MAXIMIZE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_MDI_MINIMIZE", SWIG_From_int(static_cast< int >(FXWindow::ID_MDI_MINIMIZE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_MDI_RESTORE", SWIG_From_int(static_cast< int >(FXWindow::ID_MDI_RESTORE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_MDI_CLOSE", SWIG_From_int(static_cast< int >(FXWindow::ID_MDI_CLOSE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_MDI_WINDOW", SWIG_From_int(static_cast< int >(FXWindow::ID_MDI_WINDOW)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_MDI_MENUWINDOW", SWIG_From_int(static_cast< int >(FXWindow::ID_MDI_MENUWINDOW)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_MDI_MENUMINIMIZE", SWIG_From_int(static_cast< int >(FXWindow::ID_MDI_MENUMINIMIZE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_MDI_MENURESTORE", SWIG_From_int(static_cast< int >(FXWindow::ID_MDI_MENURESTORE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_MDI_MENUCLOSE", SWIG_From_int(static_cast< int >(FXWindow::ID_MDI_MENUCLOSE)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_MDI_NEXT", SWIG_From_int(static_cast< int >(FXWindow::ID_MDI_NEXT)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_MDI_PREV", SWIG_From_int(static_cast< int >(FXWindow::ID_MDI_PREV)));
+  rb_define_const(SwigClassFXWindow.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXWindow::ID_LAST)));
+  rb_define_singleton_method(SwigClassFXWindow.klass, "octetTypeName", VALUEFUNC(_wrap_FXWindow_octetTypeName), -1);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "deleteTypeName", VALUEFUNC(_wrap_FXWindow_deleteTypeName), -1);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "textTypeName", VALUEFUNC(_wrap_FXWindow_textTypeName), -1);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "colorTypeName", VALUEFUNC(_wrap_FXWindow_colorTypeName), -1);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "urilistTypeName", VALUEFUNC(_wrap_FXWindow_urilistTypeName), -1);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "utf8TypeName", VALUEFUNC(_wrap_FXWindow_utf8TypeName), -1);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "utf16TypeName", VALUEFUNC(_wrap_FXWindow_utf16TypeName), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getParent", VALUEFUNC(_wrap_FXWindow_getParent), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getOwner", VALUEFUNC(_wrap_FXWindow_getOwner), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getShell", VALUEFUNC(_wrap_FXWindow_getShell), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getRoot", VALUEFUNC(_wrap_FXWindow_getRoot), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getNext", VALUEFUNC(_wrap_FXWindow_getNext), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getPrev", VALUEFUNC(_wrap_FXWindow_getPrev), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getFirst", VALUEFUNC(_wrap_FXWindow_getFirst), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getLast", VALUEFUNC(_wrap_FXWindow_getLast), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getFocus", VALUEFUNC(_wrap_FXWindow_getFocus), -1);
+  rb_define_method(SwigClassFXWindow.klass, "setKey", VALUEFUNC(_wrap_FXWindow_setKey), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getKey", VALUEFUNC(_wrap_FXWindow_getKey), -1);
+  rb_define_method(SwigClassFXWindow.klass, "setTarget", VALUEFUNC(_wrap_FXWindow_setTarget), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getTarget", VALUEFUNC(_wrap_FXWindow_getTarget), -1);
+  rb_define_method(SwigClassFXWindow.klass, "setSelector", VALUEFUNC(_wrap_FXWindow_setSelector), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getSelector", VALUEFUNC(_wrap_FXWindow_getSelector), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getX", VALUEFUNC(_wrap_FXWindow_getX), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getY", VALUEFUNC(_wrap_FXWindow_getY), -1);
+  rb_define_method(SwigClassFXWindow.klass, "setX", VALUEFUNC(_wrap_FXWindow_setX), -1);
+  rb_define_method(SwigClassFXWindow.klass, "setY", VALUEFUNC(_wrap_FXWindow_setY), -1);
+  rb_define_method(SwigClassFXWindow.klass, "setWidth", VALUEFUNC(_wrap_FXWindow_setWidth), -1);
+  rb_define_method(SwigClassFXWindow.klass, "setHeight", VALUEFUNC(_wrap_FXWindow_setHeight), -1);
+  rb_define_method(SwigClassFXWindow.klass, "setLayoutHints", VALUEFUNC(_wrap_FXWindow_setLayoutHints), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getLayoutHints", VALUEFUNC(_wrap_FXWindow_getLayoutHints), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getAccelTable", VALUEFUNC(_wrap_FXWindow_getAccelTable), -1);
+  rb_define_method(SwigClassFXWindow.klass, "setAccelTable", VALUEFUNC(_wrap_FXWindow_setAccelTable), -1);
+  rb_define_method(SwigClassFXWindow.klass, "addHotKey", VALUEFUNC(_wrap_FXWindow_addHotKey), -1);
+  rb_define_method(SwigClassFXWindow.klass, "remHotKey", VALUEFUNC(_wrap_FXWindow_remHotKey), -1);
+  rb_define_method(SwigClassFXWindow.klass, "setHelpTag", VALUEFUNC(_wrap_FXWindow_setHelpTag), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getHelpTag", VALUEFUNC(_wrap_FXWindow_getHelpTag), -1);
+  rb_define_method(SwigClassFXWindow.klass, "isShell", VALUEFUNC(_wrap_FXWindow_isShell), -1);
+  rb_define_method(SwigClassFXWindow.klass, "isOwnerOf", VALUEFUNC(_wrap_FXWindow_isOwnerOf), -1);
+  rb_define_method(SwigClassFXWindow.klass, "isChildOf", VALUEFUNC(_wrap_FXWindow_isChildOf), -1);
+  rb_define_method(SwigClassFXWindow.klass, "containsChild", VALUEFUNC(_wrap_FXWindow_containsChild), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getChildAt", VALUEFUNC(_wrap_FXWindow_getChildAt), -1);
+  rb_define_method(SwigClassFXWindow.klass, "numChildren", VALUEFUNC(_wrap_FXWindow_numChildren), -1);
+  rb_define_method(SwigClassFXWindow.klass, "indexOfChild", VALUEFUNC(_wrap_FXWindow_indexOfChild), -1);
+  rb_define_method(SwigClassFXWindow.klass, "removeChild", VALUEFUNC(_wrap_FXWindow_removeChild), -1);
+  rb_define_method(SwigClassFXWindow.klass, "childAtIndex", VALUEFUNC(_wrap_FXWindow_childAtIndex), -1);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "commonAncestor", VALUEFUNC(_wrap_FXWindow_commonAncestor), -1);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "before?", VALUEFUNC(_wrap_FXWindow_beforeq___), -1);
+  rb_define_singleton_method(SwigClassFXWindow.klass, "after?", VALUEFUNC(_wrap_FXWindow_afterq___), -1);
+  rb_define_method(SwigClassFXWindow.klass, "before", VALUEFUNC(_wrap_FXWindow_before), -1);
+  rb_define_method(SwigClassFXWindow.klass, "after", VALUEFUNC(_wrap_FXWindow_after), -1);
+  rb_define_method(SwigClassFXWindow.klass, "composeContext", VALUEFUNC(_wrap_FXWindow_composeContext), -1);
+  rb_define_method(SwigClassFXWindow.klass, "createComposeContext", VALUEFUNC(_wrap_FXWindow_createComposeContext), -1);
+  rb_define_method(SwigClassFXWindow.klass, "destroyComposeContext", VALUEFUNC(_wrap_FXWindow_destroyComposeContext), -1);
+  rb_define_method(SwigClassFXWindow.klass, "setDefaultCursor", VALUEFUNC(_wrap_FXWindow_setDefaultCursor), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getDefaultCursor", VALUEFUNC(_wrap_FXWindow_getDefaultCursor), -1);
+  rb_define_method(SwigClassFXWindow.klass, "setDragCursor", VALUEFUNC(_wrap_FXWindow_setDragCursor), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getDragCursor", VALUEFUNC(_wrap_FXWindow_getDragCursor), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getCursorPosition", VALUEFUNC(_wrap_FXWindow_getCursorPosition), -1);
+  rb_define_method(SwigClassFXWindow.klass, "setCursorPosition", VALUEFUNC(_wrap_FXWindow_setCursorPosition), -1);
+  rb_define_method(SwigClassFXWindow.klass, "isEnabled", VALUEFUNC(_wrap_FXWindow_isEnabled), -1);
+  rb_define_method(SwigClassFXWindow.klass, "isActive", VALUEFUNC(_wrap_FXWindow_isActive), -1);
+  rb_define_method(SwigClassFXWindow.klass, "hasFocus", VALUEFUNC(_wrap_FXWindow_hasFocus), -1);
+  rb_define_method(SwigClassFXWindow.klass, "inFocusChain?", VALUEFUNC(_wrap_FXWindow_inFocusChainq___), -1);
+  rb_define_method(SwigClassFXWindow.klass, "isDefault", VALUEFUNC(_wrap_FXWindow_isDefault), -1);
+  rb_define_method(SwigClassFXWindow.klass, "setInitial", VALUEFUNC(_wrap_FXWindow_setInitial), -1);
+  rb_define_method(SwigClassFXWindow.klass, "isInitial", VALUEFUNC(_wrap_FXWindow_isInitial), -1);
+  rb_define_method(SwigClassFXWindow.klass, "forceRefresh", VALUEFUNC(_wrap_FXWindow_forceRefresh), -1);
+  rb_define_method(SwigClassFXWindow.klass, "scroll", VALUEFUNC(_wrap_FXWindow_scroll), -1);
+  rb_define_method(SwigClassFXWindow.klass, "update", VALUEFUNC(_wrap_FXWindow_update), -1);
+  rb_define_method(SwigClassFXWindow.klass, "repaint", VALUEFUNC(_wrap_FXWindow_repaint), -1);
+  rb_define_method(SwigClassFXWindow.klass, "grab", VALUEFUNC(_wrap_FXWindow_grab), -1);
+  rb_define_method(SwigClassFXWindow.klass, "ungrab", VALUEFUNC(_wrap_FXWindow_ungrab), -1);
+  rb_define_method(SwigClassFXWindow.klass, "grabbed", VALUEFUNC(_wrap_FXWindow_grabbed), -1);
+  rb_define_method(SwigClassFXWindow.klass, "grabKeyboard", VALUEFUNC(_wrap_FXWindow_grabKeyboard), -1);
+  rb_define_method(SwigClassFXWindow.klass, "ungrabKeyboard", VALUEFUNC(_wrap_FXWindow_ungrabKeyboard), -1);
+  rb_define_method(SwigClassFXWindow.klass, "grabbedKeyboard", VALUEFUNC(_wrap_FXWindow_grabbedKeyboard), -1);
+  rb_define_method(SwigClassFXWindow.klass, "shown", VALUEFUNC(_wrap_FXWindow_shown), -1);
+  rb_define_alias(SwigClassFXWindow.klass, "visible?", "shown");
+  rb_define_method(SwigClassFXWindow.klass, "underCursor", VALUEFUNC(_wrap_FXWindow_underCursor), -1);
+  rb_define_method(SwigClassFXWindow.klass, "hasSelection", VALUEFUNC(_wrap_FXWindow_hasSelection), -1);
+  rb_define_method(SwigClassFXWindow.klass, "acquireSelection", VALUEFUNC(_wrap_FXWindow_acquireSelection), -1);
+  rb_define_method(SwigClassFXWindow.klass, "releaseSelection", VALUEFUNC(_wrap_FXWindow_releaseSelection), -1);
+  rb_define_method(SwigClassFXWindow.klass, "hasClipboard", VALUEFUNC(_wrap_FXWindow_hasClipboard), -1);
+  rb_define_method(SwigClassFXWindow.klass, "acquireClipboard", VALUEFUNC(_wrap_FXWindow_acquireClipboard), -1);
+  rb_define_method(SwigClassFXWindow.klass, "releaseClipboard", VALUEFUNC(_wrap_FXWindow_releaseClipboard), -1);
+  rb_define_method(SwigClassFXWindow.klass, "isDropEnabled", VALUEFUNC(_wrap_FXWindow_isDropEnabled), -1);
+  rb_define_method(SwigClassFXWindow.klass, "isDragging", VALUEFUNC(_wrap_FXWindow_isDragging), -1);
+  rb_define_method(SwigClassFXWindow.klass, "beginDrag", VALUEFUNC(_wrap_FXWindow_beginDrag), -1);
+  rb_define_method(SwigClassFXWindow.klass, "handleDrag", VALUEFUNC(_wrap_FXWindow_handleDrag), -1);
+  rb_define_method(SwigClassFXWindow.klass, "endDrag", VALUEFUNC(_wrap_FXWindow_endDrag), -1);
+  rb_define_method(SwigClassFXWindow.klass, "isDropTarget", VALUEFUNC(_wrap_FXWindow_isDropTarget), -1);
+  rb_define_method(SwigClassFXWindow.klass, "setDragRectangle", VALUEFUNC(_wrap_FXWindow_setDragRectangle), -1);
+  rb_define_method(SwigClassFXWindow.klass, "clearDragRectangle", VALUEFUNC(_wrap_FXWindow_clearDragRectangle), -1);
+  rb_define_method(SwigClassFXWindow.klass, "acceptDrop", VALUEFUNC(_wrap_FXWindow_acceptDrop), -1);
+  rb_define_method(SwigClassFXWindow.klass, "didAccept", VALUEFUNC(_wrap_FXWindow_didAccept), -1);
+  rb_define_method(SwigClassFXWindow.klass, "dropFinished", VALUEFUNC(_wrap_FXWindow_dropFinished), -1);
+  rb_define_method(SwigClassFXWindow.klass, "inquireDNDTypes", VALUEFUNC(_wrap_FXWindow_inquireDNDTypes), -1);
+  rb_define_method(SwigClassFXWindow.klass, "offeredDNDType", VALUEFUNC(_wrap_FXWindow_offeredDNDType), -1);
+  rb_define_method(SwigClassFXWindow.klass, "inquireDNDAction", VALUEFUNC(_wrap_FXWindow_inquireDNDAction), -1);
+  rb_define_method(SwigClassFXWindow.klass, "setDNDData", VALUEFUNC(_wrap_FXWindow_setDNDData), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getDNDData", VALUEFUNC(_wrap_FXWindow_getDNDData), -1);
+  rb_define_method(SwigClassFXWindow.klass, "translateCoordinatesFrom", VALUEFUNC(_wrap_FXWindow_translateCoordinatesFrom), -1);
+  rb_define_method(SwigClassFXWindow.klass, "translateCoordinatesTo", VALUEFUNC(_wrap_FXWindow_translateCoordinatesTo), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getBackColor", VALUEFUNC(_wrap_FXWindow_getBackColor), -1);
+  rb_define_method(SwigClassFXWindow.klass, "save", VALUEFUNC(_wrap_FXWindow_save), -1);
+  rb_define_method(SwigClassFXWindow.klass, "load", VALUEFUNC(_wrap_FXWindow_load), -1);
+  rb_define_method(SwigClassFXWindow.klass, "create", VALUEFUNC(_wrap_FXWindow_create), -1);
+  rb_define_method(SwigClassFXWindow.klass, "detach", VALUEFUNC(_wrap_FXWindow_detach), -1);
+  rb_define_method(SwigClassFXWindow.klass, "destroy", VALUEFUNC(_wrap_FXWindow_destroy), -1);
+  rb_define_method(SwigClassFXWindow.klass, "resize", VALUEFUNC(_wrap_FXWindow_resize), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXWindow_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXWindow_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXWindow_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXWindow.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXWindow_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXWindow.klass, "canFocus", VALUEFUNC(_wrap_FXWindow_canFocus), -1);
+  rb_define_method(SwigClassFXWindow.klass, "setFocus", VALUEFUNC(_wrap_FXWindow_setFocus), -1);
+  rb_define_method(SwigClassFXWindow.klass, "killFocus", VALUEFUNC(_wrap_FXWindow_killFocus), -1);
+  rb_define_method(SwigClassFXWindow.klass, "changeFocus", VALUEFUNC(_wrap_FXWindow_changeFocus), -1);
+  rb_define_method(SwigClassFXWindow.klass, "setDefault", VALUEFUNC(_wrap_FXWindow_setDefault), -1);
+  rb_define_method(SwigClassFXWindow.klass, "enable", VALUEFUNC(_wrap_FXWindow_enable), -1);
+  rb_define_method(SwigClassFXWindow.klass, "disable", VALUEFUNC(_wrap_FXWindow_disable), -1);
+  rb_define_method(SwigClassFXWindow.klass, "raiseWindow", VALUEFUNC(_wrap_FXWindow_raiseWindow), -1);
+  rb_define_method(SwigClassFXWindow.klass, "lower", VALUEFUNC(_wrap_FXWindow_lower), -1);
+  rb_define_method(SwigClassFXWindow.klass, "move", VALUEFUNC(_wrap_FXWindow_move), -1);
+  rb_define_method(SwigClassFXWindow.klass, "position", VALUEFUNC(_wrap_FXWindow_position), -1);
+  rb_define_method(SwigClassFXWindow.klass, "layout", VALUEFUNC(_wrap_FXWindow_layout), -1);
+  rb_define_method(SwigClassFXWindow.klass, "recalc", VALUEFUNC(_wrap_FXWindow_recalc), -1);
+  rb_define_method(SwigClassFXWindow.klass, "reparent", VALUEFUNC(_wrap_FXWindow_reparent), -1);
+  rb_define_method(SwigClassFXWindow.klass, "show", VALUEFUNC(_wrap_FXWindow_show), -1);
+  rb_define_method(SwigClassFXWindow.klass, "hide", VALUEFUNC(_wrap_FXWindow_hide), -1);
+  rb_define_method(SwigClassFXWindow.klass, "isComposite", VALUEFUNC(_wrap_FXWindow_isComposite), -1);
+  rb_define_method(SwigClassFXWindow.klass, "contains", VALUEFUNC(_wrap_FXWindow_contains), -1);
+  rb_define_method(SwigClassFXWindow.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXWindow_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXWindow.klass, "setBackColor", VALUEFUNC(_wrap_FXWindow_setBackColor), -1);
+  rb_define_method(SwigClassFXWindow.klass, "tr", VALUEFUNC(_wrap_FXWindow_tr), -1);
+  rb_define_method(SwigClassFXWindow.klass, "dropEnable", VALUEFUNC(_wrap_FXWindow_dropEnable), -1);
+  rb_define_method(SwigClassFXWindow.klass, "dropDisable", VALUEFUNC(_wrap_FXWindow_dropDisable), -1);
+  rb_define_method(SwigClassFXWindow.klass, "setShape", VALUEFUNC(_wrap_FXWindow_setShape), -1);
+  rb_define_method(SwigClassFXWindow.klass, "clearShape", VALUEFUNC(_wrap_FXWindow_clearShape), -1);
+  SwigClassFXWindow.mark = (void (*)(void *)) FXRbWindow::markfunc;
+  SwigClassFXWindow.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXWindow.trackObjects = 0;
+  
+  SWIGTYPE_p_FXWindow->dcast = (swig_dycast_func) FXWindow_dynamic_cast;
+  
+  rb_define_const(mFox, "JUSTIFY_NORMAL", SWIG_From_int(static_cast< int >(JUSTIFY_NORMAL)));
+  rb_define_const(mFox, "JUSTIFY_CENTER_X", SWIG_From_int(static_cast< int >(JUSTIFY_CENTER_X)));
+  rb_define_const(mFox, "JUSTIFY_LEFT", SWIG_From_int(static_cast< int >(JUSTIFY_LEFT)));
+  rb_define_const(mFox, "JUSTIFY_RIGHT", SWIG_From_int(static_cast< int >(JUSTIFY_RIGHT)));
+  rb_define_const(mFox, "JUSTIFY_HZ_APART", SWIG_From_int(static_cast< int >(JUSTIFY_HZ_APART)));
+  rb_define_const(mFox, "JUSTIFY_CENTER_Y", SWIG_From_int(static_cast< int >(JUSTIFY_CENTER_Y)));
+  rb_define_const(mFox, "JUSTIFY_TOP", SWIG_From_int(static_cast< int >(JUSTIFY_TOP)));
+  rb_define_const(mFox, "JUSTIFY_BOTTOM", SWIG_From_int(static_cast< int >(JUSTIFY_BOTTOM)));
+  rb_define_const(mFox, "JUSTIFY_VT_APART", SWIG_From_int(static_cast< int >(JUSTIFY_VT_APART)));
+  rb_define_const(mFox, "DEFAULT_PAD", SWIG_From_int(static_cast< int >(DEFAULT_PAD)));
+  
+  SwigClassFXFrame.klass = rb_define_class_under(mFox, "FXFrame", ((swig_class *) SWIGTYPE_p_FXWindow->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXFrame, (void *) &SwigClassFXFrame);
+  rb_define_alloc_func(SwigClassFXFrame.klass, _wrap_FXFrame_allocate);
+  rb_define_method(SwigClassFXFrame.klass, "initialize", VALUEFUNC(_wrap_new_FXFrame), -1);
+  rb_define_method(SwigClassFXFrame.klass, "onPaint", VALUEFUNC(_wrap_FXFrame_onPaint), -1);
+  rb_define_method(SwigClassFXFrame.klass, "setFrameStyle", VALUEFUNC(_wrap_FXFrame_setFrameStyle), -1);
+  rb_define_method(SwigClassFXFrame.klass, "getFrameStyle", VALUEFUNC(_wrap_FXFrame_getFrameStyle), -1);
+  rb_define_method(SwigClassFXFrame.klass, "getBorderWidth", VALUEFUNC(_wrap_FXFrame_getBorderWidth), -1);
+  rb_define_method(SwigClassFXFrame.klass, "setPadTop", VALUEFUNC(_wrap_FXFrame_setPadTop), -1);
+  rb_define_method(SwigClassFXFrame.klass, "getPadTop", VALUEFUNC(_wrap_FXFrame_getPadTop), -1);
+  rb_define_method(SwigClassFXFrame.klass, "setPadBottom", VALUEFUNC(_wrap_FXFrame_setPadBottom), -1);
+  rb_define_method(SwigClassFXFrame.klass, "getPadBottom", VALUEFUNC(_wrap_FXFrame_getPadBottom), -1);
+  rb_define_method(SwigClassFXFrame.klass, "setPadLeft", VALUEFUNC(_wrap_FXFrame_setPadLeft), -1);
+  rb_define_method(SwigClassFXFrame.klass, "getPadLeft", VALUEFUNC(_wrap_FXFrame_getPadLeft), -1);
+  rb_define_method(SwigClassFXFrame.klass, "setPadRight", VALUEFUNC(_wrap_FXFrame_setPadRight), -1);
+  rb_define_method(SwigClassFXFrame.klass, "getPadRight", VALUEFUNC(_wrap_FXFrame_getPadRight), -1);
+  rb_define_method(SwigClassFXFrame.klass, "setHiliteColor", VALUEFUNC(_wrap_FXFrame_setHiliteColor), -1);
+  rb_define_method(SwigClassFXFrame.klass, "getHiliteColor", VALUEFUNC(_wrap_FXFrame_getHiliteColor), -1);
+  rb_define_method(SwigClassFXFrame.klass, "setShadowColor", VALUEFUNC(_wrap_FXFrame_setShadowColor), -1);
+  rb_define_method(SwigClassFXFrame.klass, "getShadowColor", VALUEFUNC(_wrap_FXFrame_getShadowColor), -1);
+  rb_define_method(SwigClassFXFrame.klass, "setBorderColor", VALUEFUNC(_wrap_FXFrame_setBorderColor), -1);
+  rb_define_method(SwigClassFXFrame.klass, "getBorderColor", VALUEFUNC(_wrap_FXFrame_getBorderColor), -1);
+  rb_define_method(SwigClassFXFrame.klass, "setBaseColor", VALUEFUNC(_wrap_FXFrame_setBaseColor), -1);
+  rb_define_method(SwigClassFXFrame.klass, "getBaseColor", VALUEFUNC(_wrap_FXFrame_getBaseColor), -1);
+  rb_define_method(SwigClassFXFrame.klass, "save", VALUEFUNC(_wrap_FXFrame_save), -1);
+  rb_define_method(SwigClassFXFrame.klass, "load", VALUEFUNC(_wrap_FXFrame_load), -1);
+  rb_define_method(SwigClassFXFrame.klass, "create", VALUEFUNC(_wrap_FXFrame_create), -1);
+  rb_define_method(SwigClassFXFrame.klass, "detach", VALUEFUNC(_wrap_FXFrame_detach), -1);
+  rb_define_method(SwigClassFXFrame.klass, "destroy", VALUEFUNC(_wrap_FXFrame_destroy), -1);
+  rb_define_method(SwigClassFXFrame.klass, "resize", VALUEFUNC(_wrap_FXFrame_resize), -1);
+  rb_define_method(SwigClassFXFrame.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXFrame_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXFrame.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXFrame_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXFrame.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXFrame_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXFrame.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXFrame_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXFrame.klass, "canFocus", VALUEFUNC(_wrap_FXFrame_canFocus), -1);
+  rb_define_method(SwigClassFXFrame.klass, "setFocus", VALUEFUNC(_wrap_FXFrame_setFocus), -1);
+  rb_define_method(SwigClassFXFrame.klass, "killFocus", VALUEFUNC(_wrap_FXFrame_killFocus), -1);
+  rb_define_method(SwigClassFXFrame.klass, "changeFocus", VALUEFUNC(_wrap_FXFrame_changeFocus), -1);
+  rb_define_method(SwigClassFXFrame.klass, "setDefault", VALUEFUNC(_wrap_FXFrame_setDefault), -1);
+  rb_define_method(SwigClassFXFrame.klass, "enable", VALUEFUNC(_wrap_FXFrame_enable), -1);
+  rb_define_method(SwigClassFXFrame.klass, "disable", VALUEFUNC(_wrap_FXFrame_disable), -1);
+  rb_define_method(SwigClassFXFrame.klass, "raiseWindow", VALUEFUNC(_wrap_FXFrame_raiseWindow), -1);
+  rb_define_method(SwigClassFXFrame.klass, "lower", VALUEFUNC(_wrap_FXFrame_lower), -1);
+  rb_define_method(SwigClassFXFrame.klass, "move", VALUEFUNC(_wrap_FXFrame_move), -1);
+  rb_define_method(SwigClassFXFrame.klass, "position", VALUEFUNC(_wrap_FXFrame_position), -1);
+  rb_define_method(SwigClassFXFrame.klass, "layout", VALUEFUNC(_wrap_FXFrame_layout), -1);
+  rb_define_method(SwigClassFXFrame.klass, "recalc", VALUEFUNC(_wrap_FXFrame_recalc), -1);
+  rb_define_method(SwigClassFXFrame.klass, "reparent", VALUEFUNC(_wrap_FXFrame_reparent), -1);
+  rb_define_method(SwigClassFXFrame.klass, "show", VALUEFUNC(_wrap_FXFrame_show), -1);
+  rb_define_method(SwigClassFXFrame.klass, "hide", VALUEFUNC(_wrap_FXFrame_hide), -1);
+  rb_define_method(SwigClassFXFrame.klass, "isComposite", VALUEFUNC(_wrap_FXFrame_isComposite), -1);
+  rb_define_method(SwigClassFXFrame.klass, "contains", VALUEFUNC(_wrap_FXFrame_contains), -1);
+  rb_define_method(SwigClassFXFrame.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXFrame_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXFrame.klass, "setBackColor", VALUEFUNC(_wrap_FXFrame_setBackColor), -1);
+  rb_define_method(SwigClassFXFrame.klass, "tr", VALUEFUNC(_wrap_FXFrame_tr), -1);
+  rb_define_method(SwigClassFXFrame.klass, "dropEnable", VALUEFUNC(_wrap_FXFrame_dropEnable), -1);
+  rb_define_method(SwigClassFXFrame.klass, "dropDisable", VALUEFUNC(_wrap_FXFrame_dropDisable), -1);
+  rb_define_method(SwigClassFXFrame.klass, "setShape", VALUEFUNC(_wrap_FXFrame_setShape), -1);
+  rb_define_method(SwigClassFXFrame.klass, "clearShape", VALUEFUNC(_wrap_FXFrame_clearShape), -1);
+  SwigClassFXFrame.mark = (void (*)(void *)) FXRbFrame::markfunc;
+  SwigClassFXFrame.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXFrame.trackObjects = 0;
+  
+  SWIGTYPE_p_FXFrame->dcast = (swig_dycast_func) FXFrame_dynamic_cast;
+  
+  
+  SwigClassFXComposite.klass = rb_define_class_under(mFox, "FXComposite", ((swig_class *) SWIGTYPE_p_FXWindow->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXComposite, (void *) &SwigClassFXComposite);
+  rb_define_alloc_func(SwigClassFXComposite.klass, _wrap_FXComposite_allocate);
+  rb_define_method(SwigClassFXComposite.klass, "initialize", VALUEFUNC(_wrap_new_FXComposite), -1);
+  rb_define_method(SwigClassFXComposite.klass, "onKeyPress", VALUEFUNC(_wrap_FXComposite_onKeyPress), -1);
+  rb_define_method(SwigClassFXComposite.klass, "onKeyRelease", VALUEFUNC(_wrap_FXComposite_onKeyRelease), -1);
+  rb_define_method(SwigClassFXComposite.klass, "onFocusNext", VALUEFUNC(_wrap_FXComposite_onFocusNext), -1);
+  rb_define_method(SwigClassFXComposite.klass, "onFocusPrev", VALUEFUNC(_wrap_FXComposite_onFocusPrev), -1);
+  rb_define_method(SwigClassFXComposite.klass, "onCmdUpdate", VALUEFUNC(_wrap_FXComposite_onCmdUpdate), -1);
+  rb_define_method(SwigClassFXComposite.klass, "maxChildWidth", VALUEFUNC(_wrap_FXComposite_maxChildWidth), -1);
+  rb_define_method(SwigClassFXComposite.klass, "maxChildHeight", VALUEFUNC(_wrap_FXComposite_maxChildHeight), -1);
+  rb_define_method(SwigClassFXComposite.klass, "save", VALUEFUNC(_wrap_FXComposite_save), -1);
+  rb_define_method(SwigClassFXComposite.klass, "load", VALUEFUNC(_wrap_FXComposite_load), -1);
+  rb_define_method(SwigClassFXComposite.klass, "create", VALUEFUNC(_wrap_FXComposite_create), -1);
+  rb_define_method(SwigClassFXComposite.klass, "detach", VALUEFUNC(_wrap_FXComposite_detach), -1);
+  rb_define_method(SwigClassFXComposite.klass, "destroy", VALUEFUNC(_wrap_FXComposite_destroy), -1);
+  rb_define_method(SwigClassFXComposite.klass, "resize", VALUEFUNC(_wrap_FXComposite_resize), -1);
+  rb_define_method(SwigClassFXComposite.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXComposite_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXComposite.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXComposite_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXComposite.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXComposite_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXComposite.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXComposite_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXComposite.klass, "canFocus", VALUEFUNC(_wrap_FXComposite_canFocus), -1);
+  rb_define_method(SwigClassFXComposite.klass, "setFocus", VALUEFUNC(_wrap_FXComposite_setFocus), -1);
+  rb_define_method(SwigClassFXComposite.klass, "killFocus", VALUEFUNC(_wrap_FXComposite_killFocus), -1);
+  rb_define_method(SwigClassFXComposite.klass, "changeFocus", VALUEFUNC(_wrap_FXComposite_changeFocus), -1);
+  rb_define_method(SwigClassFXComposite.klass, "setDefault", VALUEFUNC(_wrap_FXComposite_setDefault), -1);
+  rb_define_method(SwigClassFXComposite.klass, "enable", VALUEFUNC(_wrap_FXComposite_enable), -1);
+  rb_define_method(SwigClassFXComposite.klass, "disable", VALUEFUNC(_wrap_FXComposite_disable), -1);
+  rb_define_method(SwigClassFXComposite.klass, "raiseWindow", VALUEFUNC(_wrap_FXComposite_raiseWindow), -1);
+  rb_define_method(SwigClassFXComposite.klass, "lower", VALUEFUNC(_wrap_FXComposite_lower), -1);
+  rb_define_method(SwigClassFXComposite.klass, "move", VALUEFUNC(_wrap_FXComposite_move), -1);
+  rb_define_method(SwigClassFXComposite.klass, "position", VALUEFUNC(_wrap_FXComposite_position), -1);
+  rb_define_method(SwigClassFXComposite.klass, "layout", VALUEFUNC(_wrap_FXComposite_layout), -1);
+  rb_define_method(SwigClassFXComposite.klass, "recalc", VALUEFUNC(_wrap_FXComposite_recalc), -1);
+  rb_define_method(SwigClassFXComposite.klass, "reparent", VALUEFUNC(_wrap_FXComposite_reparent), -1);
+  rb_define_method(SwigClassFXComposite.klass, "show", VALUEFUNC(_wrap_FXComposite_show), -1);
+  rb_define_method(SwigClassFXComposite.klass, "hide", VALUEFUNC(_wrap_FXComposite_hide), -1);
+  rb_define_method(SwigClassFXComposite.klass, "isComposite", VALUEFUNC(_wrap_FXComposite_isComposite), -1);
+  rb_define_method(SwigClassFXComposite.klass, "contains", VALUEFUNC(_wrap_FXComposite_contains), -1);
+  rb_define_method(SwigClassFXComposite.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXComposite_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXComposite.klass, "setBackColor", VALUEFUNC(_wrap_FXComposite_setBackColor), -1);
+  rb_define_method(SwigClassFXComposite.klass, "tr", VALUEFUNC(_wrap_FXComposite_tr), -1);
+  rb_define_method(SwigClassFXComposite.klass, "dropEnable", VALUEFUNC(_wrap_FXComposite_dropEnable), -1);
+  rb_define_method(SwigClassFXComposite.klass, "dropDisable", VALUEFUNC(_wrap_FXComposite_dropDisable), -1);
+  rb_define_method(SwigClassFXComposite.klass, "setShape", VALUEFUNC(_wrap_FXComposite_setShape), -1);
+  rb_define_method(SwigClassFXComposite.klass, "clearShape", VALUEFUNC(_wrap_FXComposite_clearShape), -1);
+  SwigClassFXComposite.mark = (void (*)(void *)) FXRbComposite::markfunc;
+  SwigClassFXComposite.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXComposite.trackObjects = 0;
+  
+  SWIGTYPE_p_FXComposite->dcast = (swig_dycast_func) FXComposite_dynamic_cast;
+  
+  
+  SwigClassFXRootWindow.klass = rb_define_class_under(mFox, "FXRootWindow", ((swig_class *) SWIGTYPE_p_FXComposite->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXRootWindow, (void *) &SwigClassFXRootWindow);
+  rb_define_alloc_func(SwigClassFXRootWindow.klass, _wrap_FXRootWindow_allocate);
+  rb_define_method(SwigClassFXRootWindow.klass, "initialize", VALUEFUNC(_wrap_new_FXRootWindow), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "save", VALUEFUNC(_wrap_FXRootWindow_save), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "load", VALUEFUNC(_wrap_FXRootWindow_load), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "create", VALUEFUNC(_wrap_FXRootWindow_create), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "detach", VALUEFUNC(_wrap_FXRootWindow_detach), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "destroy", VALUEFUNC(_wrap_FXRootWindow_destroy), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "resize", VALUEFUNC(_wrap_FXRootWindow_resize), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXRootWindow_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXRootWindow_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXRootWindow_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXRootWindow_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "canFocus", VALUEFUNC(_wrap_FXRootWindow_canFocus), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "setFocus", VALUEFUNC(_wrap_FXRootWindow_setFocus), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "killFocus", VALUEFUNC(_wrap_FXRootWindow_killFocus), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "changeFocus", VALUEFUNC(_wrap_FXRootWindow_changeFocus), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "setDefault", VALUEFUNC(_wrap_FXRootWindow_setDefault), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "enable", VALUEFUNC(_wrap_FXRootWindow_enable), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "disable", VALUEFUNC(_wrap_FXRootWindow_disable), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "raiseWindow", VALUEFUNC(_wrap_FXRootWindow_raiseWindow), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "lower", VALUEFUNC(_wrap_FXRootWindow_lower), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "move", VALUEFUNC(_wrap_FXRootWindow_move), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "position", VALUEFUNC(_wrap_FXRootWindow_position), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "layout", VALUEFUNC(_wrap_FXRootWindow_layout), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "recalc", VALUEFUNC(_wrap_FXRootWindow_recalc), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "reparent", VALUEFUNC(_wrap_FXRootWindow_reparent), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "show", VALUEFUNC(_wrap_FXRootWindow_show), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "hide", VALUEFUNC(_wrap_FXRootWindow_hide), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "isComposite", VALUEFUNC(_wrap_FXRootWindow_isComposite), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "contains", VALUEFUNC(_wrap_FXRootWindow_contains), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXRootWindow_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "setBackColor", VALUEFUNC(_wrap_FXRootWindow_setBackColor), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "tr", VALUEFUNC(_wrap_FXRootWindow_tr), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "dropEnable", VALUEFUNC(_wrap_FXRootWindow_dropEnable), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "dropDisable", VALUEFUNC(_wrap_FXRootWindow_dropDisable), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "setShape", VALUEFUNC(_wrap_FXRootWindow_setShape), -1);
+  rb_define_method(SwigClassFXRootWindow.klass, "clearShape", VALUEFUNC(_wrap_FXRootWindow_clearShape), -1);
+  SwigClassFXRootWindow.mark = (void (*)(void *)) FXRbRootWindow::markfunc;
+  SwigClassFXRootWindow.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXRootWindow.trackObjects = 0;
+  
+  SwigClassFXShell.klass = rb_define_class_under(mFox, "FXShell", ((swig_class *) SWIGTYPE_p_FXComposite->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXShell, (void *) &SwigClassFXShell);
+  rb_define_alloc_func(SwigClassFXShell.klass, _wrap_FXShell_allocate);
+  rb_define_method(SwigClassFXShell.klass, "initialize", VALUEFUNC(_wrap_new_FXShell), -1);
+  rb_define_method(SwigClassFXShell.klass, "onLayout", VALUEFUNC(_wrap_FXShell_onLayout), -1);
+  rb_define_method(SwigClassFXShell.klass, "onConfigure", VALUEFUNC(_wrap_FXShell_onConfigure), -1);
+  rb_define_method(SwigClassFXShell.klass, "onKeyPress", VALUEFUNC(_wrap_FXShell_onKeyPress), -1);
+  rb_define_method(SwigClassFXShell.klass, "onKeyRelease", VALUEFUNC(_wrap_FXShell_onKeyRelease), -1);
+  rb_define_method(SwigClassFXShell.klass, "onFocusNext", VALUEFUNC(_wrap_FXShell_onFocusNext), -1);
+  rb_define_method(SwigClassFXShell.klass, "onFocusPrev", VALUEFUNC(_wrap_FXShell_onFocusPrev), -1);
+  rb_define_const(SwigClassFXShell.klass, "ID_LAYOUT", SWIG_From_int(static_cast< int >(FXShell::ID_LAYOUT)));
+  rb_define_const(SwigClassFXShell.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXShell::ID_LAST)));
+  rb_define_method(SwigClassFXShell.klass, "save", VALUEFUNC(_wrap_FXShell_save), -1);
+  rb_define_method(SwigClassFXShell.klass, "load", VALUEFUNC(_wrap_FXShell_load), -1);
+  rb_define_method(SwigClassFXShell.klass, "create", VALUEFUNC(_wrap_FXShell_create), -1);
+  rb_define_method(SwigClassFXShell.klass, "detach", VALUEFUNC(_wrap_FXShell_detach), -1);
+  rb_define_method(SwigClassFXShell.klass, "destroy", VALUEFUNC(_wrap_FXShell_destroy), -1);
+  rb_define_method(SwigClassFXShell.klass, "resize", VALUEFUNC(_wrap_FXShell_resize), -1);
+  rb_define_method(SwigClassFXShell.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXShell_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXShell.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXShell_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXShell.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXShell_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXShell.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXShell_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXShell.klass, "canFocus", VALUEFUNC(_wrap_FXShell_canFocus), -1);
+  rb_define_method(SwigClassFXShell.klass, "setFocus", VALUEFUNC(_wrap_FXShell_setFocus), -1);
+  rb_define_method(SwigClassFXShell.klass, "killFocus", VALUEFUNC(_wrap_FXShell_killFocus), -1);
+  rb_define_method(SwigClassFXShell.klass, "changeFocus", VALUEFUNC(_wrap_FXShell_changeFocus), -1);
+  rb_define_method(SwigClassFXShell.klass, "setDefault", VALUEFUNC(_wrap_FXShell_setDefault), -1);
+  rb_define_method(SwigClassFXShell.klass, "enable", VALUEFUNC(_wrap_FXShell_enable), -1);
+  rb_define_method(SwigClassFXShell.klass, "disable", VALUEFUNC(_wrap_FXShell_disable), -1);
+  rb_define_method(SwigClassFXShell.klass, "raiseWindow", VALUEFUNC(_wrap_FXShell_raiseWindow), -1);
+  rb_define_method(SwigClassFXShell.klass, "lower", VALUEFUNC(_wrap_FXShell_lower), -1);
+  rb_define_method(SwigClassFXShell.klass, "move", VALUEFUNC(_wrap_FXShell_move), -1);
+  rb_define_method(SwigClassFXShell.klass, "position", VALUEFUNC(_wrap_FXShell_position), -1);
+  rb_define_method(SwigClassFXShell.klass, "layout", VALUEFUNC(_wrap_FXShell_layout), -1);
+  rb_define_method(SwigClassFXShell.klass, "recalc", VALUEFUNC(_wrap_FXShell_recalc), -1);
+  rb_define_method(SwigClassFXShell.klass, "reparent", VALUEFUNC(_wrap_FXShell_reparent), -1);
+  rb_define_method(SwigClassFXShell.klass, "show", VALUEFUNC(_wrap_FXShell_show), -1);
+  rb_define_method(SwigClassFXShell.klass, "hide", VALUEFUNC(_wrap_FXShell_hide), -1);
+  rb_define_method(SwigClassFXShell.klass, "isComposite", VALUEFUNC(_wrap_FXShell_isComposite), -1);
+  rb_define_method(SwigClassFXShell.klass, "contains", VALUEFUNC(_wrap_FXShell_contains), -1);
+  rb_define_method(SwigClassFXShell.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXShell_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXShell.klass, "setBackColor", VALUEFUNC(_wrap_FXShell_setBackColor), -1);
+  rb_define_method(SwigClassFXShell.klass, "tr", VALUEFUNC(_wrap_FXShell_tr), -1);
+  rb_define_method(SwigClassFXShell.klass, "dropEnable", VALUEFUNC(_wrap_FXShell_dropEnable), -1);
+  rb_define_method(SwigClassFXShell.klass, "dropDisable", VALUEFUNC(_wrap_FXShell_dropDisable), -1);
+  rb_define_method(SwigClassFXShell.klass, "setShape", VALUEFUNC(_wrap_FXShell_setShape), -1);
+  rb_define_method(SwigClassFXShell.klass, "clearShape", VALUEFUNC(_wrap_FXShell_clearShape), -1);
+  SwigClassFXShell.mark = (void (*)(void *)) FXRbShell::markfunc;
+  SwigClassFXShell.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXShell.trackObjects = 0;
+  
+  SWIGTYPE_p_FXShell->dcast = (swig_dycast_func) FXShell_dynamic_cast;
+  
+  rb_define_const(mFox, "POPUP_VERTICAL", SWIG_From_int(static_cast< int >(POPUP_VERTICAL)));
+  rb_define_const(mFox, "POPUP_HORIZONTAL", SWIG_From_int(static_cast< int >(POPUP_HORIZONTAL)));
+  rb_define_const(mFox, "POPUP_SHRINKWRAP", SWIG_From_int(static_cast< int >(POPUP_SHRINKWRAP)));
+  
+  SwigClassFXPopup.klass = rb_define_class_under(mFox, "FXPopup", ((swig_class *) SWIGTYPE_p_FXShell->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXPopup, (void *) &SwigClassFXPopup);
+  rb_define_alloc_func(SwigClassFXPopup.klass, _wrap_FXPopup_allocate);
+  rb_define_method(SwigClassFXPopup.klass, "initialize", VALUEFUNC(_wrap_new_FXPopup), -1);
+  rb_define_method(SwigClassFXPopup.klass, "onPaint", VALUEFUNC(_wrap_FXPopup_onPaint), -1);
+  rb_define_method(SwigClassFXPopup.klass, "onFocusUp", VALUEFUNC(_wrap_FXPopup_onFocusUp), -1);
+  rb_define_method(SwigClassFXPopup.klass, "onFocusDown", VALUEFUNC(_wrap_FXPopup_onFocusDown), -1);
+  rb_define_method(SwigClassFXPopup.klass, "onFocusLeft", VALUEFUNC(_wrap_FXPopup_onFocusLeft), -1);
+  rb_define_method(SwigClassFXPopup.klass, "onFocusRight", VALUEFUNC(_wrap_FXPopup_onFocusRight), -1);
+  rb_define_method(SwigClassFXPopup.klass, "onFocusNext", VALUEFUNC(_wrap_FXPopup_onFocusNext), -1);
+  rb_define_method(SwigClassFXPopup.klass, "onFocusPrev", VALUEFUNC(_wrap_FXPopup_onFocusPrev), -1);
+  rb_define_method(SwigClassFXPopup.klass, "onEnter", VALUEFUNC(_wrap_FXPopup_onEnter), -1);
+  rb_define_method(SwigClassFXPopup.klass, "onLeave", VALUEFUNC(_wrap_FXPopup_onLeave), -1);
+  rb_define_method(SwigClassFXPopup.klass, "onMotion", VALUEFUNC(_wrap_FXPopup_onMotion), -1);
+  rb_define_method(SwigClassFXPopup.klass, "onMap", VALUEFUNC(_wrap_FXPopup_onMap), -1);
+  rb_define_method(SwigClassFXPopup.klass, "onButtonPress", VALUEFUNC(_wrap_FXPopup_onButtonPress), -1);
+  rb_define_method(SwigClassFXPopup.klass, "onButtonRelease", VALUEFUNC(_wrap_FXPopup_onButtonRelease), -1);
+  rb_define_method(SwigClassFXPopup.klass, "onUngrabbed", VALUEFUNC(_wrap_FXPopup_onUngrabbed), -1);
+  rb_define_method(SwigClassFXPopup.klass, "onCmdUnpost", VALUEFUNC(_wrap_FXPopup_onCmdUnpost), -1);
+  rb_define_method(SwigClassFXPopup.klass, "onKeyPress", VALUEFUNC(_wrap_FXPopup_onKeyPress), -1);
+  rb_define_method(SwigClassFXPopup.klass, "onKeyRelease", VALUEFUNC(_wrap_FXPopup_onKeyRelease), -1);
+  rb_define_method(SwigClassFXPopup.klass, "onCmdChoice", VALUEFUNC(_wrap_FXPopup_onCmdChoice), -1);
+  rb_define_const(SwigClassFXPopup.klass, "ID_CHOICE", SWIG_From_int(static_cast< int >(FXPopup::ID_CHOICE)));
+  rb_define_const(SwigClassFXPopup.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXPopup::ID_LAST)));
+  rb_define_method(SwigClassFXPopup.klass, "getPrevActive", VALUEFUNC(_wrap_FXPopup_getPrevActive), -1);
+  rb_define_method(SwigClassFXPopup.klass, "getNextActive", VALUEFUNC(_wrap_FXPopup_getNextActive), -1);
+  rb_define_method(SwigClassFXPopup.klass, "setFrameStyle", VALUEFUNC(_wrap_FXPopup_setFrameStyle), -1);
+  rb_define_method(SwigClassFXPopup.klass, "getFrameStyle", VALUEFUNC(_wrap_FXPopup_getFrameStyle), -1);
+  rb_define_method(SwigClassFXPopup.klass, "getBorderWidth", VALUEFUNC(_wrap_FXPopup_getBorderWidth), -1);
+  rb_define_method(SwigClassFXPopup.klass, "setHiliteColor", VALUEFUNC(_wrap_FXPopup_setHiliteColor), -1);
+  rb_define_method(SwigClassFXPopup.klass, "getHiliteColor", VALUEFUNC(_wrap_FXPopup_getHiliteColor), -1);
+  rb_define_method(SwigClassFXPopup.klass, "setShadowColor", VALUEFUNC(_wrap_FXPopup_setShadowColor), -1);
+  rb_define_method(SwigClassFXPopup.klass, "getShadowColor", VALUEFUNC(_wrap_FXPopup_getShadowColor), -1);
+  rb_define_method(SwigClassFXPopup.klass, "setBorderColor", VALUEFUNC(_wrap_FXPopup_setBorderColor), -1);
+  rb_define_method(SwigClassFXPopup.klass, "getBorderColor", VALUEFUNC(_wrap_FXPopup_getBorderColor), -1);
+  rb_define_method(SwigClassFXPopup.klass, "setBaseColor", VALUEFUNC(_wrap_FXPopup_setBaseColor), -1);
+  rb_define_method(SwigClassFXPopup.klass, "getBaseColor", VALUEFUNC(_wrap_FXPopup_getBaseColor), -1);
+  rb_define_method(SwigClassFXPopup.klass, "getGrabOwner", VALUEFUNC(_wrap_FXPopup_getGrabOwner), -1);
+  rb_define_method(SwigClassFXPopup.klass, "getOrientation", VALUEFUNC(_wrap_FXPopup_getOrientation), -1);
+  rb_define_method(SwigClassFXPopup.klass, "setOrientation", VALUEFUNC(_wrap_FXPopup_setOrientation), -1);
+  rb_define_method(SwigClassFXPopup.klass, "getShrinkWrap", VALUEFUNC(_wrap_FXPopup_getShrinkWrap), -1);
+  rb_define_method(SwigClassFXPopup.klass, "setShrinkWrap", VALUEFUNC(_wrap_FXPopup_setShrinkWrap), -1);
+  rb_define_method(SwigClassFXPopup.klass, "save", VALUEFUNC(_wrap_FXPopup_save), -1);
+  rb_define_method(SwigClassFXPopup.klass, "load", VALUEFUNC(_wrap_FXPopup_load), -1);
+  rb_define_method(SwigClassFXPopup.klass, "create", VALUEFUNC(_wrap_FXPopup_create), -1);
+  rb_define_method(SwigClassFXPopup.klass, "detach", VALUEFUNC(_wrap_FXPopup_detach), -1);
+  rb_define_method(SwigClassFXPopup.klass, "destroy", VALUEFUNC(_wrap_FXPopup_destroy), -1);
+  rb_define_method(SwigClassFXPopup.klass, "resize", VALUEFUNC(_wrap_FXPopup_resize), -1);
+  rb_define_method(SwigClassFXPopup.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXPopup_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXPopup.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXPopup_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXPopup.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXPopup_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXPopup.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXPopup_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXPopup.klass, "canFocus", VALUEFUNC(_wrap_FXPopup_canFocus), -1);
+  rb_define_method(SwigClassFXPopup.klass, "setFocus", VALUEFUNC(_wrap_FXPopup_setFocus), -1);
+  rb_define_method(SwigClassFXPopup.klass, "killFocus", VALUEFUNC(_wrap_FXPopup_killFocus), -1);
+  rb_define_method(SwigClassFXPopup.klass, "changeFocus", VALUEFUNC(_wrap_FXPopup_changeFocus), -1);
+  rb_define_method(SwigClassFXPopup.klass, "setDefault", VALUEFUNC(_wrap_FXPopup_setDefault), -1);
+  rb_define_method(SwigClassFXPopup.klass, "enable", VALUEFUNC(_wrap_FXPopup_enable), -1);
+  rb_define_method(SwigClassFXPopup.klass, "disable", VALUEFUNC(_wrap_FXPopup_disable), -1);
+  rb_define_method(SwigClassFXPopup.klass, "raiseWindow", VALUEFUNC(_wrap_FXPopup_raiseWindow), -1);
+  rb_define_method(SwigClassFXPopup.klass, "lower", VALUEFUNC(_wrap_FXPopup_lower), -1);
+  rb_define_method(SwigClassFXPopup.klass, "move", VALUEFUNC(_wrap_FXPopup_move), -1);
+  rb_define_method(SwigClassFXPopup.klass, "position", VALUEFUNC(_wrap_FXPopup_position), -1);
+  rb_define_method(SwigClassFXPopup.klass, "layout", VALUEFUNC(_wrap_FXPopup_layout), -1);
+  rb_define_method(SwigClassFXPopup.klass, "recalc", VALUEFUNC(_wrap_FXPopup_recalc), -1);
+  rb_define_method(SwigClassFXPopup.klass, "reparent", VALUEFUNC(_wrap_FXPopup_reparent), -1);
+  rb_define_method(SwigClassFXPopup.klass, "show", VALUEFUNC(_wrap_FXPopup_show), -1);
+  rb_define_method(SwigClassFXPopup.klass, "hide", VALUEFUNC(_wrap_FXPopup_hide), -1);
+  rb_define_method(SwigClassFXPopup.klass, "isComposite", VALUEFUNC(_wrap_FXPopup_isComposite), -1);
+  rb_define_method(SwigClassFXPopup.klass, "contains", VALUEFUNC(_wrap_FXPopup_contains), -1);
+  rb_define_method(SwigClassFXPopup.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXPopup_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXPopup.klass, "setBackColor", VALUEFUNC(_wrap_FXPopup_setBackColor), -1);
+  rb_define_method(SwigClassFXPopup.klass, "tr", VALUEFUNC(_wrap_FXPopup_tr), -1);
+  rb_define_method(SwigClassFXPopup.klass, "dropEnable", VALUEFUNC(_wrap_FXPopup_dropEnable), -1);
+  rb_define_method(SwigClassFXPopup.klass, "dropDisable", VALUEFUNC(_wrap_FXPopup_dropDisable), -1);
+  rb_define_method(SwigClassFXPopup.klass, "setShape", VALUEFUNC(_wrap_FXPopup_setShape), -1);
+  rb_define_method(SwigClassFXPopup.klass, "clearShape", VALUEFUNC(_wrap_FXPopup_clearShape), -1);
+  rb_define_method(SwigClassFXPopup.klass, "popup", VALUEFUNC(_wrap_FXPopup_popup), -1);
+  rb_define_method(SwigClassFXPopup.klass, "popdown", VALUEFUNC(_wrap_FXPopup_popdown), -1);
+  SwigClassFXPopup.mark = (void (*)(void *)) FXRbPopup::markfunc;
+  SwigClassFXPopup.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXPopup.trackObjects = 0;
+  
+  SWIGTYPE_p_FXPopup->dcast = (swig_dycast_func) FXPopup_dynamic_cast;
+  
+  rb_define_const(mFox, "DECOR_NONE", SWIG_From_int(static_cast< int >(DECOR_NONE)));
+  rb_define_const(mFox, "DECOR_TITLE", SWIG_From_int(static_cast< int >(DECOR_TITLE)));
+  rb_define_const(mFox, "DECOR_MINIMIZE", SWIG_From_int(static_cast< int >(DECOR_MINIMIZE)));
+  rb_define_const(mFox, "DECOR_MAXIMIZE", SWIG_From_int(static_cast< int >(DECOR_MAXIMIZE)));
+  rb_define_const(mFox, "DECOR_CLOSE", SWIG_From_int(static_cast< int >(DECOR_CLOSE)));
+  rb_define_const(mFox, "DECOR_BORDER", SWIG_From_int(static_cast< int >(DECOR_BORDER)));
+  rb_define_const(mFox, "DECOR_SHRINKABLE", SWIG_From_int(static_cast< int >(DECOR_SHRINKABLE)));
+  rb_define_const(mFox, "DECOR_STRETCHABLE", SWIG_From_int(static_cast< int >(DECOR_STRETCHABLE)));
+  rb_define_const(mFox, "DECOR_RESIZE", SWIG_From_int(static_cast< int >(DECOR_RESIZE)));
+  rb_define_const(mFox, "DECOR_MENU", SWIG_From_int(static_cast< int >(DECOR_MENU)));
+  rb_define_const(mFox, "DECOR_ALL", SWIG_From_int(static_cast< int >(DECOR_ALL)));
+  rb_define_const(mFox, "PLACEMENT_DEFAULT", SWIG_From_int(static_cast< int >(PLACEMENT_DEFAULT)));
+  rb_define_const(mFox, "PLACEMENT_VISIBLE", SWIG_From_int(static_cast< int >(PLACEMENT_VISIBLE)));
+  rb_define_const(mFox, "PLACEMENT_CURSOR", SWIG_From_int(static_cast< int >(PLACEMENT_CURSOR)));
+  rb_define_const(mFox, "PLACEMENT_OWNER", SWIG_From_int(static_cast< int >(PLACEMENT_OWNER)));
+  rb_define_const(mFox, "PLACEMENT_SCREEN", SWIG_From_int(static_cast< int >(PLACEMENT_SCREEN)));
+  rb_define_const(mFox, "PLACEMENT_MAXIMIZED", SWIG_From_int(static_cast< int >(PLACEMENT_MAXIMIZED)));
+  
+  SwigClassFXTopWindow.klass = rb_define_class_under(mFox, "FXTopWindow", ((swig_class *) SWIGTYPE_p_FXShell->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXTopWindow, (void *) &SwigClassFXTopWindow);
+  rb_define_alloc_func(SwigClassFXTopWindow.klass, _wrap_FXTopWindow_allocate);
+  rb_define_method(SwigClassFXTopWindow.klass, "initialize", VALUEFUNC(_wrap_new_FXTopWindow), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "onFocusUp", VALUEFUNC(_wrap_FXTopWindow_onFocusUp), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "onFocusDown", VALUEFUNC(_wrap_FXTopWindow_onFocusDown), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "onFocusLeft", VALUEFUNC(_wrap_FXTopWindow_onFocusLeft), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "onFocusRight", VALUEFUNC(_wrap_FXTopWindow_onFocusRight), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "onSessionNotify", VALUEFUNC(_wrap_FXTopWindow_onSessionNotify), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "onSessionClosed", VALUEFUNC(_wrap_FXTopWindow_onSessionClosed), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "onCmdMaximize", VALUEFUNC(_wrap_FXTopWindow_onCmdMaximize), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "onCmdMinimize", VALUEFUNC(_wrap_FXTopWindow_onCmdMinimize), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "onCmdRestore", VALUEFUNC(_wrap_FXTopWindow_onCmdRestore), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "onCmdClose", VALUEFUNC(_wrap_FXTopWindow_onCmdClose), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "onCmdSetStringValue", VALUEFUNC(_wrap_FXTopWindow_onCmdSetStringValue), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "onCmdGetStringValue", VALUEFUNC(_wrap_FXTopWindow_onCmdGetStringValue), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "onCmdSetIconValue", VALUEFUNC(_wrap_FXTopWindow_onCmdSetIconValue), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "onCmdGetIconValue", VALUEFUNC(_wrap_FXTopWindow_onCmdGetIconValue), -1);
+  rb_define_const(SwigClassFXTopWindow.klass, "ID_MAXIMIZE", SWIG_From_int(static_cast< int >(FXTopWindow::ID_MAXIMIZE)));
+  rb_define_const(SwigClassFXTopWindow.klass, "ID_MINIMIZE", SWIG_From_int(static_cast< int >(FXTopWindow::ID_MINIMIZE)));
+  rb_define_const(SwigClassFXTopWindow.klass, "ID_RESTORE", SWIG_From_int(static_cast< int >(FXTopWindow::ID_RESTORE)));
+  rb_define_const(SwigClassFXTopWindow.klass, "ID_CLOSE", SWIG_From_int(static_cast< int >(FXTopWindow::ID_CLOSE)));
+  rb_define_const(SwigClassFXTopWindow.klass, "ID_QUERY_DOCK", SWIG_From_int(static_cast< int >(FXTopWindow::ID_QUERY_DOCK)));
+  rb_define_const(SwigClassFXTopWindow.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXTopWindow::ID_LAST)));
+  rb_define_method(SwigClassFXTopWindow.klass, "getWMBorders", VALUEFUNC(_wrap_FXTopWindow_getWMBorders), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "place", VALUEFUNC(_wrap_FXTopWindow_place), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "isMaximized", VALUEFUNC(_wrap_FXTopWindow_isMaximized), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "isMinimized", VALUEFUNC(_wrap_FXTopWindow_isMinimized), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "setTitle", VALUEFUNC(_wrap_FXTopWindow_setTitle), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "getTitle", VALUEFUNC(_wrap_FXTopWindow_getTitle), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "setPadTop", VALUEFUNC(_wrap_FXTopWindow_setPadTop), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "getPadTop", VALUEFUNC(_wrap_FXTopWindow_getPadTop), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "setPadBottom", VALUEFUNC(_wrap_FXTopWindow_setPadBottom), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "getPadBottom", VALUEFUNC(_wrap_FXTopWindow_getPadBottom), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "setPadLeft", VALUEFUNC(_wrap_FXTopWindow_setPadLeft), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "getPadLeft", VALUEFUNC(_wrap_FXTopWindow_getPadLeft), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "setPadRight", VALUEFUNC(_wrap_FXTopWindow_setPadRight), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "getPadRight", VALUEFUNC(_wrap_FXTopWindow_getPadRight), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "getHSpacing", VALUEFUNC(_wrap_FXTopWindow_getHSpacing), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "getVSpacing", VALUEFUNC(_wrap_FXTopWindow_getVSpacing), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "setHSpacing", VALUEFUNC(_wrap_FXTopWindow_setHSpacing), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "setVSpacing", VALUEFUNC(_wrap_FXTopWindow_setVSpacing), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "setPackingHints", VALUEFUNC(_wrap_FXTopWindow_setPackingHints), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "getPackingHints", VALUEFUNC(_wrap_FXTopWindow_getPackingHints), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "setDecorations", VALUEFUNC(_wrap_FXTopWindow_setDecorations), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "getDecorations", VALUEFUNC(_wrap_FXTopWindow_getDecorations), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "getIcon", VALUEFUNC(_wrap_FXTopWindow_getIcon), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "setIcon", VALUEFUNC(_wrap_FXTopWindow_setIcon), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "getMiniIcon", VALUEFUNC(_wrap_FXTopWindow_getMiniIcon), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "setMiniIcon", VALUEFUNC(_wrap_FXTopWindow_setMiniIcon), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "save", VALUEFUNC(_wrap_FXTopWindow_save), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "load", VALUEFUNC(_wrap_FXTopWindow_load), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "create", VALUEFUNC(_wrap_FXTopWindow_create), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "detach", VALUEFUNC(_wrap_FXTopWindow_detach), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "destroy", VALUEFUNC(_wrap_FXTopWindow_destroy), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "resize", VALUEFUNC(_wrap_FXTopWindow_resize), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXTopWindow_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXTopWindow_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXTopWindow_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXTopWindow_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "canFocus", VALUEFUNC(_wrap_FXTopWindow_canFocus), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "setFocus", VALUEFUNC(_wrap_FXTopWindow_setFocus), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "killFocus", VALUEFUNC(_wrap_FXTopWindow_killFocus), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "changeFocus", VALUEFUNC(_wrap_FXTopWindow_changeFocus), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "setDefault", VALUEFUNC(_wrap_FXTopWindow_setDefault), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "enable", VALUEFUNC(_wrap_FXTopWindow_enable), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "disable", VALUEFUNC(_wrap_FXTopWindow_disable), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "raiseWindow", VALUEFUNC(_wrap_FXTopWindow_raiseWindow), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "lower", VALUEFUNC(_wrap_FXTopWindow_lower), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "move", VALUEFUNC(_wrap_FXTopWindow_move), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "position", VALUEFUNC(_wrap_FXTopWindow_position), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "layout", VALUEFUNC(_wrap_FXTopWindow_layout), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "recalc", VALUEFUNC(_wrap_FXTopWindow_recalc), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "reparent", VALUEFUNC(_wrap_FXTopWindow_reparent), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "hide", VALUEFUNC(_wrap_FXTopWindow_hide), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "isComposite", VALUEFUNC(_wrap_FXTopWindow_isComposite), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "contains", VALUEFUNC(_wrap_FXTopWindow_contains), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXTopWindow_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "setBackColor", VALUEFUNC(_wrap_FXTopWindow_setBackColor), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "tr", VALUEFUNC(_wrap_FXTopWindow_tr), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "dropEnable", VALUEFUNC(_wrap_FXTopWindow_dropEnable), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "dropDisable", VALUEFUNC(_wrap_FXTopWindow_dropDisable), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "setShape", VALUEFUNC(_wrap_FXTopWindow_setShape), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "clearShape", VALUEFUNC(_wrap_FXTopWindow_clearShape), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "show", VALUEFUNC(_wrap_FXTopWindow_show), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "maximize", VALUEFUNC(_wrap_FXTopWindow_maximize), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "minimize", VALUEFUNC(_wrap_FXTopWindow_minimize), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "restore", VALUEFUNC(_wrap_FXTopWindow_restore), -1);
+  rb_define_method(SwigClassFXTopWindow.klass, "close", VALUEFUNC(_wrap_FXTopWindow_close), -1);
+  SwigClassFXTopWindow.mark = (void (*)(void *)) FXRbTopWindow::markfunc;
+  SwigClassFXTopWindow.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXTopWindow.trackObjects = 0;
+  
+  SWIGTYPE_p_FXTopWindow->dcast = (swig_dycast_func) FXTopWindow_dynamic_cast;
+  
+  
+  SwigClassFXMainWindow.klass = rb_define_class_under(mFox, "FXMainWindow", ((swig_class *) SWIGTYPE_p_FXTopWindow->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMainWindow, (void *) &SwigClassFXMainWindow);
+  rb_define_alloc_func(SwigClassFXMainWindow.klass, _wrap_FXMainWindow_allocate);
+  rb_define_method(SwigClassFXMainWindow.klass, "initialize", VALUEFUNC(_wrap_new_FXMainWindow), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "save", VALUEFUNC(_wrap_FXMainWindow_save), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "load", VALUEFUNC(_wrap_FXMainWindow_load), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "create", VALUEFUNC(_wrap_FXMainWindow_create), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "detach", VALUEFUNC(_wrap_FXMainWindow_detach), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "destroy", VALUEFUNC(_wrap_FXMainWindow_destroy), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "resize", VALUEFUNC(_wrap_FXMainWindow_resize), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXMainWindow_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXMainWindow_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXMainWindow_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXMainWindow_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "canFocus", VALUEFUNC(_wrap_FXMainWindow_canFocus), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "setFocus", VALUEFUNC(_wrap_FXMainWindow_setFocus), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "killFocus", VALUEFUNC(_wrap_FXMainWindow_killFocus), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "changeFocus", VALUEFUNC(_wrap_FXMainWindow_changeFocus), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "setDefault", VALUEFUNC(_wrap_FXMainWindow_setDefault), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "enable", VALUEFUNC(_wrap_FXMainWindow_enable), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "disable", VALUEFUNC(_wrap_FXMainWindow_disable), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "raiseWindow", VALUEFUNC(_wrap_FXMainWindow_raiseWindow), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "lower", VALUEFUNC(_wrap_FXMainWindow_lower), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "move", VALUEFUNC(_wrap_FXMainWindow_move), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "position", VALUEFUNC(_wrap_FXMainWindow_position), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "layout", VALUEFUNC(_wrap_FXMainWindow_layout), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "recalc", VALUEFUNC(_wrap_FXMainWindow_recalc), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "reparent", VALUEFUNC(_wrap_FXMainWindow_reparent), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "hide", VALUEFUNC(_wrap_FXMainWindow_hide), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "isComposite", VALUEFUNC(_wrap_FXMainWindow_isComposite), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "contains", VALUEFUNC(_wrap_FXMainWindow_contains), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXMainWindow_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "setBackColor", VALUEFUNC(_wrap_FXMainWindow_setBackColor), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "tr", VALUEFUNC(_wrap_FXMainWindow_tr), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "dropEnable", VALUEFUNC(_wrap_FXMainWindow_dropEnable), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "dropDisable", VALUEFUNC(_wrap_FXMainWindow_dropDisable), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "setShape", VALUEFUNC(_wrap_FXMainWindow_setShape), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "clearShape", VALUEFUNC(_wrap_FXMainWindow_clearShape), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "show", VALUEFUNC(_wrap_FXMainWindow_show), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "maximize", VALUEFUNC(_wrap_FXMainWindow_maximize), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "minimize", VALUEFUNC(_wrap_FXMainWindow_minimize), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "restore", VALUEFUNC(_wrap_FXMainWindow_restore), -1);
+  rb_define_method(SwigClassFXMainWindow.klass, "close", VALUEFUNC(_wrap_FXMainWindow_close), -1);
+  SwigClassFXMainWindow.mark = (void (*)(void *)) FXRbMainWindow::markfunc;
+  SwigClassFXMainWindow.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXMainWindow.trackObjects = 0;
+  rb_define_const(mFox, "SPLASH_SIMPLE", SWIG_From_int(static_cast< int >(SPLASH_SIMPLE)));
+  rb_define_const(mFox, "SPLASH_SHAPED", SWIG_From_int(static_cast< int >(SPLASH_SHAPED)));
+  rb_define_const(mFox, "SPLASH_OWNS_ICON", SWIG_From_int(static_cast< int >(SPLASH_OWNS_ICON)));
+  rb_define_const(mFox, "SPLASH_DESTROY", SWIG_From_int(static_cast< int >(SPLASH_DESTROY)));
+  
+  SwigClassFXSplashWindow.klass = rb_define_class_under(mFox, "FXSplashWindow", ((swig_class *) SWIGTYPE_p_FXTopWindow->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXSplashWindow, (void *) &SwigClassFXSplashWindow);
+  rb_define_alloc_func(SwigClassFXSplashWindow.klass, _wrap_FXSplashWindow_allocate);
+  rb_define_method(SwigClassFXSplashWindow.klass, "initialize", VALUEFUNC(_wrap_new_FXSplashWindow), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "onPaint", VALUEFUNC(_wrap_FXSplashWindow_onPaint), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "icon=", VALUEFUNC(_wrap_FXSplashWindow_icone___), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "icon", VALUEFUNC(_wrap_FXSplashWindow_icon), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "delay=", VALUEFUNC(_wrap_FXSplashWindow_delaye___), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "delay", VALUEFUNC(_wrap_FXSplashWindow_delay), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "save", VALUEFUNC(_wrap_FXSplashWindow_save), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "load", VALUEFUNC(_wrap_FXSplashWindow_load), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "create", VALUEFUNC(_wrap_FXSplashWindow_create), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "detach", VALUEFUNC(_wrap_FXSplashWindow_detach), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "destroy", VALUEFUNC(_wrap_FXSplashWindow_destroy), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "resize", VALUEFUNC(_wrap_FXSplashWindow_resize), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXSplashWindow_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXSplashWindow_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXSplashWindow_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXSplashWindow_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "canFocus", VALUEFUNC(_wrap_FXSplashWindow_canFocus), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "setFocus", VALUEFUNC(_wrap_FXSplashWindow_setFocus), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "killFocus", VALUEFUNC(_wrap_FXSplashWindow_killFocus), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "changeFocus", VALUEFUNC(_wrap_FXSplashWindow_changeFocus), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "setDefault", VALUEFUNC(_wrap_FXSplashWindow_setDefault), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "enable", VALUEFUNC(_wrap_FXSplashWindow_enable), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "disable", VALUEFUNC(_wrap_FXSplashWindow_disable), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "raiseWindow", VALUEFUNC(_wrap_FXSplashWindow_raiseWindow), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "lower", VALUEFUNC(_wrap_FXSplashWindow_lower), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "move", VALUEFUNC(_wrap_FXSplashWindow_move), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "position", VALUEFUNC(_wrap_FXSplashWindow_position), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "layout", VALUEFUNC(_wrap_FXSplashWindow_layout), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "recalc", VALUEFUNC(_wrap_FXSplashWindow_recalc), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "reparent", VALUEFUNC(_wrap_FXSplashWindow_reparent), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "hide", VALUEFUNC(_wrap_FXSplashWindow_hide), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "isComposite", VALUEFUNC(_wrap_FXSplashWindow_isComposite), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "contains", VALUEFUNC(_wrap_FXSplashWindow_contains), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXSplashWindow_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "setBackColor", VALUEFUNC(_wrap_FXSplashWindow_setBackColor), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "tr", VALUEFUNC(_wrap_FXSplashWindow_tr), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "dropEnable", VALUEFUNC(_wrap_FXSplashWindow_dropEnable), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "dropDisable", VALUEFUNC(_wrap_FXSplashWindow_dropDisable), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "setShape", VALUEFUNC(_wrap_FXSplashWindow_setShape), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "clearShape", VALUEFUNC(_wrap_FXSplashWindow_clearShape), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "show", VALUEFUNC(_wrap_FXSplashWindow_show), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "maximize", VALUEFUNC(_wrap_FXSplashWindow_maximize), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "minimize", VALUEFUNC(_wrap_FXSplashWindow_minimize), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "restore", VALUEFUNC(_wrap_FXSplashWindow_restore), -1);
+  rb_define_method(SwigClassFXSplashWindow.klass, "close", VALUEFUNC(_wrap_FXSplashWindow_close), -1);
+  SwigClassFXSplashWindow.mark = (void (*)(void *)) FXRbSplashWindow::markfunc;
+  SwigClassFXSplashWindow.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXSplashWindow.trackObjects = 0;
+}
+
diff --git a/ext/fox16_c/dc_wrap.cpp b/ext/fox16_c/dc_wrap.cpp
new file mode 100644
index 00000000..15078398
--- /dev/null
+++ b/ext/fox16_c/dc_wrap.cpp
@@ -0,0 +1,12165 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 3.0.12
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+
+#ifndef SWIGRUBY
+#define SWIGRUBY
+#endif
+
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
+};
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic C API SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "4"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/*  Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN           0x1
+
+
+/*
+   Flags/methods for returning states.
+
+   The SWIG conversion methods, as ConvertPtr, return an integer
+   that tells if the conversion was successful or not. And if not,
+   an error code can be returned (see swigerrors.swg for the codes).
+
+   Use the following macros/flags to set or process the returning
+   states.
+
+   In old versions of SWIG, code such as the following was usually written:
+
+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+       // success code
+     } else {
+       //fail code
+     }
+
+   Now you can be more explicit:
+
+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+    } else {
+      // fail code
+    }
+
+   which is the same really, but now you can also do
+
+    Type *ptr;
+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+      if (SWIG_IsNewObj(res) {
+        ...
+	delete *ptr;
+      } else {
+        ...
+      }
+    } else {
+      // fail code
+    }
+
+   I.e., now SWIG_ConvertPtr can return new objects and you can
+   identify the case and take care of the deallocation. Of course that
+   also requires SWIG_ConvertPtr to return new result values, such as
+
+      int SWIG_ConvertPtr(obj, ptr,...) {
+        if (<obj is ok>) {
+          if (<need new object>) {
+            *ptr = <ptr to new allocated object>;
+            return SWIG_NEWOBJ;
+          } else {
+            *ptr = <ptr to old object>;
+            return SWIG_OLDOBJ;
+          }
+        } else {
+          return SWIG_BADOBJ;
+        }
+      }
+
+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+   SWIG errors code.
+
+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+   allows to return the 'cast rank', for example, if you have this
+
+       int food(double)
+       int fooi(int);
+
+   and you call
+
+      food(1)   // cast rank '1'  (1 -> 1.0)
+      fooi(1)   // cast rank '0'
+
+   just use the SWIG_AddCast()/SWIG_CheckState()
+*/
+
+#define SWIG_OK                    (0)
+#define SWIG_ERROR                 (-1)
+#define SWIG_IsOK(r)               (r >= 0)
+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT         (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ                (SWIG_ERROR)
+#define SWIG_OLDOBJ                (SWIG_OK)
+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+#  ifndef SWIG_TypeRank
+#    define SWIG_TypeRank             unsigned long
+#  endif
+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
+#    define SWIG_MAXCASTRANK          (2)
+#  endif
+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+#  define SWIG_AddCast(r) (r)
+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *, int *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store information on one type */
+typedef struct swig_type_info {
+  const char             *name;			/* mangled name of this type */
+  const char             *str;			/* human readable name of this type */
+  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
+  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
+  void                   *clientdata;		/* language specific type data */
+  int                    owndata;		/* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
+  swig_converter_func     converter;		/* function to cast the void pointers */
+  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
+  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
+  size_t                 size;		        /* Number of types in this module */
+  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
+  swig_type_info         **type_initial;	/* Array of initially generated type structures */
+  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
+  void                    *clientdata;		/* Language specific module data */
+} swig_module_info;
+
+/*
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+  }
+  return (int)((l1 - f1) - (l2 - f2));
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCmp(const char *nb, const char *tb) {
+  int equiv = 1;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (equiv != 0 && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
+}
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
+}
+
+/*
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+  swig_type_info *lastty = ty;
+  if (!ty || !ty->dcast) return ty;
+  while (ty && (ty->dcast)) {
+    ty = (*ty->dcast)(ptr);
+    if (ty) lastty = ty;
+  }
+  return lastty;
+}
+
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+  return ty->name;
+}
+
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (!type) return NULL;
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
+  }
+  else
+    return type->name;
+}
+
+/*
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+  swig_cast_info *cast = ti->cast;
+  /* if (ti->clientdata == clientdata) return; */
+  ti->clientdata = clientdata;
+
+  while (cast) {
+    if (!cast->converter) {
+      swig_type_info *tc = cast->type;
+      if (!tc->clientdata) {
+	SWIG_TypeClientData(tc, clientdata);
+      }
+    }
+    cast = cast->next;
+  }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientData(ti, clientdata);
+  ti->owndata = 1;
+}
+
+/*
+  Search for a swig_type_info structure only by mangled name
+  Search is a O(log #types)
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+                            swig_module_info *end,
+		            const char *name) {
+  swig_module_info *iter = start;
+  do {
+    if (iter->size) {
+      size_t l = 0;
+      size_t r = iter->size - 1;
+      do {
+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
+	size_t i = (l + r) >> 1;
+	const char *iname = iter->types[i]->name;
+	if (iname) {
+	  int compare = strcmp(name, iname);
+	  if (compare == 0) {
+	    return iter->types[i];
+	  } else if (compare < 0) {
+	    if (i) {
+	      r = i - 1;
+	    } else {
+	      break;
+	    }
+	  } else if (compare > 0) {
+	    l = i + 1;
+	  }
+	} else {
+	  break; /* should never happen */
+	}
+      } while (l <= r);
+    }
+    iter = iter->next;
+  } while (iter != end);
+  return 0;
+}
+
+/*
+  Search for a swig_type_info structure for either a mangled name or a human readable name.
+  It first searches the mangled names of the types, which is a O(log #types)
+  If a type is not found it then searches the human readable names, which is O(#types).
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+                     swig_module_info *end,
+		     const char *name) {
+  /* STEP 1: Search the name field using binary search */
+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+  if (ret) {
+    return ret;
+  } else {
+    /* STEP 2: If the type hasn't been found, do a complete search
+       of the str field (the human readable name) */
+    swig_module_info *iter = start;
+    do {
+      size_t i = 0;
+      for (; i < iter->size; ++i) {
+	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+	  return iter->types[i];
+      }
+      iter = iter->next;
+    } while (iter != end);
+  }
+
+  /* neither found a match */
+  return 0;
+}
+
+/*
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+
+/*
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = (unsigned char)((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = (unsigned char)((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (unsigned char)(d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (unsigned char)(d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/*
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/*  Errors in SWIG */
+#define  SWIG_UnknownError    	   -1
+#define  SWIG_IOError        	   -2
+#define  SWIG_RuntimeError   	   -3
+#define  SWIG_IndexError     	   -4
+#define  SWIG_TypeError      	   -5
+#define  SWIG_DivisionByZero 	   -6
+#define  SWIG_OverflowError  	   -7
+#define  SWIG_SyntaxError    	   -8
+#define  SWIG_ValueError     	   -9
+#define  SWIG_SystemError    	   -10
+#define  SWIG_AttributeError 	   -11
+#define  SWIG_MemoryError    	   -12
+#define  SWIG_NullReferenceError   -13
+
+
+
+      #include <ruby.h>
+
+      #if defined(RB_METHOD_DEFINITION_DECL)
+      # define RUBY_VALUE_METHOD_FUNC(func) (func)
+      # define RUBY_INT_METHOD_FUNC(func) (func)
+      # define RUBY_VOID_METHOD_FUNC(func) (func)
+      # define RUBY_VOIDP_METHOD_FUNC(func) (func)
+      #else
+      # define RUBY_VALUE_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
+      # define RUBY_INT_METHOD_FUNC(func) ((int (*)(ANYARGS))(func))
+      # define RUBY_VOID_METHOD_FUNC(func) ((void (*)(ANYARGS))(func))
+      # define RUBY_VOIDP_METHOD_FUNC(func) ((void *(*)(ANYARGS))(func))
+      #endif
+
+
+/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
+ * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
+ * issue for now by disabling this.
+ * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
+ */
+#ifdef rb_intern
+# undef rb_intern
+#endif
+
+/* Remove global macros defined in Ruby's win32.h */
+#ifdef write
+# undef write
+#endif
+#ifdef read
+# undef read
+#endif
+#ifdef bind
+# undef bind
+#endif
+#ifdef close
+# undef close
+#endif
+#ifdef connect
+# undef connect
+#endif
+
+
+/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
+#ifndef NUM2LL
+#define NUM2LL(x) NUM2LONG((x))
+#endif
+#ifndef LL2NUM
+#define LL2NUM(x) INT2NUM((long) (x))
+#endif
+#ifndef ULL2NUM
+#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
+#endif
+
+/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
+#ifndef NUM2ULL
+#ifdef HAVE_LONG_LONG
+#define NUM2ULL(x) rb_num2ull((x))
+#else
+#define NUM2ULL(x) NUM2ULONG(x)
+#endif
+#endif
+
+/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
+/* Define these for older versions so we can just write code the new way */
+#ifndef RSTRING_LEN
+# define RSTRING_LEN(x) RSTRING(x)->len
+#endif
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(x) RSTRING(x)->ptr
+#endif
+#ifndef RSTRING_END
+# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
+#endif
+#ifndef RARRAY_LEN
+# define RARRAY_LEN(x) RARRAY(x)->len
+#endif
+#ifndef RARRAY_PTR
+# define RARRAY_PTR(x) RARRAY(x)->ptr
+#endif
+#ifndef RFLOAT_VALUE
+# define RFLOAT_VALUE(x) RFLOAT(x)->value
+#endif
+#ifndef DOUBLE2NUM
+# define DOUBLE2NUM(x) rb_float_new(x)
+#endif
+#ifndef RHASH_TBL
+# define RHASH_TBL(x) (RHASH(x)->tbl)
+#endif
+#ifndef RHASH_ITER_LEV
+# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
+#endif
+#ifndef RHASH_IFNONE
+# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
+#endif
+#ifndef RHASH_SIZE
+# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
+#endif
+#ifndef RHASH_EMPTY_P
+# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
+#endif
+#ifndef RSTRUCT_LEN
+# define RSTRUCT_LEN(x) RSTRUCT(x)->len
+#endif
+#ifndef RSTRUCT_PTR
+# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
+#endif
+
+
+
+/*
+ * Need to be very careful about how these macros are defined, especially
+ * when compiling C++ code or C code with an ANSI C compiler.
+ *
+ * VALUEFUNC(f) is a macro used to typecast a C function that implements
+ * a Ruby method so that it can be passed as an argument to API functions
+ * like rb_define_method() and rb_define_singleton_method().
+ *
+ * VOIDFUNC(f) is a macro used to typecast a C function that implements
+ * either the "mark" or "free" stuff for a Ruby Data object, so that it
+ * can be passed as an argument to API functions like Data_Wrap_Struct()
+ * and Data_Make_Struct().
+ */
+ 
+#ifdef __cplusplus
+#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
+#    define PROTECTFUNC(f) ((VALUE (*)()) f)
+#    define VALUEFUNC(f) ((VALUE (*)()) f)
+#    define VOIDFUNC(f)  ((void (*)()) f)
+#  else
+#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
+#      define PROTECTFUNC(f) ((VALUE (*)()) f)
+#      define VALUEFUNC(f) ((VALUE (*)()) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    else /* These definitions should work for Ruby 1.7+ */
+#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
+#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    endif
+#  endif
+#else
+#  define VALUEFUNC(f) (f)
+#  define VOIDFUNC(f) (f)
+#endif
+
+/* Don't use for expressions have side effect */
+#ifndef RB_STRING_VALUE
+#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
+#endif
+#ifndef StringValue
+#define StringValue(s) RB_STRING_VALUE(s)
+#endif
+#ifndef StringValuePtr
+#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
+#endif
+#ifndef StringValueLen
+#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
+#endif
+#ifndef SafeStringValue
+#define SafeStringValue(v) do {\
+    StringValue(v);\
+    rb_check_safe_str(v);\
+} while (0)
+#endif
+
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
+#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
+#endif
+
+static VALUE _mSWIG = Qnil;
+
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+
+/* Define some additional error types */
+#define SWIG_ObjectPreviouslyDeletedError  -100
+
+
+/* Define custom exceptions for errors that do not map to existing Ruby
+   exceptions.  Note this only works for C++ since a global cannot be
+   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/
+
+SWIGINTERN VALUE 
+getNullReferenceError(void) {
+  static int init = 0;
+  static VALUE rb_eNullReferenceError ;
+  if (!init) {
+    init = 1;
+    rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
+  }
+  return rb_eNullReferenceError;
+} 
+
+SWIGINTERN VALUE 
+getObjectPreviouslyDeletedError(void) {
+  static int init = 0;
+  static VALUE rb_eObjectPreviouslyDeleted ;
+  if (!init) {
+    init = 1;
+    rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
+  }
+  return rb_eObjectPreviouslyDeleted;
+} 
+
+
+SWIGINTERN VALUE
+SWIG_Ruby_ErrorType(int SWIG_code) {
+  VALUE type;
+  switch (SWIG_code) {
+  case SWIG_MemoryError:
+    type = rb_eNoMemError;
+    break;
+  case SWIG_IOError:
+    type = rb_eIOError;
+    break;
+  case SWIG_RuntimeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_IndexError:
+    type = rb_eIndexError;
+    break;
+  case SWIG_TypeError:
+    type = rb_eTypeError;
+    break;
+  case SWIG_DivisionByZero:
+    type = rb_eZeroDivError;
+    break;
+  case SWIG_OverflowError:
+    type = rb_eRangeError;
+    break;
+  case SWIG_SyntaxError:
+    type = rb_eSyntaxError;
+    break;
+  case SWIG_ValueError:
+    type = rb_eArgError;
+    break;
+  case SWIG_SystemError:
+    type = rb_eFatal;
+    break;
+  case SWIG_AttributeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_NullReferenceError:
+    type = getNullReferenceError();
+    break;
+  case SWIG_ObjectPreviouslyDeletedError:
+    type = getObjectPreviouslyDeletedError();
+    break;
+  case SWIG_UnknownError:
+    type = rb_eRuntimeError;
+    break;
+  default:
+    type = rb_eRuntimeError;
+  }
+  return type;
+}
+
+
+/* This function is called when a user inputs a wrong argument to
+   a method.
+ */
+SWIGINTERN 
+const char* Ruby_Format_TypeError( const char* msg,
+				   const char* type, 
+				   const char* name, 
+				   const int argn,
+				   VALUE input )
+{
+  char buf[128];
+  VALUE str;
+  VALUE asStr;
+  if ( msg && *msg )
+    {
+      str = rb_str_new2(msg);
+    }
+  else
+    {
+      str = rb_str_new(NULL, 0);
+    }
+
+  str = rb_str_cat2( str, "Expected argument " );
+  sprintf( buf, "%d of type ", argn-1 );
+  str = rb_str_cat2( str, buf );
+  str = rb_str_cat2( str, type );
+  str = rb_str_cat2( str, ", but got " );
+  str = rb_str_cat2( str, rb_obj_classname(input) );
+  str = rb_str_cat2( str, " " );
+  asStr = rb_inspect(input);
+  if ( RSTRING_LEN(asStr) > 30 )
+    {
+      str = rb_str_cat( str, StringValuePtr(asStr), 30 );
+      str = rb_str_cat2( str, "..." );
+    }
+  else
+    {
+      str = rb_str_append( str, asStr );
+    }
+
+  if ( name )
+    {
+      str = rb_str_cat2( str, "\n\tin SWIG method '" );
+      str = rb_str_cat2( str, name );
+      str = rb_str_cat2( str, "'" );
+    }
+
+  return StringValuePtr( str );
+}
+
+/* This function is called when an overloaded method fails */
+SWIGINTERN 
+void Ruby_Format_OverloadedError(
+				 const int argc,
+				 const int maxargs,
+				 const char* method, 
+				 const char* prototypes 
+				 )
+{
+  const char* msg = "Wrong # of arguments";
+  if ( argc <= maxargs ) msg = "Wrong arguments";
+  rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
+	   "Possible C/C++ prototypes are:\n%s",
+	   msg, method, prototypes);
+}
+
+/* -----------------------------------------------------------------------------
+ * rubytracking.swg
+ *
+ * This file contains support for tracking mappings from 
+ * Ruby objects to C++ objects.  This functionality is needed
+ * to implement mark functions for Ruby's mark and sweep
+ * garbage collector.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(ST_DATA_T_DEFINED)
+/* Needs to be explicitly included for Ruby 1.8 and earlier */
+#include <st.h>
+#endif
+
+/* Ruby 1.8 actually assumes the first case. */
+#if SIZEOF_VOIDP == SIZEOF_LONG
+#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
+#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
+#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
+#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
+#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
+#else
+#  error sizeof(void*) is not the same as long or long long
+#endif
+
+/* Global hash table to store Trackings from C/C++
+   structs to Ruby Objects. 
+*/
+static st_table* swig_ruby_trackings = NULL;
+
+static VALUE swig_ruby_trackings_count(ID id, VALUE *var) {
+  return SWIG2NUM(swig_ruby_trackings->num_entries);
+}
+
+
+/* Setup a hash table to store Trackings */
+SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
+  /* Create a hash table to store Trackings from C++
+     objects to Ruby objects. */
+
+  /* Try to see if some other .so has already created a 
+     tracking hash table, which we keep hidden in an instance var
+     in the SWIG module.
+     This is done to allow multiple DSOs to share the same
+     tracking table.
+  */
+  VALUE trackings_value = Qnil;
+  /* change the variable name so that we can mix modules
+     compiled with older SWIG's - this used to be called "@__trackings__" */
+  ID trackings_id = rb_intern( "@__safetrackings__" );
+  VALUE verbose = rb_gv_get("VERBOSE");
+  rb_gv_set("VERBOSE", Qfalse);
+  trackings_value = rb_ivar_get( _mSWIG, trackings_id );
+  rb_gv_set("VERBOSE", verbose);
+
+  /* The trick here is that we have to store the hash table
+  pointer in a Ruby variable. We do not want Ruby's GC to
+  treat this pointer as a Ruby object, so we convert it to
+  a Ruby numeric value. */
+  if (trackings_value == Qnil) {
+    /* No, it hasn't.  Create one ourselves */
+    swig_ruby_trackings = st_init_numtable();
+    rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
+  } else {
+    swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
+  }
+
+        rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", RUBY_VALUE_METHOD_FUNC(swig_ruby_trackings_count), RUBY_VOID_METHOD_FUNC((rb_gvar_setter_t*)NULL))
+;
+}
+
+/* Add a Tracking from a C/C++ struct to a Ruby object */
+SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
+  /* Store the mapping to the global hash table. */
+  st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
+}
+
+/* Get the Ruby object that owns the specified C/C++ struct */
+SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
+  /* Now lookup the value stored in the global hash table */
+  VALUE value;
+
+  if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
+    return value;
+  } else {
+    return Qnil;
+  }
+}
+
+/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
+   is very important to remove objects once they are destroyed
+   since the same memory address may be reused later to create
+   a new object. */
+SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
+  /* Delete the object from the hash table */
+  st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
+}
+
+/* This is a helper method that unlinks a Ruby object from its
+   underlying C++ object.  This is needed if the lifetime of the
+   Ruby object is longer than the C++ object */
+SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
+  VALUE object = SWIG_RubyInstanceFor(ptr);
+
+  if (object != Qnil) {
+    if (TYPE(object) != T_DATA)
+      abort();
+    DATA_PTR(object) = 0;
+  }
+}
+
+/* This is a helper method that iterates over all the trackings
+   passing the C++ object pointer and its related Ruby object
+   to the passed callback function. */
+
+/* Proxy method to abstract the internal trackings datatype */
+      static int swig_ruby_internal_iterate_callback(st_data_t ptr, st_data_t obj, st_data_t meth) {
+        ((void(*)(void*, VALUE))meth)((void*)ptr, (VALUE)obj);
+
+  return ST_CONTINUE;
+}
+
+SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
+  st_foreach(swig_ruby_trackings, RUBY_INT_METHOD_FUNC(swig_ruby_internal_iterate_callback), (st_data_t)meth);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Ruby API portion that goes into the runtime
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGINTERN VALUE
+SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
+  if (NIL_P(target)) {
+    target = o;
+  } else {
+    if (TYPE(target) != T_ARRAY) {
+      VALUE o2 = target;
+      target = rb_ary_new();
+      rb_ary_push(target, o2);
+    }
+    rb_ary_push(target, o);
+  }
+  return target;
+}
+
+/* For ruby1.8.4 and earlier. */
+#ifndef RUBY_INIT_STACK
+   RUBY_EXTERN void Init_stack(VALUE* addr);
+#  define RUBY_INIT_STACK \
+   VALUE variable_in_this_stack_frame; \
+   Init_stack(&variable_in_this_stack_frame);
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* -----------------------------------------------------------------------------
+ * rubyrun.swg
+ *
+ * This file contains the runtime support for Ruby modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
+#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
+#define swig_owntype                                    swig_ruby_owntype
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) 		SWIG_Ruby_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
+#define SWIG_Error(code, msg)            		rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
+#define SWIG_fail                        		goto fail				 
+
+
+/* Ruby-specific SWIG API */
+
+#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
+#define SWIG_define_class(ty)                        	SWIG_Ruby_define_class(ty)
+#define SWIG_NewClassInstance(value, ty)             	SWIG_Ruby_NewClassInstance(value, ty)
+#define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
+#define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  
+
+#include "assert.h"
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  VALUE klass;
+  VALUE mImpl;
+  void  (*mark)(void *);
+  void  (*destroy)(void *);
+  int trackObjects;
+} swig_class;
+
+
+/* Global pointer used to keep some internal SWIG stuff */
+static VALUE _cSWIG_Pointer = Qnil;
+static VALUE swig_runtime_data_type_pointer = Qnil;
+
+/* Global IDs used to keep some internal SWIG stuff */
+static ID swig_arity_id = 0;
+static ID swig_call_id  = 0;
+
+/*
+  If your swig extension is to be run within an embedded ruby and has
+  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
+  This will reset ruby's stack frame on each entry point from the main 
+  program the first time a virtual director function is invoked (in a 
+  non-recursive way).
+  If this is not done, you run the risk of Ruby trashing the stack.
+*/
+
+#ifdef RUBY_EMBEDDED
+
+#  define SWIG_INIT_STACK                            \
+      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
+      ++swig_virtual_calls;
+#  define SWIG_RELEASE_STACK --swig_virtual_calls;
+#  define Ruby_DirectorTypeMismatchException(x) \
+          rb_raise( rb_eTypeError, "%s", x ); return c_result;
+
+      static unsigned int swig_virtual_calls = 0;
+
+#else  /* normal non-embedded extension */
+
+#  define SWIG_INIT_STACK
+#  define SWIG_RELEASE_STACK
+#  define Ruby_DirectorTypeMismatchException(x) \
+          throw Swig::DirectorTypeMismatchException( x );
+
+#endif  /* RUBY_EMBEDDED */
+
+
+SWIGRUNTIME VALUE 
+getExceptionClass(void) {
+  static int init = 0;
+  static VALUE rubyExceptionClass ;
+  if (!init) {
+    init = 1;
+    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
+  }
+  return rubyExceptionClass;
+} 
+
+/* This code checks to see if the Ruby object being raised as part
+   of an exception inherits from the Ruby class Exception.  If so,
+   the object is simply returned.  If not, then a new Ruby exception
+   object is created and that will be returned to Ruby.*/
+SWIGRUNTIME VALUE
+SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
+  VALUE exceptionClass = getExceptionClass();
+  if (rb_obj_is_kind_of(obj, exceptionClass)) {
+    return obj;
+  }  else {
+    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
+  }
+}
+
+/* Initialize Ruby runtime support */
+SWIGRUNTIME void
+SWIG_Ruby_InitRuntime(void)
+{
+  if (_mSWIG == Qnil) {
+    _mSWIG = rb_define_module("SWIG");
+    swig_call_id  = rb_intern("call");
+    swig_arity_id = rb_intern("arity");
+  }
+}
+
+/* Define Ruby class for C type */
+SWIGRUNTIME void
+SWIG_Ruby_define_class(swig_type_info *type)
+{
+  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+  sprintf(klass_name, "TYPE%s", type->name);
+  if (NIL_P(_cSWIG_Pointer)) {
+    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
+    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
+  }
+  rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
+  free((void *) klass_name);
+}
+
+/* Create a new pointer object */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
+{
+  int own =  flags & SWIG_POINTER_OWN; 
+  int track;
+  char *klass_name;
+  swig_class *sklass;
+  VALUE klass;
+  VALUE obj;
+  
+  if (!ptr)
+    return Qnil;
+  
+  if (type->clientdata) {
+    sklass = (swig_class *) type->clientdata;
+		
+    /* Are we tracking this class and have we already returned this Ruby object? */
+    track = sklass->trackObjects;
+    if (track) {
+      obj = SWIG_RubyInstanceFor(ptr);
+      
+      /* Check the object's type and make sure it has the correct type.
+        It might not in cases where methods do things like 
+        downcast methods. */
+      if (obj != Qnil) {
+        VALUE value = rb_iv_get(obj, "@__swigtype__");
+        const char* type_name = RSTRING_PTR(value);
+				
+        if (strcmp(type->name, type_name) == 0) {
+          return obj;
+        }
+      }
+    }
+
+    /* Create a new Ruby object */
+    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
+			   ( own ? VOIDFUNC(sklass->destroy) : 
+			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
+			     ), ptr);
+
+    /* If tracking is on for this class then track this object. */
+    if (track) {
+      SWIG_RubyAddTracking(ptr, obj);
+    }
+  } else {
+    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+    sprintf(klass_name, "TYPE%s", type->name);
+    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
+    free((void *) klass_name);
+    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
+  }
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  
+  return obj;
+}
+
+/* Create a new class instance (always owned) */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
+{
+  VALUE obj;
+  swig_class *sklass = (swig_class *) type->clientdata;
+  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  return obj;
+}
+
+/* Get type mangle from class name */
+SWIGRUNTIMEINLINE char *
+SWIG_Ruby_MangleStr(VALUE obj)
+{
+  VALUE stype = rb_iv_get(obj, "@__swigtype__");
+  return StringValuePtr(stype);
+}
+
+/* Acquire a pointer value */
+typedef struct {
+  void (*datafree)(void *);
+  int own;
+} swig_ruby_owntype;
+
+SWIGRUNTIME swig_ruby_owntype
+SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
+  swig_ruby_owntype oldown = {0, 0};
+  if (obj) {
+    oldown.datafree = RDATA(obj)->dfree;
+    RDATA(obj)->dfree = own.datafree;
+  }
+  return oldown;
+}
+
+/* Convert a pointer value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
+{
+  char *c;
+  swig_cast_info *tc;
+  void *vptr = 0;
+
+  /* Grab the pointer */
+  if (NIL_P(obj)) {
+    if (ptr)
+      *ptr = 0;
+    return SWIG_OK;
+  } else {
+    if (TYPE(obj) != T_DATA) {
+      return SWIG_ERROR;
+    }
+    Data_Get_Struct(obj, void, vptr);
+  }
+  
+  if (own) {
+    own->datafree = RDATA(obj)->dfree;
+    own->own = 0;
+  }
+    
+  /* Check to see if the input object is giving up ownership
+     of the underlying C struct or C++ object.  If so then we
+     need to reset the destructor since the Ruby object no 
+     longer owns the underlying C++ object.*/ 
+  if (flags & SWIG_POINTER_DISOWN) {
+    /* Is tracking on for this class? */
+    int track = 0;
+    if (ty && ty->clientdata) {
+      swig_class *sklass = (swig_class *) ty->clientdata;
+      track = sklass->trackObjects;
+    }
+		
+    if (track) {
+      /* We are tracking objects for this class.  Thus we change the destructor
+       * to SWIG_RubyRemoveTracking.  This allows us to
+       * remove the mapping from the C++ to Ruby object
+       * when the Ruby object is garbage collected.  If we don't
+       * do this, then it is possible we will return a reference 
+       * to a Ruby object that no longer exists thereby crashing Ruby. */
+      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
+    } else {    
+      RDATA(obj)->dfree = 0;
+    }
+  }
+
+  /* Do type-checking if type info was provided */
+  if (ty) {
+    if (ty->clientdata) {
+      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
+        if (vptr == 0) {
+          /* The object has already been deleted */
+          return SWIG_ObjectPreviouslyDeletedError;
+        }
+      }
+    }
+    if ((c = SWIG_MangleStr(obj)) == NULL) {
+      return SWIG_ERROR;
+    }
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) {
+      return SWIG_ERROR;
+    } else {
+      if (ptr) {
+        if (tc->type == ty) {
+          *ptr = vptr;
+        } else {
+          int newmemory = 0;
+          *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
+          if (newmemory == SWIG_CAST_NEW_MEMORY) {
+            assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+            if (own)
+              own->own = own->own | SWIG_CAST_NEW_MEMORY;
+          }
+        }
+      }
+    }
+  } else {
+    if (ptr)
+      *ptr = vptr;
+  }
+  
+  return SWIG_OK;
+}
+
+/* Check convert */
+SWIGRUNTIMEINLINE int
+SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
+{
+  char *c = SWIG_MangleStr(obj);
+  if (!c) return 0;
+  return SWIG_TypeCheck(c,ty) != 0;
+}
+
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r, ptr, sz);
+  strcpy(r, type->name);
+  return rb_str_new2(result);
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c;
+
+  if (TYPE(obj) != T_STRING) goto type_error;
+  c = StringValuePtr(obj);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') goto type_error;
+  c++;
+  c = SWIG_UnpackData(c, ptr, sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) goto type_error;
+  }
+  return SWIG_OK;
+
+ type_error:
+  return SWIG_ERROR;
+}
+
+SWIGRUNTIME swig_module_info *
+SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
+{
+  VALUE pointer;
+  swig_module_info *ret = 0;
+  VALUE verbose = rb_gv_get("VERBOSE");
+
+ /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
+  rb_gv_set("VERBOSE", Qfalse);
+  
+  /* first check if pointer already created */
+  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  if (pointer != Qnil) {
+    Data_Get_Struct(pointer, swig_module_info, ret);
+  }
+
+  /* reinstate warnings */
+  rb_gv_set("VERBOSE", verbose);
+  return ret;
+}
+
+SWIGRUNTIME void 
+SWIG_Ruby_SetModule(swig_module_info *pointer)
+{
+  /* register a new class */
+  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
+  /* create and store the structure pointer to a global variable */
+  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
+  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
+}
+
+/* This function can be used to check whether a proc or method or similarly
+   callable function has been passed.  Usually used in a %typecheck, like:
+
+   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
+        $result = SWIG_Ruby_isCallable( $input );
+   }
+ */
+SWIGINTERN
+int SWIG_Ruby_isCallable( VALUE proc )
+{
+  if ( rb_respond_to( proc, swig_call_id ) )
+    return 1;
+  return 0;
+}
+
+/* This function can be used to check the arity (number of arguments)
+   a proc or method can take.  Usually used in a %typecheck.
+   Valid arities will be that equal to minimal or those < 0
+   which indicate a variable number of parameters at the end.
+ */
+SWIGINTERN
+int SWIG_Ruby_arity( VALUE proc, int minimal )
+{
+  if ( rb_respond_to( proc, swig_arity_id ) )
+    {
+      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
+      int arity = NUM2INT(num);
+      if ( arity < 0 && (arity+1) < -minimal ) return 1;
+      if ( arity == minimal ) return 1;
+      return 1;
+    }
+  return 0;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
+
+
+
+  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) 
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_p_FXApp swig_types[0]
+#define SWIGTYPE_p_FXArc swig_types[1]
+#define SWIGTYPE_p_FXBitmap swig_types[2]
+#define SWIGTYPE_p_FXComposite swig_types[3]
+#define SWIGTYPE_p_FXDC swig_types[4]
+#define SWIGTYPE_p_FXDCPrint swig_types[5]
+#define SWIGTYPE_p_FXDCWindow swig_types[6]
+#define SWIGTYPE_p_FXDrawable swig_types[7]
+#define SWIGTYPE_p_FXEvent swig_types[8]
+#define SWIGTYPE_p_FXFont swig_types[9]
+#define SWIGTYPE_p_FXFrame swig_types[10]
+#define SWIGTYPE_p_FXIcon swig_types[11]
+#define SWIGTYPE_p_FXImage swig_types[12]
+#define SWIGTYPE_p_FXMainWindow swig_types[13]
+#define SWIGTYPE_p_FXPSBounds swig_types[14]
+#define SWIGTYPE_p_FXPopup swig_types[15]
+#define SWIGTYPE_p_FXPrinter swig_types[16]
+#define SWIGTYPE_p_FXRectangle swig_types[17]
+#define SWIGTYPE_p_FXRegion swig_types[18]
+#define SWIGTYPE_p_FXRootWindow swig_types[19]
+#define SWIGTYPE_p_FXSegment swig_types[20]
+#define SWIGTYPE_p_FXShell swig_types[21]
+#define SWIGTYPE_p_FXSplashWindow swig_types[22]
+#define SWIGTYPE_p_FXString swig_types[23]
+#define SWIGTYPE_p_FXTopWindow swig_types[24]
+#define SWIGTYPE_p_FXWindow swig_types[25]
+#define SWIGTYPE_p_char swig_types[26]
+#define SWIGTYPE_p_double swig_types[27]
+#define SWIGTYPE_p_float swig_types[28]
+#define SWIGTYPE_p_int swig_types[29]
+#define SWIGTYPE_p_long swig_types[30]
+#define SWIGTYPE_p_short swig_types[31]
+#define SWIGTYPE_p_unsigned_char swig_types[32]
+#define SWIGTYPE_p_unsigned_int swig_types[33]
+#define SWIGTYPE_p_unsigned_long swig_types[34]
+#define SWIGTYPE_p_unsigned_short swig_types[35]
+static swig_type_info *swig_types[37];
+static swig_module_info swig_module = {swig_types, 36, 0, 0, 0, 0};
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
+
+/* -------- TYPES TABLE (END) -------- */
+
+#define SWIG_init    Init_dc
+#define SWIG_name    "Dc"
+
+
+
+#define SWIG_RUBY_THREAD_BEGIN_BLOCK
+#define SWIG_RUBY_THREAD_END_BLOCK
+
+
+#define SWIGVERSION 0x030012 
+#define SWIG_VERSION SWIGVERSION
+
+
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
+
+
+#include <stdexcept>
+
+
+#include "FXRbCommon.h"
+
+
+inline FXColor to_FXColor(VALUE obj){
+  if(TYPE(obj)==T_STRING){
+    return fxcolorfromname(StringValuePtr(obj));
+    }
+  else if(TYPE(obj)==T_SYMBOL){
+    return fxcolorfromname(rb_id2name(SYM2ID(obj)));
+    }
+  else{
+    return NUM2ULONG(obj);
+    }
+  }
+
+
+inline FXString to_FXString(VALUE obj){
+  if(!NIL_P(obj)){
+    Check_Type(obj,T_STRING);
+    return FXString(StringValuePtr(obj));
+    }
+  else{
+    return FXString::null;
+    }
+  }
+
+
+inline FXbool to_FXbool(VALUE obj){
+  if (obj == Qtrue || obj == Qfalse){
+    return (obj == Qtrue) ? TRUE : FALSE;
+    }
+  else{
+    return static_cast<FXbool>(NUM2UINT(obj));
+    }
+  }
+
+
+static swig_type_info* FXEventTypeInfo=0;
+
+inline void* to_FXEvent(VALUE obj){
+  void* ptr;
+  if(!FXEventTypeInfo){
+    FXEventTypeInfo=SWIG_TypeQuery("FXEvent *");
+    FXASSERT(FXEventTypeInfo!=0);
+    }
+  SWIG_ConvertPtr(obj,&ptr,FXEventTypeInfo,1);
+  return ptr;
+  }
+
+
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
+
+
+  #define SWIG_From_long   LONG2NUM 
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_int  (int value)
+{    
+  return SWIG_From_long  (value);
+}
+
+SWIGINTERN FXSegment *new_FXSegment(FXshort x1=0,FXshort y1=0,FXshort x2=0,FXshort y2=0){
+      FXSegment* seg=new FXSegment;
+      seg->x1=x1; seg->y1=y1; seg->x2=x2; seg->y2=y2;
+      return seg;
+      }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_short  (short value)
+{    
+  return SWIG_From_long  (value);
+}
+
+SWIGINTERN FXArc *new_FXArc(FXshort x=0,FXshort y=0,FXshort w=0,FXshort h=0,FXshort a=0,FXshort b=0){
+      FXArc* arc=new FXArc;
+      arc->x=x; arc->y=y; arc->w=w; arc->h=h; arc->a=a; arc->b=b;
+      return arc;
+      }
+SWIGINTERN FXDC *new_FXDC(FXApp *a){
+      return new FXRbDC(a);
+      }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_long  (unsigned long value)
+{
+  return ULONG2NUM(value); 
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_int  (unsigned int value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+SWIGINTERN VALUE FXDC_getDashPattern(FXDC const *self){
+      return FXRbMakeArray(self->getDashPattern(), self->getDashLength());
+      }
+
+SWIGINTERN swig_type_info*
+SWIG_pchar_descriptor(void)
+{
+  static int init = 0;
+  static swig_type_info* info = 0;
+  if (!init) {
+    info = SWIG_TypeQuery("_p_char");
+    init = 1;
+  }
+  return info;
+}
+
+
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
+{
+  if (TYPE(obj) == T_STRING) {
+    char *cstr = StringValuePtr(obj); 
+    size_t size = RSTRING_LEN(obj) + 1;
+    if (cptr)  {
+      if (alloc) {
+	if (*alloc == SWIG_NEWOBJ) {
+	  *cptr = reinterpret_cast< char* >(memcpy(new char[size], cstr, sizeof(char)*(size)));
+	} else {
+	  *cptr = cstr;
+	  *alloc = SWIG_OLDOBJ;
+	}
+      }
+    }
+    if (psize) *psize = size;
+    return SWIG_OK;
+  } else {
+    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+    if (pchar_descriptor) {
+      void* vptr = 0;
+      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
+	if (cptr) *cptr = (char *)vptr;
+	if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
+	if (alloc) *alloc = SWIG_OLDOBJ;
+	return SWIG_OK;
+      }
+    }
+  }  
+  return SWIG_TypeError;
+}
+
+
+
+
+
+SWIGINTERN VALUE
+SWIG_ruby_failed(VALUE, VALUE)
+{
+  return Qnil;
+} 
+
+
+/*@SWIG:/usr/share/swig3.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE pargs){VALUE *args=(VALUE *)pargs;
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  long *res = (long *)(args[1]);
+  *res = type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj);
+  return obj;
+}
+/*@SWIG@*/
+
+SWIGINTERN int
+SWIG_AsVal_long (VALUE obj, long* val)
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
+    long v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_VALUE_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_VALUE_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_int (VALUE obj, int *val)
+{
+  long v;
+  int res = SWIG_AsVal_long (obj, &v);
+  if (SWIG_IsOK(res)) {
+    if ((v < INT_MIN || v > INT_MAX)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = static_cast< int >(v);
+    }
+  }  
+  return res;
+}
+
+SWIGINTERN FXDCWindow *new_FXDCWindow__SWIG_0(FXDrawable *drawable,FXEvent *event){
+      return new FXRbDCWindow(drawable,event);
+      }
+SWIGINTERN FXDCWindow *new_FXDCWindow__SWIG_1(FXDrawable *drawable){
+      return new FXRbDCWindow(drawable);
+      }
+
+/*@SWIG:/usr/share/swig3.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE pargs){VALUE *args=(VALUE *)pargs;
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  double *res = (double *)(args[1]);
+  *res = NUM2DBL(obj); (void)type;
+  return obj;
+}
+/*@SWIG@*/
+
+SWIGINTERN int
+SWIG_AsVal_double (VALUE obj, double *val)
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FLOAT) || (type == T_FIXNUM) || (type == T_BIGNUM)) {
+    double v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_VALUE_METHOD_FUNC(SWIG_AUX_NUM2DBL), (VALUE)a, RUBY_VALUE_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+  #define SWIG_From_double   rb_float_new 
+
+SWIGINTERN FXDCPrint *new_FXDCPrint(FXApp *a){
+      return new FXRbDCPrint(a);
+      }
+static swig_class SwigClassFXSegment;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXSegment_allocate(VALUE self)
+#else
+_wrap_FXSegment_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXSegment);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSegment(int argc, VALUE *argv, VALUE self) {
+  FXshort arg1 = (FXshort) 0 ;
+  FXshort arg2 = (FXshort) 0 ;
+  FXshort arg3 = (FXshort) 0 ;
+  FXshort arg4 = (FXshort) 0 ;
+  FXSegment *result = 0 ;
+  
+  if ((argc < 0) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  if (argc > 0) {
+    arg1 = NUM2INT(argv[0]);
+  }
+  if (argc > 1) {
+    arg2 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  result = (FXSegment *)new_FXSegment(arg1,arg2,arg3,arg4);
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSegment_x1_set(int argc, VALUE *argv, VALUE self) {
+  FXSegment *arg1 = (FXSegment *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSegment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSegment *","x1", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSegment * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->x1 = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSegment_x1_get(int argc, VALUE *argv, VALUE self) {
+  FXSegment *arg1 = (FXSegment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXshort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSegment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSegment *","x1", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSegment * >(argp1);
+  result = (FXshort) ((arg1)->x1);
+  vresult = SWIG_From_short(static_cast< short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSegment_y1_set(int argc, VALUE *argv, VALUE self) {
+  FXSegment *arg1 = (FXSegment *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSegment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSegment *","y1", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSegment * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->y1 = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSegment_y1_get(int argc, VALUE *argv, VALUE self) {
+  FXSegment *arg1 = (FXSegment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXshort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSegment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSegment *","y1", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSegment * >(argp1);
+  result = (FXshort) ((arg1)->y1);
+  vresult = SWIG_From_short(static_cast< short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSegment_x2_set(int argc, VALUE *argv, VALUE self) {
+  FXSegment *arg1 = (FXSegment *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSegment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSegment *","x2", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSegment * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->x2 = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSegment_x2_get(int argc, VALUE *argv, VALUE self) {
+  FXSegment *arg1 = (FXSegment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXshort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSegment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSegment *","x2", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSegment * >(argp1);
+  result = (FXshort) ((arg1)->x2);
+  vresult = SWIG_From_short(static_cast< short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSegment_y2_set(int argc, VALUE *argv, VALUE self) {
+  FXSegment *arg1 = (FXSegment *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSegment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSegment *","y2", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSegment * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->y2 = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSegment_y2_get(int argc, VALUE *argv, VALUE self) {
+  FXSegment *arg1 = (FXSegment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXshort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSegment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSegment *","y2", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSegment * >(argp1);
+  result = (FXshort) ((arg1)->y2);
+  vresult = SWIG_From_short(static_cast< short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN void
+free_FXSegment(void *self) {
+    FXSegment *arg1 = (FXSegment *)self;
+    delete arg1;
+}
+
+static swig_class SwigClassFXArc;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXArc_allocate(VALUE self)
+#else
+_wrap_FXArc_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXArc);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXArc(int argc, VALUE *argv, VALUE self) {
+  FXshort arg1 = (FXshort) 0 ;
+  FXshort arg2 = (FXshort) 0 ;
+  FXshort arg3 = (FXshort) 0 ;
+  FXshort arg4 = (FXshort) 0 ;
+  FXshort arg5 = (FXshort) 0 ;
+  FXshort arg6 = (FXshort) 0 ;
+  FXArc *result = 0 ;
+  
+  if ((argc < 0) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  if (argc > 0) {
+    arg1 = NUM2INT(argv[0]);
+  }
+  if (argc > 1) {
+    arg2 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  result = (FXArc *)new_FXArc(arg1,arg2,arg3,arg4,arg5,arg6);
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArc_x_set(int argc, VALUE *argv, VALUE self) {
+  FXArc *arg1 = (FXArc *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArc *","x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArc * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->x = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArc_x_get(int argc, VALUE *argv, VALUE self) {
+  FXArc *arg1 = (FXArc *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXshort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArc *","x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArc * >(argp1);
+  result = (FXshort) ((arg1)->x);
+  vresult = SWIG_From_short(static_cast< short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArc_y_set(int argc, VALUE *argv, VALUE self) {
+  FXArc *arg1 = (FXArc *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArc *","y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArc * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->y = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArc_y_get(int argc, VALUE *argv, VALUE self) {
+  FXArc *arg1 = (FXArc *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXshort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArc *","y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArc * >(argp1);
+  result = (FXshort) ((arg1)->y);
+  vresult = SWIG_From_short(static_cast< short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArc_w_set(int argc, VALUE *argv, VALUE self) {
+  FXArc *arg1 = (FXArc *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArc *","w", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArc * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->w = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArc_w_get(int argc, VALUE *argv, VALUE self) {
+  FXArc *arg1 = (FXArc *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXshort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArc *","w", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArc * >(argp1);
+  result = (FXshort) ((arg1)->w);
+  vresult = SWIG_From_short(static_cast< short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArc_h_set(int argc, VALUE *argv, VALUE self) {
+  FXArc *arg1 = (FXArc *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArc *","h", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArc * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->h = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArc_h_get(int argc, VALUE *argv, VALUE self) {
+  FXArc *arg1 = (FXArc *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXshort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArc *","h", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArc * >(argp1);
+  result = (FXshort) ((arg1)->h);
+  vresult = SWIG_From_short(static_cast< short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArc_a_set(int argc, VALUE *argv, VALUE self) {
+  FXArc *arg1 = (FXArc *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArc *","a", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArc * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->a = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArc_a_get(int argc, VALUE *argv, VALUE self) {
+  FXArc *arg1 = (FXArc *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXshort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArc *","a", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArc * >(argp1);
+  result = (FXshort) ((arg1)->a);
+  vresult = SWIG_From_short(static_cast< short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArc_b_set(int argc, VALUE *argv, VALUE self) {
+  FXArc *arg1 = (FXArc *) 0 ;
+  FXshort arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArc *","b", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArc * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->b = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArc_b_get(int argc, VALUE *argv, VALUE self) {
+  FXArc *arg1 = (FXArc *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXshort result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArc, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArc *","b", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArc * >(argp1);
+  result = (FXshort) ((arg1)->b);
+  vresult = SWIG_From_short(static_cast< short >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN void
+free_FXArc(void *self) {
+    FXArc *arg1 = (FXArc *)self;
+    delete arg1;
+}
+
+static swig_class SwigClassFXDC;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXDC_allocate(VALUE self)
+#else
+_wrap_FXDC_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXDC);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXDC(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXDC *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXDC", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXDC *)new_FXDC(arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_getApp(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXApp *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getApp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  result = (FXApp *)((FXDC const *)arg1)->getApp();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXApp, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_getForeground(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getForeground", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  result = (FXColor)((FXDC const *)arg1)->getForeground();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_getBackground(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getBackground", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  result = (FXColor)((FXDC const *)arg1)->getBackground();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_getDashPattern(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getDashPattern", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  result = (VALUE)FXDC_getDashPattern((FXDC const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_getDashOffset(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getDashOffset", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  result = (FXuint)((FXDC const *)arg1)->getDashOffset();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_getLineWidth(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getLineWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  result = (FXuint)((FXDC const *)arg1)->getLineWidth();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_getLineCap(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXCapStyle result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getLineCap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  result = (FXCapStyle)((FXDC const *)arg1)->getLineCap();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_getLineJoin(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXJoinStyle result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getLineJoin", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  result = (FXJoinStyle)((FXDC const *)arg1)->getLineJoin();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_getLineStyle(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXLineStyle result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getLineStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  result = (FXLineStyle)((FXDC const *)arg1)->getLineStyle();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_getFillStyle(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFillStyle result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getFillStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  result = (FXFillStyle)((FXDC const *)arg1)->getFillStyle();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_getFillRule(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFillRule result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getFillRule", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  result = (FXFillRule)((FXDC const *)arg1)->getFillRule();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_getFunction(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFunction result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getFunction", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  result = (FXFunction)((FXDC const *)arg1)->getFunction();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_getTile(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXImage *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getTile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  result = (FXImage *)((FXDC const *)arg1)->getTile();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXImage, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_getStippleBitmap(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXBitmap *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getStippleBitmap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  result = (FXBitmap *)((FXDC const *)arg1)->getStippleBitmap();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXBitmap, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_getStipplePattern(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXStipplePattern result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getStipplePattern", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  result = (FXStipplePattern)((FXDC const *)arg1)->getStipplePattern();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_getClipRectangle(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXRectangle *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getClipRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  result = (FXRectangle *) &((FXDC const *)arg1)->getClipRectangle();
+  vresult = FXRbGetRubyObj(result, "FXRectangle *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_getClipX(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getClipX", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  result = (FXint)((FXDC const *)arg1)->getClipX();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_getClipY(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getClipY", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  result = (FXint)((FXDC const *)arg1)->getClipY();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_getClipWidth(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getClipWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  result = (FXint)((FXDC const *)arg1)->getClipWidth();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_getClipHeight(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getClipHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  result = (FXint)((FXDC const *)arg1)->getClipHeight();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_getFont(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  result = (FXFont *)((FXDC const *)arg1)->getFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_readPixel(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","readPixel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXColor)FXDC_readPixel(arg1,arg2,arg3);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawPoint(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawPoint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDC_drawPoint(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawPoints(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawPoints", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDC_drawPoints(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawPointsRel(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawPointsRel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDC_drawPointsRel(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawLine(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawLine", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDC_drawLine(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawLines(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawLines", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDC_drawLines(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawLinesRel(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawLinesRel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDC_drawLinesRel(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawLineSegments(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXSegment *arg2 = (FXSegment *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawLineSegments", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXSegment[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXSegment *pSeg;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXSegment, pSeg);
+      arg2[i] = *pSeg;
+    }
+  }
+  FXDC_drawLineSegments(arg1,(FXSegment const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawRectangle(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDC_drawRectangle(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawRectangles(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXRectangle *arg2 = (FXRectangle *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawRectangles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXRectangle[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXRectangle *pRect;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXRectangle, pRect);
+      arg2[i] = *pRect;
+    }
+  }
+  FXDC_drawRectangles(arg1,(FXRectangle const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawRoundRectangle(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawRoundRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXDC_drawRoundRectangle(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawArc(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawArc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXDC_drawArc(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawArcs(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXArc *arg2 = (FXArc *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawArcs", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXArc[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXArc *pArc;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXArc, pArc);
+      arg2[i] = *pArc;
+    }
+  }
+  FXDC_drawArcs(arg1,(FXArc const *)arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawEllipse(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawEllipse", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDC_drawEllipse(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_fillRectangle(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDC_fillRectangle(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_fillRectangles(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXRectangle *arg2 = (FXRectangle *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillRectangles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXRectangle[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXRectangle *pRect;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXRectangle, pRect);
+      arg2[i] = *pRect;
+    }
+  }
+  FXDC_fillRectangles(arg1,(FXRectangle const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_fillRoundRectangle(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillRoundRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXDC_fillRoundRectangle(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_fillChord(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillChord", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXDC_fillChord(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_fillChords(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXArc *arg2 = (FXArc *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillChords", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXArc, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXArc const *","fillChords", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXArc * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  FXDC_fillChords(arg1,(FXArc const *)arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_fillArc(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillArc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXDC_fillArc(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_fillArcs(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXArc *arg2 = (FXArc *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillArcs", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXArc[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXArc *pArc;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXArc, pArc);
+      arg2[i] = *pArc;
+    }
+  }
+  FXDC_fillArcs(arg1,(FXArc const *)arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_fillPolygon(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillPolygon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDC_fillPolygon(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_fillConcavePolygon(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillConcavePolygon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDC_fillConcavePolygon(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_fillComplexPolygon(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillComplexPolygon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDC_fillComplexPolygon(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_fillPolygonRel(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillPolygonRel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDC_fillPolygonRel(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_fillConcavePolygonRel(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillConcavePolygonRel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDC_fillConcavePolygonRel(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_fillComplexPolygonRel(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","fillComplexPolygonRel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDC_fillComplexPolygonRel(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawHashBox(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawHashBox", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = NUM2INT(argv[4]);
+  }
+  FXDC_drawHashBox(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawFocusRectangle(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawFocusRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDC_drawFocusRectangle(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawArea__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXDrawable *arg2 = (FXDrawable *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  FXint arg8 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 7) || (argc > 7)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawArea", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXDrawable, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDrawable const *","drawArea", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXDrawable * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  arg8 = NUM2INT(argv[6]);
+  FXDC_drawArea(arg1,(FXDrawable const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawArea__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXDrawable *arg2 = (FXDrawable *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  FXint arg8 ;
+  FXint arg9 ;
+  FXint arg10 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 9) || (argc > 9)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawArea", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXDrawable, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDrawable const *","drawArea", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXDrawable * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  arg8 = NUM2INT(argv[6]);
+  arg9 = NUM2INT(argv[7]);
+  arg10 = NUM2INT(argv[8]);
+  FXDC_drawArea(arg1,(FXDrawable const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDC_drawArea(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[11];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 11) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 8) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDC, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXDrawable, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    return _wrap_FXDC_drawArea__SWIG_0(nargs, args, self);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if (argc == 10) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDC, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXDrawable, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    {
+                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
+                    }
+                    if (_v) {
+                      {
+                        _v = (TYPE(argv[9]) == T_FIXNUM || TYPE(argv[9]) == T_BIGNUM) ? 1 : 0;
+                      }
+                      if (_v) {
+                        return _wrap_FXDC_drawArea__SWIG_1(nargs, args, self);
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 11, "drawArea", 
+    "    void drawArea(FXDrawable const *source, FXint sx, FXint sy, FXint sw, FXint sh, FXint dx, FXint dy)\n"
+    "    void drawArea(FXDrawable const *source, FXint sx, FXint sy, FXint sw, FXint sh, FXint dx, FXint dy, FXint dw, FXint dh)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawImage(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXImage *arg2 = (FXImage *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawImage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXImage const *","drawImage", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXImage * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  FXDC_drawImage(arg1,(FXImage const *)arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawBitmap(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawBitmap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap const *","drawBitmap", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  FXDC_drawBitmap(arg1,(FXBitmap const *)arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawIcon(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon const *","drawIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  FXDC_drawIcon(arg1,(FXIcon const *)arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawIconShaded(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawIconShaded", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon const *","drawIconShaded", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  FXDC_drawIconShaded(arg1,(FXIcon const *)arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawIconSunken(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawIconSunken", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon const *","drawIconSunken", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  FXDC_drawIconSunken(arg1,(FXIcon const *)arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawText(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXchar *arg4 = (FXchar *) 0 ;
+  FXuint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    Check_Type(argv[2], T_STRING);
+    arg4 = StringValuePtr(argv[2]);
+    arg5 = RSTRING_LEN(argv[2]);
+  }
+  FXDC_drawText(arg1,arg2,arg3,(char const *)arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_drawImageText(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXchar *arg4 = (FXchar *) 0 ;
+  FXuint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","drawImageText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    Check_Type(argv[2], T_STRING);
+    arg4 = StringValuePtr(argv[2]);
+    arg5 = RSTRING_LEN(argv[2]);
+  }
+  FXDC_drawImageText(arg1,arg2,arg3,(char const *)arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_setForeground(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setForeground", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXDC_setForeground(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_setBackground(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setBackground", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXDC_setBackground(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_setDashes(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXuint arg2 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  FXuint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setDashes", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  {
+    Check_Type(argv[1], T_ARRAY);
+    arg3 = new FXchar[RARRAY_LEN(argv[1])];
+    arg4 = static_cast<FXuint>( RARRAY_LEN(argv[1]) );
+    for (FXuint i = 0; i < arg4; i++) {
+      arg3[i] = NUM2INT(rb_ary_entry(argv[1], i));
+    }
+  }
+  FXDC_setDashes(arg1,arg2,(char const *)arg3,arg4);
+  {
+    delete [] arg3;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg3;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_setLineWidth(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXuint arg2 = (FXuint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setLineWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  FXDC_setLineWidth(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_setLineCap(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXCapStyle arg2 = (FXCapStyle) CAP_BUTT ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setLineCap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_int(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXCapStyle","setLineCap", 2, argv[0] ));
+    } 
+    arg2 = static_cast< FXCapStyle >(val2);
+  }
+  FXDC_setLineCap(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_setLineJoin(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXJoinStyle arg2 = (FXJoinStyle) JOIN_MITER ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setLineJoin", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_int(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXJoinStyle","setLineJoin", 2, argv[0] ));
+    } 
+    arg2 = static_cast< FXJoinStyle >(val2);
+  }
+  FXDC_setLineJoin(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_setLineStyle(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXLineStyle arg2 = (FXLineStyle) LINE_SOLID ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setLineStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_int(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXLineStyle","setLineStyle", 2, argv[0] ));
+    } 
+    arg2 = static_cast< FXLineStyle >(val2);
+  }
+  FXDC_setLineStyle(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_setFillStyle(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXFillStyle arg2 = (FXFillStyle) FILL_SOLID ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setFillStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_int(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXFillStyle","setFillStyle", 2, argv[0] ));
+    } 
+    arg2 = static_cast< FXFillStyle >(val2);
+  }
+  FXDC_setFillStyle(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_setFillRule(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXFillRule arg2 = (FXFillRule) RULE_EVEN_ODD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setFillRule", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_int(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXFillRule","setFillRule", 2, argv[0] ));
+    } 
+    arg2 = static_cast< FXFillRule >(val2);
+  }
+  FXDC_setFillRule(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_setFunction(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXFunction arg2 = (FXFunction) BLT_SRC ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setFunction", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_int(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXFunction","setFunction", 2, argv[0] ));
+    } 
+    arg2 = static_cast< FXFunction >(val2);
+  }
+  FXDC_setFunction(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_setTile(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXImage *arg2 = (FXImage *) 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setTile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXImage *","setTile", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXImage * >(argp2);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXDC_setTile(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_setStipple__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setStipple", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setStipple", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXDC_setStipple(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_setStipple__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXStipplePattern arg2 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setStipple", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXStipplePattern","setStipple", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXStipplePattern >(val2);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXDC_setStipple(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDC_setStipple(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 5) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 2) && (argc <= 4)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDC, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_FXDC_setStipple__SWIG_0(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXDC_setStipple__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_FXDC_setStipple__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 2) && (argc <= 4)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDC, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_FXDC_setStipple__SWIG_1(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXDC_setStipple__SWIG_1(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_FXDC_setStipple__SWIG_1(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 5, "setStipple", 
+    "    void setStipple(FXBitmap *bitmap, FXint dx, FXint dy)\n"
+    "    void setStipple(FXStipplePattern pat, FXint dx, FXint dy)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_setClipRegion(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setClipRegion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setClipRegion", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setClipRegion", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXDC_setClipRegion(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_setClipRectangle__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setClipRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDC_setClipRectangle(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_setClipRectangle__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXRectangle *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setClipRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRectangle,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRectangle const &","setClipRectangle", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRectangle const &","setClipRectangle", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRectangle * >(argp2);
+  FXDC_setClipRectangle(arg1,(FXRectangle const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDC_setClipRectangle(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDC, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRectangle, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDC_setClipRectangle__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDC, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXDC_setClipRectangle__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "setClipRectangle", 
+    "    void setClipRectangle(FXint x, FXint y, FXint w, FXint h)\n"
+    "    void setClipRectangle(FXRectangle const &rectangle)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_clearClipRectangle(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","clearClipRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  FXDC_clearClipRectangle(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_setClipMask(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setClipMask", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setClipMask", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXDC_setClipMask(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_clearClipMask(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","clearClipMask", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  FXDC_clearClipMask(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_setFont(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  FXDC_setFont(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDC_clipChildren(int argc, VALUE *argv, VALUE self) {
+  FXDC *arg1 = (FXDC *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDC, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDC *","clipChildren", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDC * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXDC_clipChildren(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXDCWindow;
+
+SWIGINTERN VALUE
+_wrap_new_FXDCWindow__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDrawable *arg1 = (FXDrawable *) 0 ;
+  FXEvent *arg2 = (FXEvent *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXDCWindow *result = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXDrawable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDrawable *","FXDCWindow", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXDrawable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXEvent, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXEvent *","FXDCWindow", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXEvent * >(argp2);
+  {
+    result = (FXDCWindow *)new_FXDCWindow__SWIG_0(arg1,arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_ensure(RUBY_VALUE_METHOD_FUNC(rb_yield), self, RUBY_VALUE_METHOD_FUNC(FXRbDCWindow::endit), self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXDCWindow_allocate(VALUE self)
+#else
+_wrap_FXDCWindow_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXDCWindow);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXDCWindow__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDrawable *arg1 = (FXDrawable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXDCWindow *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXDrawable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDrawable *","FXDCWindow", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXDrawable * >(argp1);
+  {
+    result = (FXDCWindow *)new_FXDCWindow__SWIG_1(arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_ensure(RUBY_VALUE_METHOD_FUNC(rb_yield), self, RUBY_VALUE_METHOD_FUNC(FXRbDCWindow::endit), self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXDCWindow(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[2];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 2) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDrawable, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXDCWindow__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDrawable, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXEvent, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_FXDCWindow__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 2, "FXDCWindow.new", 
+    "    FXDCWindow.new(FXDrawable *drawable, FXEvent *event)\n"
+    "    FXDCWindow.new(FXDrawable *drawable)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_begin(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXDrawable *arg2 = (FXDrawable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","begin", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXDrawable, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDrawable *","begin", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXDrawable * >(argp2);
+  (arg1)->begin(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_end(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","end", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  (arg1)->end();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN void
+free_FXDCWindow(void *self) {
+    FXDCWindow *arg1 = (FXDCWindow *)self;
+    delete arg1;
+}
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_readPixel(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","readPixel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXColor)FXDCWindow_readPixel(arg1,arg2,arg3);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawPoint(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawPoint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDCWindow_drawPoint(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawPoints(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawPoints", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDCWindow_drawPoints(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawPointsRel(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawPointsRel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDCWindow_drawPointsRel(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawLine(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawLine", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDCWindow_drawLine(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawLines(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawLines", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDCWindow_drawLines(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawLinesRel(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawLinesRel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDCWindow_drawLinesRel(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawLineSegments(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXSegment *arg2 = (FXSegment *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawLineSegments", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXSegment[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXSegment *pSeg;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXSegment, pSeg);
+      arg2[i] = *pSeg;
+    }
+  }
+  FXDCWindow_drawLineSegments(arg1,(FXSegment const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawRectangle(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDCWindow_drawRectangle(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawRectangles(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXRectangle *arg2 = (FXRectangle *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawRectangles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXRectangle[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXRectangle *pRect;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXRectangle, pRect);
+      arg2[i] = *pRect;
+    }
+  }
+  FXDCWindow_drawRectangles(arg1,(FXRectangle const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawRoundRectangle(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawRoundRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXDCWindow_drawRoundRectangle(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawArc(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawArc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXDCWindow_drawArc(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawArcs(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXArc *arg2 = (FXArc *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawArcs", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXArc[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXArc *pArc;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXArc, pArc);
+      arg2[i] = *pArc;
+    }
+  }
+  FXDCWindow_drawArcs(arg1,(FXArc const *)arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawEllipse(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawEllipse", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDCWindow_drawEllipse(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_fillRectangle(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","fillRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDCWindow_fillRectangle(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_fillRectangles(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXRectangle *arg2 = (FXRectangle *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","fillRectangles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXRectangle[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXRectangle *pRect;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXRectangle, pRect);
+      arg2[i] = *pRect;
+    }
+  }
+  FXDCWindow_fillRectangles(arg1,(FXRectangle const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_fillRoundRectangle(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","fillRoundRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXDCWindow_fillRoundRectangle(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_fillChord(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","fillChord", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXDCWindow_fillChord(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_fillChords(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXArc *arg2 = (FXArc *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","fillChords", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXArc, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXArc const *","fillChords", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXArc * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  FXDCWindow_fillChords(arg1,(FXArc const *)arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_fillArc(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","fillArc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXDCWindow_fillArc(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_fillArcs(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXArc *arg2 = (FXArc *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","fillArcs", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXArc[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXArc *pArc;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXArc, pArc);
+      arg2[i] = *pArc;
+    }
+  }
+  FXDCWindow_fillArcs(arg1,(FXArc const *)arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_fillPolygon(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","fillPolygon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDCWindow_fillPolygon(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_fillConcavePolygon(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","fillConcavePolygon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDCWindow_fillConcavePolygon(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_fillComplexPolygon(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","fillComplexPolygon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDCWindow_fillComplexPolygon(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_fillPolygonRel(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","fillPolygonRel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDCWindow_fillPolygonRel(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_fillConcavePolygonRel(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","fillConcavePolygonRel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDCWindow_fillConcavePolygonRel(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_fillComplexPolygonRel(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","fillComplexPolygonRel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDCWindow_fillComplexPolygonRel(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawHashBox(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawHashBox", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = NUM2INT(argv[4]);
+  }
+  FXDCWindow_drawHashBox(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawFocusRectangle(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawFocusRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDCWindow_drawFocusRectangle(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawArea__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXDrawable *arg2 = (FXDrawable *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  FXint arg8 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 7) || (argc > 7)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawArea", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXDrawable, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDrawable const *","drawArea", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXDrawable * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  arg8 = NUM2INT(argv[6]);
+  FXDCWindow_drawArea(arg1,(FXDrawable const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawArea__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXDrawable *arg2 = (FXDrawable *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  FXint arg8 ;
+  FXint arg9 ;
+  FXint arg10 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 9) || (argc > 9)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawArea", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXDrawable, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDrawable const *","drawArea", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXDrawable * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  arg8 = NUM2INT(argv[6]);
+  arg9 = NUM2INT(argv[7]);
+  arg10 = NUM2INT(argv[8]);
+  FXDCWindow_drawArea(arg1,(FXDrawable const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDCWindow_drawArea(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[11];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 11) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 8) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDCWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXDrawable, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    return _wrap_FXDCWindow_drawArea__SWIG_0(nargs, args, self);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if (argc == 10) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDCWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXDrawable, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    {
+                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
+                    }
+                    if (_v) {
+                      {
+                        _v = (TYPE(argv[9]) == T_FIXNUM || TYPE(argv[9]) == T_BIGNUM) ? 1 : 0;
+                      }
+                      if (_v) {
+                        return _wrap_FXDCWindow_drawArea__SWIG_1(nargs, args, self);
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 11, "drawArea", 
+    "    void drawArea(FXDrawable const *source, FXint sx, FXint sy, FXint sw, FXint sh, FXint dx, FXint dy)\n"
+    "    void drawArea(FXDrawable const *source, FXint sx, FXint sy, FXint sw, FXint sh, FXint dx, FXint dy, FXint dw, FXint dh)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawImage(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXImage *arg2 = (FXImage *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawImage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXImage const *","drawImage", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXImage * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  FXDCWindow_drawImage(arg1,(FXImage const *)arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawBitmap(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawBitmap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap const *","drawBitmap", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  FXDCWindow_drawBitmap(arg1,(FXBitmap const *)arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawIcon(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon const *","drawIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  FXDCWindow_drawIcon(arg1,(FXIcon const *)arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawIconShaded(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawIconShaded", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon const *","drawIconShaded", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  FXDCWindow_drawIconShaded(arg1,(FXIcon const *)arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawIconSunken(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawIconSunken", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon const *","drawIconSunken", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  FXDCWindow_drawIconSunken(arg1,(FXIcon const *)arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawText(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXchar *arg4 = (FXchar *) 0 ;
+  FXuint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    Check_Type(argv[2], T_STRING);
+    arg4 = StringValuePtr(argv[2]);
+    arg5 = RSTRING_LEN(argv[2]);
+  }
+  FXDCWindow_drawText(arg1,arg2,arg3,(char const *)arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_drawImageText(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXchar *arg4 = (FXchar *) 0 ;
+  FXuint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","drawImageText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    Check_Type(argv[2], T_STRING);
+    arg4 = StringValuePtr(argv[2]);
+    arg5 = RSTRING_LEN(argv[2]);
+  }
+  FXDCWindow_drawImageText(arg1,arg2,arg3,(char const *)arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_setForeground(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","setForeground", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXDCWindow_setForeground(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_setBackground(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","setBackground", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXDCWindow_setBackground(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_setDashes(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXuint arg2 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  FXuint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","setDashes", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  {
+    Check_Type(argv[1], T_ARRAY);
+    arg3 = new FXchar[RARRAY_LEN(argv[1])];
+    arg4 = static_cast<FXuint>( RARRAY_LEN(argv[1]) );
+    for (FXuint i = 0; i < arg4; i++) {
+      arg3[i] = NUM2INT(rb_ary_entry(argv[1], i));
+    }
+  }
+  FXDCWindow_setDashes(arg1,arg2,(char const *)arg3,arg4);
+  {
+    delete [] arg3;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg3;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_setLineWidth(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXuint arg2 = (FXuint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","setLineWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  FXDCWindow_setLineWidth(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_setLineCap(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXCapStyle arg2 = (FXCapStyle) CAP_BUTT ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","setLineCap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_int(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXCapStyle","setLineCap", 2, argv[0] ));
+    } 
+    arg2 = static_cast< FXCapStyle >(val2);
+  }
+  FXDCWindow_setLineCap(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_setLineJoin(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXJoinStyle arg2 = (FXJoinStyle) JOIN_MITER ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","setLineJoin", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_int(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXJoinStyle","setLineJoin", 2, argv[0] ));
+    } 
+    arg2 = static_cast< FXJoinStyle >(val2);
+  }
+  FXDCWindow_setLineJoin(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_setLineStyle(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXLineStyle arg2 = (FXLineStyle) LINE_SOLID ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","setLineStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_int(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXLineStyle","setLineStyle", 2, argv[0] ));
+    } 
+    arg2 = static_cast< FXLineStyle >(val2);
+  }
+  FXDCWindow_setLineStyle(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_setFillStyle(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXFillStyle arg2 = (FXFillStyle) FILL_SOLID ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","setFillStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_int(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXFillStyle","setFillStyle", 2, argv[0] ));
+    } 
+    arg2 = static_cast< FXFillStyle >(val2);
+  }
+  FXDCWindow_setFillStyle(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_setFillRule(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXFillRule arg2 = (FXFillRule) RULE_EVEN_ODD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","setFillRule", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_int(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXFillRule","setFillRule", 2, argv[0] ));
+    } 
+    arg2 = static_cast< FXFillRule >(val2);
+  }
+  FXDCWindow_setFillRule(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_setFunction(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXFunction arg2 = (FXFunction) BLT_SRC ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","setFunction", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_int(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXFunction","setFunction", 2, argv[0] ));
+    } 
+    arg2 = static_cast< FXFunction >(val2);
+  }
+  FXDCWindow_setFunction(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_setTile(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXImage *arg2 = (FXImage *) 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","setTile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXImage *","setTile", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXImage * >(argp2);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXDCWindow_setTile(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_setStipple__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","setStipple", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setStipple", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXDCWindow_setStipple(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_setStipple__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXStipplePattern arg2 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","setStipple", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXStipplePattern","setStipple", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXStipplePattern >(val2);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXDCWindow_setStipple(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDCWindow_setStipple(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 5) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 2) && (argc <= 4)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDCWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_FXDCWindow_setStipple__SWIG_0(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXDCWindow_setStipple__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_FXDCWindow_setStipple__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 2) && (argc <= 4)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDCWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_FXDCWindow_setStipple__SWIG_1(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXDCWindow_setStipple__SWIG_1(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_FXDCWindow_setStipple__SWIG_1(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 5, "setStipple", 
+    "    void setStipple(FXBitmap *bitmap, FXint dx, FXint dy)\n"
+    "    void setStipple(FXStipplePattern pat, FXint dx, FXint dy)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_setClipRegion(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","setClipRegion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setClipRegion", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setClipRegion", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXDCWindow_setClipRegion(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_setClipRectangle__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","setClipRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDCWindow_setClipRectangle(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_setClipRectangle__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXRectangle *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","setClipRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRectangle,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRectangle const &","setClipRectangle", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRectangle const &","setClipRectangle", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRectangle * >(argp2);
+  FXDCWindow_setClipRectangle(arg1,(FXRectangle const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDCWindow_setClipRectangle(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDCWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRectangle, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDCWindow_setClipRectangle__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDCWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXDCWindow_setClipRectangle__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "setClipRectangle", 
+    "    void setClipRectangle(FXint x, FXint y, FXint w, FXint h)\n"
+    "    void setClipRectangle(FXRectangle const &rectangle)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_clearClipRectangle(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","clearClipRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  FXDCWindow_clearClipRectangle(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_setClipMask(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","setClipMask", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setClipMask", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXDCWindow_setClipMask(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_clearClipMask(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","clearClipMask", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  FXDCWindow_clearClipMask(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_setFont(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  FXDCWindow_setFont(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCWindow_clipChildren(int argc, VALUE *argv, VALUE self) {
+  FXDCWindow *arg1 = (FXDCWindow *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCWindow *","clipChildren", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCWindow * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXDCWindow_clipChildren(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXPSBounds;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXPSBounds_allocate(VALUE self)
+#else
+_wrap_FXPSBounds_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXPSBounds);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXPSBounds(int argc, VALUE *argv, VALUE self) {
+  FXPSBounds *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (FXPSBounds *)new FXPSBounds();
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPSBounds_xmin_set(int argc, VALUE *argv, VALUE self) {
+  FXPSBounds *arg1 = (FXPSBounds *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPSBounds, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPSBounds *","xmin", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPSBounds * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","xmin", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->xmin = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPSBounds_xmin_get(int argc, VALUE *argv, VALUE self) {
+  FXPSBounds *arg1 = (FXPSBounds *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPSBounds, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPSBounds *","xmin", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPSBounds * >(argp1);
+  result = (FXdouble) ((arg1)->xmin);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPSBounds_xmax_set(int argc, VALUE *argv, VALUE self) {
+  FXPSBounds *arg1 = (FXPSBounds *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPSBounds, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPSBounds *","xmax", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPSBounds * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","xmax", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->xmax = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPSBounds_xmax_get(int argc, VALUE *argv, VALUE self) {
+  FXPSBounds *arg1 = (FXPSBounds *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPSBounds, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPSBounds *","xmax", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPSBounds * >(argp1);
+  result = (FXdouble) ((arg1)->xmax);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPSBounds_ymin_set(int argc, VALUE *argv, VALUE self) {
+  FXPSBounds *arg1 = (FXPSBounds *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPSBounds, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPSBounds *","ymin", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPSBounds * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","ymin", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->ymin = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPSBounds_ymin_get(int argc, VALUE *argv, VALUE self) {
+  FXPSBounds *arg1 = (FXPSBounds *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPSBounds, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPSBounds *","ymin", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPSBounds * >(argp1);
+  result = (FXdouble) ((arg1)->ymin);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPSBounds_ymax_set(int argc, VALUE *argv, VALUE self) {
+  FXPSBounds *arg1 = (FXPSBounds *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPSBounds, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPSBounds *","ymax", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPSBounds * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","ymax", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->ymax = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPSBounds_ymax_get(int argc, VALUE *argv, VALUE self) {
+  FXPSBounds *arg1 = (FXPSBounds *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPSBounds, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPSBounds *","ymax", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPSBounds * >(argp1);
+  result = (FXdouble) ((arg1)->ymax);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN void
+free_FXPSBounds(void *self) {
+    FXPSBounds *arg1 = (FXPSBounds *)self;
+    delete arg1;
+}
+
+static swig_class SwigClassFXPrinter;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXPrinter_allocate(VALUE self)
+#else
+_wrap_FXPrinter_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXPrinter);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXPrinter(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (FXPrinter *)new FXPrinter();
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_name_set(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  FXString arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","name", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  arg2 = to_FXString(argv[0]);
+  if (arg1) (arg1)->name = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_name_get(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","name", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  result =  ((arg1)->name);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_firstpage_set(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","firstpage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (arg1) (arg1)->firstpage = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_firstpage_get(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","firstpage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  result = (FXuint) ((arg1)->firstpage);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_lastpage_set(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","lastpage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (arg1) (arg1)->lastpage = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_lastpage_get(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","lastpage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  result = (FXuint) ((arg1)->lastpage);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_currentpage_set(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","currentpage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (arg1) (arg1)->currentpage = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_currentpage_get(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","currentpage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  result = (FXuint) ((arg1)->currentpage);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_frompage_set(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","frompage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (arg1) (arg1)->frompage = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_frompage_get(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","frompage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  result = (FXuint) ((arg1)->frompage);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_topage_set(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","topage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (arg1) (arg1)->topage = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_topage_get(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","topage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  result = (FXuint) ((arg1)->topage);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_mediasize_set(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","mediasize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (arg1) (arg1)->mediasize = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_mediasize_get(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","mediasize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  result = (FXuint) ((arg1)->mediasize);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_mediawidth_set(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","mediawidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","mediawidth", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->mediawidth = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_mediawidth_get(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","mediawidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  result = (FXdouble) ((arg1)->mediawidth);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_mediaheight_set(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","mediaheight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","mediaheight", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->mediaheight = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_mediaheight_get(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","mediaheight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  result = (FXdouble) ((arg1)->mediaheight);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_leftmargin_set(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","leftmargin", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","leftmargin", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->leftmargin = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_leftmargin_get(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","leftmargin", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  result = (FXdouble) ((arg1)->leftmargin);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_rightmargin_set(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","rightmargin", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","rightmargin", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->rightmargin = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_rightmargin_get(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","rightmargin", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  result = (FXdouble) ((arg1)->rightmargin);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_topmargin_set(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","topmargin", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","topmargin", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->topmargin = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_topmargin_get(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","topmargin", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  result = (FXdouble) ((arg1)->topmargin);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_bottommargin_set(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","bottommargin", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","bottommargin", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->bottommargin = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_bottommargin_get(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","bottommargin", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  result = (FXdouble) ((arg1)->bottommargin);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_numcopies_set(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","numcopies", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (arg1) (arg1)->numcopies = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_numcopies_get(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","numcopies", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  result = (FXuint) ((arg1)->numcopies);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_flags_set(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","flags", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (arg1) (arg1)->flags = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrinter_flags_get(int argc, VALUE *argv, VALUE self) {
+  FXPrinter *arg1 = (FXPrinter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrinter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrinter *","flags", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrinter * >(argp1);
+  result = (FXuint) ((arg1)->flags);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXDCPrint;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXDCPrint_allocate(VALUE self)
+#else
+_wrap_FXDCPrint_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXDCPrint);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXDCPrint(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXDCPrint *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXDCPrint", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXDCPrint *)new_FXDCPrint(arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_beginPrint(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXPrinter *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","beginPrint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXPrinter,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXPrinter &","beginPrint", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXPrinter &","beginPrint", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXPrinter * >(argp2);
+  result = (FXbool)(arg1)->beginPrint(*arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_endPrint(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","endPrint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  result = (FXbool)(arg1)->endPrint();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_beginPage(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXuint arg2 = (FXuint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","beginPage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  result = (FXbool)(arg1)->beginPage(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_endPage(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","endPage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  result = (FXbool)(arg1)->endPage();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_setContentRange(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","setContentRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  result = (FXbool)(arg1)->setContentRange(arg2,arg3,arg4,arg5);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_readPixel(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","readPixel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXColor)FXDCPrint_readPixel(arg1,arg2,arg3);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawPoint(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawPoint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDCPrint_drawPoint(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawPoints(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawPoints", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDCPrint_drawPoints(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawPointsRel(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawPointsRel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDCPrint_drawPointsRel(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawLine(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawLine", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDCPrint_drawLine(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawLines(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawLines", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDCPrint_drawLines(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawLinesRel(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawLinesRel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDCPrint_drawLinesRel(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawLineSegments(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXSegment *arg2 = (FXSegment *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawLineSegments", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXSegment[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXSegment *pSeg;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXSegment, pSeg);
+      arg2[i] = *pSeg;
+    }
+  }
+  FXDCPrint_drawLineSegments(arg1,(FXSegment const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawRectangle(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDCPrint_drawRectangle(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawRectangles(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXRectangle *arg2 = (FXRectangle *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawRectangles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXRectangle[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXRectangle *pRect;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXRectangle, pRect);
+      arg2[i] = *pRect;
+    }
+  }
+  FXDCPrint_drawRectangles(arg1,(FXRectangle const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawRoundRectangle(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawRoundRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXDCPrint_drawRoundRectangle(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawArc(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawArc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXDCPrint_drawArc(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawArcs(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXArc *arg2 = (FXArc *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawArcs", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXArc[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXArc *pArc;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXArc, pArc);
+      arg2[i] = *pArc;
+    }
+  }
+  FXDCPrint_drawArcs(arg1,(FXArc const *)arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawEllipse(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawEllipse", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDCPrint_drawEllipse(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_fillRectangle(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","fillRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDCPrint_fillRectangle(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_fillRectangles(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXRectangle *arg2 = (FXRectangle *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","fillRectangles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXRectangle[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXRectangle *pRect;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXRectangle, pRect);
+      arg2[i] = *pRect;
+    }
+  }
+  FXDCPrint_fillRectangles(arg1,(FXRectangle const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_fillRoundRectangle(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","fillRoundRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXDCPrint_fillRoundRectangle(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_fillChord(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","fillChord", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXDCPrint_fillChord(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_fillChords(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXArc *arg2 = (FXArc *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","fillChords", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXArc, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXArc const *","fillChords", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXArc * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  FXDCPrint_fillChords(arg1,(FXArc const *)arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_fillArc(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","fillArc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXDCPrint_fillArc(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_fillArcs(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXArc *arg2 = (FXArc *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","fillArcs", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXArc[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXArc *pArc;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXArc, pArc);
+      arg2[i] = *pArc;
+    }
+  }
+  FXDCPrint_fillArcs(arg1,(FXArc const *)arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_fillPolygon(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","fillPolygon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDCPrint_fillPolygon(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_fillConcavePolygon(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","fillConcavePolygon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDCPrint_fillConcavePolygon(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_fillComplexPolygon(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","fillComplexPolygon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDCPrint_fillComplexPolygon(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_fillPolygonRel(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","fillPolygonRel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDCPrint_fillPolygonRel(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_fillConcavePolygonRel(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","fillConcavePolygonRel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDCPrint_fillConcavePolygonRel(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_fillComplexPolygonRel(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXPoint *arg2 = (FXPoint *) 0 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","fillComplexPolygonRel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    arg2 = new FXPoint[RARRAY_LEN(argv[0])];
+    arg3 = static_cast<FXuint>( RARRAY_LEN(argv[0]) );
+    for (FXuint i = 0; i < arg3; i++) {
+      FXPoint *pPoint;
+      Data_Get_Struct(rb_ary_entry(argv[0], i), FXPoint, pPoint);
+      arg2[i] = *pPoint;
+    }
+  }
+  FXDCPrint_fillComplexPolygonRel(arg1,(FXPoint const *)arg2,arg3);
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg2;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawHashBox(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawHashBox", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = NUM2INT(argv[4]);
+  }
+  FXDCPrint_drawHashBox(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawFocusRectangle(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawFocusRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDCPrint_drawFocusRectangle(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawArea__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXDrawable *arg2 = (FXDrawable *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  FXint arg8 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 7) || (argc > 7)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawArea", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXDrawable, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDrawable const *","drawArea", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXDrawable * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  arg8 = NUM2INT(argv[6]);
+  FXDCPrint_drawArea(arg1,(FXDrawable const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawArea__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXDrawable *arg2 = (FXDrawable *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  FXint arg8 ;
+  FXint arg9 ;
+  FXint arg10 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 9) || (argc > 9)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawArea", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXDrawable, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDrawable const *","drawArea", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXDrawable * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  arg8 = NUM2INT(argv[6]);
+  arg9 = NUM2INT(argv[7]);
+  arg10 = NUM2INT(argv[8]);
+  FXDCPrint_drawArea(arg1,(FXDrawable const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDCPrint_drawArea(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[11];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 11) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 8) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDCPrint, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXDrawable, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    return _wrap_FXDCPrint_drawArea__SWIG_0(nargs, args, self);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if (argc == 10) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDCPrint, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXDrawable, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    {
+                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
+                    }
+                    if (_v) {
+                      {
+                        _v = (TYPE(argv[9]) == T_FIXNUM || TYPE(argv[9]) == T_BIGNUM) ? 1 : 0;
+                      }
+                      if (_v) {
+                        return _wrap_FXDCPrint_drawArea__SWIG_1(nargs, args, self);
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 11, "drawArea", 
+    "    void drawArea(FXDrawable const *source, FXint sx, FXint sy, FXint sw, FXint sh, FXint dx, FXint dy)\n"
+    "    void drawArea(FXDrawable const *source, FXint sx, FXint sy, FXint sw, FXint sh, FXint dx, FXint dy, FXint dw, FXint dh)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawImage(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXImage *arg2 = (FXImage *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawImage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXImage const *","drawImage", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXImage * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  FXDCPrint_drawImage(arg1,(FXImage const *)arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawBitmap(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawBitmap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap const *","drawBitmap", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  FXDCPrint_drawBitmap(arg1,(FXBitmap const *)arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawIcon(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon const *","drawIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  FXDCPrint_drawIcon(arg1,(FXIcon const *)arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawIconShaded(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawIconShaded", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon const *","drawIconShaded", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  FXDCPrint_drawIconShaded(arg1,(FXIcon const *)arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawIconSunken(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawIconSunken", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon const *","drawIconSunken", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  FXDCPrint_drawIconSunken(arg1,(FXIcon const *)arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawText(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXchar *arg4 = (FXchar *) 0 ;
+  FXuint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    Check_Type(argv[2], T_STRING);
+    arg4 = StringValuePtr(argv[2]);
+    arg5 = RSTRING_LEN(argv[2]);
+  }
+  FXDCPrint_drawText(arg1,arg2,arg3,(char const *)arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_drawImageText(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXchar *arg4 = (FXchar *) 0 ;
+  FXuint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","drawImageText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    Check_Type(argv[2], T_STRING);
+    arg4 = StringValuePtr(argv[2]);
+    arg5 = RSTRING_LEN(argv[2]);
+  }
+  FXDCPrint_drawImageText(arg1,arg2,arg3,(char const *)arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_setForeground(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","setForeground", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXDCPrint_setForeground(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_setBackground(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","setBackground", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXDCPrint_setBackground(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_setDashes(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXuint arg2 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  FXuint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","setDashes", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  {
+    Check_Type(argv[1], T_ARRAY);
+    arg3 = new FXchar[RARRAY_LEN(argv[1])];
+    arg4 = static_cast<FXuint>( RARRAY_LEN(argv[1]) );
+    for (FXuint i = 0; i < arg4; i++) {
+      arg3[i] = NUM2INT(rb_ary_entry(argv[1], i));
+    }
+  }
+  FXDCPrint_setDashes(arg1,arg2,(char const *)arg3,arg4);
+  {
+    delete [] arg3;
+  }
+  return Qnil;
+fail:
+  {
+    delete [] arg3;
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_setLineWidth(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXuint arg2 = (FXuint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","setLineWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  FXDCPrint_setLineWidth(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_setLineCap(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXCapStyle arg2 = (FXCapStyle) CAP_BUTT ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","setLineCap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_int(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXCapStyle","setLineCap", 2, argv[0] ));
+    } 
+    arg2 = static_cast< FXCapStyle >(val2);
+  }
+  FXDCPrint_setLineCap(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_setLineJoin(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXJoinStyle arg2 = (FXJoinStyle) JOIN_MITER ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","setLineJoin", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_int(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXJoinStyle","setLineJoin", 2, argv[0] ));
+    } 
+    arg2 = static_cast< FXJoinStyle >(val2);
+  }
+  FXDCPrint_setLineJoin(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_setLineStyle(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXLineStyle arg2 = (FXLineStyle) LINE_SOLID ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","setLineStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_int(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXLineStyle","setLineStyle", 2, argv[0] ));
+    } 
+    arg2 = static_cast< FXLineStyle >(val2);
+  }
+  FXDCPrint_setLineStyle(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_setFillStyle(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXFillStyle arg2 = (FXFillStyle) FILL_SOLID ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","setFillStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_int(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXFillStyle","setFillStyle", 2, argv[0] ));
+    } 
+    arg2 = static_cast< FXFillStyle >(val2);
+  }
+  FXDCPrint_setFillStyle(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_setFillRule(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXFillRule arg2 = (FXFillRule) RULE_EVEN_ODD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","setFillRule", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_int(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXFillRule","setFillRule", 2, argv[0] ));
+    } 
+    arg2 = static_cast< FXFillRule >(val2);
+  }
+  FXDCPrint_setFillRule(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_setFunction(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXFunction arg2 = (FXFunction) BLT_SRC ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","setFunction", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  if (argc > 0) {
+    ecode2 = SWIG_AsVal_int(argv[0], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXFunction","setFunction", 2, argv[0] ));
+    } 
+    arg2 = static_cast< FXFunction >(val2);
+  }
+  FXDCPrint_setFunction(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_setTile(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXImage *arg2 = (FXImage *) 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","setTile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXImage *","setTile", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXImage * >(argp2);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXDCPrint_setTile(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_setStipple__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","setStipple", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setStipple", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXDCPrint_setStipple(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_setStipple__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXStipplePattern arg2 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","setStipple", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXStipplePattern","setStipple", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXStipplePattern >(val2);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXDCPrint_setStipple(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDCPrint_setStipple(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 5) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 2) && (argc <= 4)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDCPrint, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_FXDCPrint_setStipple__SWIG_0(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXDCPrint_setStipple__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_FXDCPrint_setStipple__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 2) && (argc <= 4)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDCPrint, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_int(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_FXDCPrint_setStipple__SWIG_1(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXDCPrint_setStipple__SWIG_1(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_FXDCPrint_setStipple__SWIG_1(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 5, "setStipple", 
+    "    void setStipple(FXBitmap *bitmap, FXint dx, FXint dy)\n"
+    "    void setStipple(FXStipplePattern pat, FXint dx, FXint dy)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_setClipRegion(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","setClipRegion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setClipRegion", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setClipRegion", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXDCPrint_setClipRegion(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_setClipRectangle__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","setClipRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDCPrint_setClipRectangle(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_setClipRectangle__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXRectangle *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","setClipRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRectangle,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRectangle const &","setClipRectangle", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRectangle const &","setClipRectangle", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRectangle * >(argp2);
+  FXDCPrint_setClipRectangle(arg1,(FXRectangle const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDCPrint_setClipRectangle(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDCPrint, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRectangle, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDCPrint_setClipRectangle__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDCPrint, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXDCPrint_setClipRectangle__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "setClipRectangle", 
+    "    void setClipRectangle(FXint x, FXint y, FXint w, FXint h)\n"
+    "    void setClipRectangle(FXRectangle const &rectangle)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_clearClipRectangle(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","clearClipRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  FXDCPrint_clearClipRectangle(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_setClipMask(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","setClipMask", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setClipMask", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXDCPrint_setClipMask(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_clearClipMask(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","clearClipMask", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  FXDCPrint_clearClipMask(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_setFont(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  FXDCPrint_setFont(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDCPrint_clipChildren(int argc, VALUE *argv, VALUE self) {
+  FXDCPrint *arg1 = (FXDCPrint *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDCPrint, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDCPrint *","clipChildren", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDCPrint * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXDCPrint_clipChildren(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_FXCompositeTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *)  ((FXWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXPopupTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXTopWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FXDCPrintTo_p_FXDC(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDC *)  ((FXDCPrint *) x));
+}
+static void *_p_FXDCWindowTo_p_FXDC(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDC *)  ((FXDCWindow *) x));
+}
+static swig_type_info _swigt__p_FXApp = {"_p_FXApp", "FXApp *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXArc = {"_p_FXArc", "FXArc *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXBitmap = {"_p_FXBitmap", "FXBitmap *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDC = {"_p_FXDC", "FXDC *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDCPrint = {"_p_FXDCPrint", "FXDCPrint *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDCWindow = {"_p_FXDCWindow", "FXDCWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDrawable = {"_p_FXDrawable", "FXDrawable *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXComposite = {"_p_FXComposite", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShell = {"_p_FXShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXWindow = {"_p_FXWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRootWindow = {"_p_FXRootWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPopup = {"_p_FXPopup", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTopWindow = {"_p_FXTopWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMainWindow = {"_p_FXMainWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplashWindow = {"_p_FXSplashWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFrame = {"_p_FXFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXEvent = {"_p_FXEvent", "FXEvent *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFont = {"_p_FXFont", "FXFont *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXIcon = {"_p_FXIcon", "FXIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXImage = {"_p_FXImage", "FXImage *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXPSBounds = {"_p_FXPSBounds", "FXPSBounds *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXPrinter = {"_p_FXPrinter", "FXPrinter *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRectangle = {"_p_FXRectangle", "FXRectangle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRegion = {"_p_FXRegion", "FXRegion *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXSegment = {"_p_FXSegment", "FXSegment *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXString = {"_p_FXString", "FXString *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_char = {"_p_char", "char *|FXchar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "double *|FXdouble *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_float = {"_p_float", "float *|FXfloat *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "FXint *|int *|FXInputHandle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_long = {"_p_long", "long *|FXTime *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_short = {"_p_short", "short *|FXshort *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "FXuchar *|unsigned char *|FXbool *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "FXwchar *|FXDragType *|unsigned int *|FXuint *|FXColor *|FXSelector *|FXHotKey *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|FXuval *|FXPixel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|FXushort *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_FXApp,
+  &_swigt__p_FXArc,
+  &_swigt__p_FXBitmap,
+  &_swigt__p_FXComposite,
+  &_swigt__p_FXDC,
+  &_swigt__p_FXDCPrint,
+  &_swigt__p_FXDCWindow,
+  &_swigt__p_FXDrawable,
+  &_swigt__p_FXEvent,
+  &_swigt__p_FXFont,
+  &_swigt__p_FXFrame,
+  &_swigt__p_FXIcon,
+  &_swigt__p_FXImage,
+  &_swigt__p_FXMainWindow,
+  &_swigt__p_FXPSBounds,
+  &_swigt__p_FXPopup,
+  &_swigt__p_FXPrinter,
+  &_swigt__p_FXRectangle,
+  &_swigt__p_FXRegion,
+  &_swigt__p_FXRootWindow,
+  &_swigt__p_FXSegment,
+  &_swigt__p_FXShell,
+  &_swigt__p_FXSplashWindow,
+  &_swigt__p_FXString,
+  &_swigt__p_FXTopWindow,
+  &_swigt__p_FXWindow,
+  &_swigt__p_char,
+  &_swigt__p_double,
+  &_swigt__p_float,
+  &_swigt__p_int,
+  &_swigt__p_long,
+  &_swigt__p_short,
+  &_swigt__p_unsigned_char,
+  &_swigt__p_unsigned_int,
+  &_swigt__p_unsigned_long,
+  &_swigt__p_unsigned_short,
+};
+
+static swig_cast_info _swigc__p_FXApp[] = {  {&_swigt__p_FXApp, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXArc[] = {  {&_swigt__p_FXArc, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBitmap[] = {  {&_swigt__p_FXBitmap, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDC[] = {  {&_swigt__p_FXDCPrint, _p_FXDCPrintTo_p_FXDC, 0, 0},  {&_swigt__p_FXDC, 0, 0, 0},  {&_swigt__p_FXDCWindow, _p_FXDCWindowTo_p_FXDC, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDCPrint[] = {  {&_swigt__p_FXDCPrint, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDCWindow[] = {  {&_swigt__p_FXDCWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComposite[] = {{&_swigt__p_FXComposite, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShell[] = {{&_swigt__p_FXShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXWindow[] = {{&_swigt__p_FXWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRootWindow[] = {{&_swigt__p_FXRootWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPopup[] = {{&_swigt__p_FXPopup, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTopWindow[] = {{&_swigt__p_FXTopWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMainWindow[] = {{&_swigt__p_FXMainWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplashWindow[] = {{&_swigt__p_FXSplashWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFrame[] = {{&_swigt__p_FXFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDrawable[] = {  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDrawable, 0, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXDrawable, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXEvent[] = {  {&_swigt__p_FXEvent, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFont[] = {  {&_swigt__p_FXFont, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIcon[] = {  {&_swigt__p_FXIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImage[] = {  {&_swigt__p_FXImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPSBounds[] = {  {&_swigt__p_FXPSBounds, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPrinter[] = {  {&_swigt__p_FXPrinter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRectangle[] = {  {&_swigt__p_FXRectangle, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegion[] = {  {&_swigt__p_FXRegion, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSegment[] = {  {&_swigt__p_FXSegment, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXString[] = {  {&_swigt__p_FXString, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
+
+static swig_cast_info *swig_cast_initial[] = {
+  _swigc__p_FXApp,
+  _swigc__p_FXArc,
+  _swigc__p_FXBitmap,
+  _swigc__p_FXComposite,
+  _swigc__p_FXDC,
+  _swigc__p_FXDCPrint,
+  _swigc__p_FXDCWindow,
+  _swigc__p_FXDrawable,
+  _swigc__p_FXEvent,
+  _swigc__p_FXFont,
+  _swigc__p_FXFrame,
+  _swigc__p_FXIcon,
+  _swigc__p_FXImage,
+  _swigc__p_FXMainWindow,
+  _swigc__p_FXPSBounds,
+  _swigc__p_FXPopup,
+  _swigc__p_FXPrinter,
+  _swigc__p_FXRectangle,
+  _swigc__p_FXRegion,
+  _swigc__p_FXRootWindow,
+  _swigc__p_FXSegment,
+  _swigc__p_FXShell,
+  _swigc__p_FXSplashWindow,
+  _swigc__p_FXString,
+  _swigc__p_FXTopWindow,
+  _swigc__p_FXWindow,
+  _swigc__p_char,
+  _swigc__p_double,
+  _swigc__p_float,
+  _swigc__p_int,
+  _swigc__p_long,
+  _swigc__p_short,
+  _swigc__p_unsigned_char,
+  _swigc__p_unsigned_int,
+  _swigc__p_unsigned_long,
+  _swigc__p_unsigned_short,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned statically to an initial
+ * array. We just loop through that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded.
+ * There are three cases to handle:
+ *  1) If the cast->type has already been loaded AND the type we are adding
+ *     casting info to has not been loaded (it is in this module), THEN we
+ *     replace the cast->type pointer with the type pointer that has already
+ *     been loaded.
+ *  2) If BOTH types (the one we are adding casting info to, and the
+ *     cast->type) are loaded, THEN the cast info has already been loaded by
+ *     the previous module so we just ignore it.
+ *  3) Finally, if cast->type has not already been loaded, then we add that
+ *     swig_cast_info to the linked list (because the cast->type) pointer will
+ *     be correct.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* c-mode */
+#endif
+#endif
+
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+  size_t i;
+  swig_module_info *module_head, *iter;
+  int init;
+
+  /* check to see if the circular list has been setup, if not, set it up */
+  if (swig_module.next==0) {
+    /* Initialize the swig_module */
+    swig_module.type_initial = swig_type_initial;
+    swig_module.cast_initial = swig_cast_initial;
+    swig_module.next = &swig_module;
+    init = 1;
+  } else {
+    init = 0;
+  }
+
+  /* Try and load any already created modules */
+  module_head = SWIG_GetModule(clientdata);
+  if (!module_head) {
+    /* This is the first module loaded for this interpreter */
+    /* so set the swig module into the interpreter */
+    SWIG_SetModule(clientdata, &swig_module);
+  } else {
+    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+    iter=module_head;
+    do {
+      if (iter==&swig_module) {
+        /* Our module is already in the list, so there's nothing more to do. */
+        return;
+      }
+      iter=iter->next;
+    } while (iter!= module_head);
+
+    /* otherwise we must add our module into the list */
+    swig_module.next = module_head->next;
+    module_head->next = &swig_module;
+  }
+
+  /* When multiple interpreters are used, a module could have already been initialized in
+     a different interpreter, but not yet have a pointer in this interpreter.
+     In this case, we do not want to continue adding types... everything should be
+     set up already */
+  if (init == 0) return;
+
+  /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+  for (i = 0; i < swig_module.size; ++i) {
+    swig_type_info *type = 0;
+    swig_type_info *ret;
+    swig_cast_info *cast;
+
+#ifdef SWIGRUNTIME_DEBUG
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+
+    /* if there is another module already loaded */
+    if (swig_module.next != &swig_module) {
+      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
+    }
+    if (type) {
+      /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+      if (swig_module.type_initial[i]->clientdata) {
+	type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+      }
+    } else {
+      type = swig_module.type_initial[i];
+    }
+
+    /* Insert casting types */
+    cast = swig_module.cast_initial[i];
+    while (cast->type) {
+
+      /* Don't need to add information already in the list */
+      ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+      if (swig_module.next != &swig_module) {
+        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+      }
+      if (ret) {
+	if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+	  cast->type = ret;
+	  ret = 0;
+	} else {
+	  /* Check for casting already in the list */
+	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+	  if (!ocast) ret = 0;
+	}
+      }
+
+      if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+        if (type->cast) {
+          type->cast->prev = cast;
+          cast->next = type->cast;
+        }
+        type->cast = cast;
+      }
+      cast++;
+    }
+    /* Set entry in modules->types array equal to the type */
+    swig_module.types[i] = type;
+  }
+  swig_module.types[i] = 0;
+
+#ifdef SWIGRUNTIME_DEBUG
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+  for (i = 0; i < swig_module.size; ++i) {
+    int j = 0;
+    swig_cast_info *cast = swig_module.cast_initial[i];
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    while (cast->type) {
+      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+      cast++;
+      ++j;
+    }
+  printf("---- Total casts: %d\n",j);
+  }
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types.  It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+  size_t i;
+  swig_cast_info *equiv;
+  static int init_run = 0;
+
+  if (init_run) return;
+  init_run = 1;
+
+  for (i = 0; i < swig_module.size; i++) {
+    if (swig_module.types[i]->clientdata) {
+      equiv = swig_module.types[i]->cast;
+      while (equiv) {
+        if (!equiv->converter) {
+          if (equiv->type && !equiv->type->clientdata)
+            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+        }
+        equiv = equiv->next;
+      }
+    }
+  }
+}
+
+#ifdef __cplusplus
+#if 0
+{ /* c-mode */
+#endif
+}
+#endif
+
+/*
+
+*/
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void Init_dc(void) {
+  size_t i;
+  
+  SWIG_InitRuntime();
+  
+  
+  SWIG_InitializeModule(0);
+  for (i = 0; i < swig_module.size; i++) {
+    SWIG_define_class(swig_module.types[i]);
+  }
+  
+  SWIG_RubyInitializeTrackings();
+  
+  rb_define_const(mFox, "BLT_CLR", SWIG_From_int(static_cast< int >(BLT_CLR)));
+  rb_define_const(mFox, "BLT_SRC_AND_DST", SWIG_From_int(static_cast< int >(BLT_SRC_AND_DST)));
+  rb_define_const(mFox, "BLT_SRC_AND_NOT_DST", SWIG_From_int(static_cast< int >(BLT_SRC_AND_NOT_DST)));
+  rb_define_const(mFox, "BLT_SRC", SWIG_From_int(static_cast< int >(BLT_SRC)));
+  rb_define_const(mFox, "BLT_NOT_SRC_AND_DST", SWIG_From_int(static_cast< int >(BLT_NOT_SRC_AND_DST)));
+  rb_define_const(mFox, "BLT_DST", SWIG_From_int(static_cast< int >(BLT_DST)));
+  rb_define_const(mFox, "BLT_SRC_XOR_DST", SWIG_From_int(static_cast< int >(BLT_SRC_XOR_DST)));
+  rb_define_const(mFox, "BLT_SRC_OR_DST", SWIG_From_int(static_cast< int >(BLT_SRC_OR_DST)));
+  rb_define_const(mFox, "BLT_NOT_SRC_AND_NOT_DST", SWIG_From_int(static_cast< int >(BLT_NOT_SRC_AND_NOT_DST)));
+  rb_define_const(mFox, "BLT_NOT_SRC_XOR_DST", SWIG_From_int(static_cast< int >(BLT_NOT_SRC_XOR_DST)));
+  rb_define_const(mFox, "BLT_NOT_DST", SWIG_From_int(static_cast< int >(BLT_NOT_DST)));
+  rb_define_const(mFox, "BLT_SRC_OR_NOT_DST", SWIG_From_int(static_cast< int >(BLT_SRC_OR_NOT_DST)));
+  rb_define_const(mFox, "BLT_NOT_SRC", SWIG_From_int(static_cast< int >(BLT_NOT_SRC)));
+  rb_define_const(mFox, "BLT_NOT_SRC_OR_DST", SWIG_From_int(static_cast< int >(BLT_NOT_SRC_OR_DST)));
+  rb_define_const(mFox, "BLT_NOT_SRC_OR_NOT_DST", SWIG_From_int(static_cast< int >(BLT_NOT_SRC_OR_NOT_DST)));
+  rb_define_const(mFox, "BLT_SET", SWIG_From_int(static_cast< int >(BLT_SET)));
+  rb_define_const(mFox, "LINE_SOLID", SWIG_From_int(static_cast< int >(LINE_SOLID)));
+  rb_define_const(mFox, "LINE_ONOFF_DASH", SWIG_From_int(static_cast< int >(LINE_ONOFF_DASH)));
+  rb_define_const(mFox, "LINE_DOUBLE_DASH", SWIG_From_int(static_cast< int >(LINE_DOUBLE_DASH)));
+  rb_define_const(mFox, "CAP_NOT_LAST", SWIG_From_int(static_cast< int >(CAP_NOT_LAST)));
+  rb_define_const(mFox, "CAP_BUTT", SWIG_From_int(static_cast< int >(CAP_BUTT)));
+  rb_define_const(mFox, "CAP_ROUND", SWIG_From_int(static_cast< int >(CAP_ROUND)));
+  rb_define_const(mFox, "CAP_PROJECTING", SWIG_From_int(static_cast< int >(CAP_PROJECTING)));
+  rb_define_const(mFox, "JOIN_MITER", SWIG_From_int(static_cast< int >(JOIN_MITER)));
+  rb_define_const(mFox, "JOIN_ROUND", SWIG_From_int(static_cast< int >(JOIN_ROUND)));
+  rb_define_const(mFox, "JOIN_BEVEL", SWIG_From_int(static_cast< int >(JOIN_BEVEL)));
+  rb_define_const(mFox, "FILL_SOLID", SWIG_From_int(static_cast< int >(FILL_SOLID)));
+  rb_define_const(mFox, "FILL_TILED", SWIG_From_int(static_cast< int >(FILL_TILED)));
+  rb_define_const(mFox, "FILL_STIPPLED", SWIG_From_int(static_cast< int >(FILL_STIPPLED)));
+  rb_define_const(mFox, "FILL_OPAQUESTIPPLED", SWIG_From_int(static_cast< int >(FILL_OPAQUESTIPPLED)));
+  rb_define_const(mFox, "RULE_EVEN_ODD", SWIG_From_int(static_cast< int >(RULE_EVEN_ODD)));
+  rb_define_const(mFox, "RULE_WINDING", SWIG_From_int(static_cast< int >(RULE_WINDING)));
+  rb_define_const(mFox, "STIPPLE_0", SWIG_From_int(static_cast< int >(STIPPLE_0)));
+  rb_define_const(mFox, "STIPPLE_NONE", SWIG_From_int(static_cast< int >(STIPPLE_NONE)));
+  rb_define_const(mFox, "STIPPLE_BLACK", SWIG_From_int(static_cast< int >(STIPPLE_BLACK)));
+  rb_define_const(mFox, "STIPPLE_1", SWIG_From_int(static_cast< int >(STIPPLE_1)));
+  rb_define_const(mFox, "STIPPLE_2", SWIG_From_int(static_cast< int >(STIPPLE_2)));
+  rb_define_const(mFox, "STIPPLE_3", SWIG_From_int(static_cast< int >(STIPPLE_3)));
+  rb_define_const(mFox, "STIPPLE_4", SWIG_From_int(static_cast< int >(STIPPLE_4)));
+  rb_define_const(mFox, "STIPPLE_5", SWIG_From_int(static_cast< int >(STIPPLE_5)));
+  rb_define_const(mFox, "STIPPLE_6", SWIG_From_int(static_cast< int >(STIPPLE_6)));
+  rb_define_const(mFox, "STIPPLE_7", SWIG_From_int(static_cast< int >(STIPPLE_7)));
+  rb_define_const(mFox, "STIPPLE_8", SWIG_From_int(static_cast< int >(STIPPLE_8)));
+  rb_define_const(mFox, "STIPPLE_GRAY", SWIG_From_int(static_cast< int >(STIPPLE_GRAY)));
+  rb_define_const(mFox, "STIPPLE_9", SWIG_From_int(static_cast< int >(STIPPLE_9)));
+  rb_define_const(mFox, "STIPPLE_10", SWIG_From_int(static_cast< int >(STIPPLE_10)));
+  rb_define_const(mFox, "STIPPLE_11", SWIG_From_int(static_cast< int >(STIPPLE_11)));
+  rb_define_const(mFox, "STIPPLE_12", SWIG_From_int(static_cast< int >(STIPPLE_12)));
+  rb_define_const(mFox, "STIPPLE_13", SWIG_From_int(static_cast< int >(STIPPLE_13)));
+  rb_define_const(mFox, "STIPPLE_14", SWIG_From_int(static_cast< int >(STIPPLE_14)));
+  rb_define_const(mFox, "STIPPLE_15", SWIG_From_int(static_cast< int >(STIPPLE_15)));
+  rb_define_const(mFox, "STIPPLE_16", SWIG_From_int(static_cast< int >(STIPPLE_16)));
+  rb_define_const(mFox, "STIPPLE_WHITE", SWIG_From_int(static_cast< int >(STIPPLE_WHITE)));
+  rb_define_const(mFox, "STIPPLE_HORZ", SWIG_From_int(static_cast< int >(STIPPLE_HORZ)));
+  rb_define_const(mFox, "STIPPLE_VERT", SWIG_From_int(static_cast< int >(STIPPLE_VERT)));
+  rb_define_const(mFox, "STIPPLE_CROSS", SWIG_From_int(static_cast< int >(STIPPLE_CROSS)));
+  rb_define_const(mFox, "STIPPLE_DIAG", SWIG_From_int(static_cast< int >(STIPPLE_DIAG)));
+  rb_define_const(mFox, "STIPPLE_REVDIAG", SWIG_From_int(static_cast< int >(STIPPLE_REVDIAG)));
+  rb_define_const(mFox, "STIPPLE_CROSSDIAG", SWIG_From_int(static_cast< int >(STIPPLE_CROSSDIAG)));
+  
+  SwigClassFXSegment.klass = rb_define_class_under(mFox, "FXSegment", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXSegment, (void *) &SwigClassFXSegment);
+  rb_define_alloc_func(SwigClassFXSegment.klass, _wrap_FXSegment_allocate);
+  rb_define_method(SwigClassFXSegment.klass, "initialize", VALUEFUNC(_wrap_new_FXSegment), -1);
+  rb_define_method(SwigClassFXSegment.klass, "x1=", VALUEFUNC(_wrap_FXSegment_x1_set), -1);
+  rb_define_method(SwigClassFXSegment.klass, "x1", VALUEFUNC(_wrap_FXSegment_x1_get), -1);
+  rb_define_method(SwigClassFXSegment.klass, "y1=", VALUEFUNC(_wrap_FXSegment_y1_set), -1);
+  rb_define_method(SwigClassFXSegment.klass, "y1", VALUEFUNC(_wrap_FXSegment_y1_get), -1);
+  rb_define_method(SwigClassFXSegment.klass, "x2=", VALUEFUNC(_wrap_FXSegment_x2_set), -1);
+  rb_define_method(SwigClassFXSegment.klass, "x2", VALUEFUNC(_wrap_FXSegment_x2_get), -1);
+  rb_define_method(SwigClassFXSegment.klass, "y2=", VALUEFUNC(_wrap_FXSegment_y2_set), -1);
+  rb_define_method(SwigClassFXSegment.klass, "y2", VALUEFUNC(_wrap_FXSegment_y2_get), -1);
+  SwigClassFXSegment.mark = 0;
+  SwigClassFXSegment.destroy = (void (*)(void *)) free_FXSegment;
+  SwigClassFXSegment.trackObjects = 0;
+  
+  SwigClassFXArc.klass = rb_define_class_under(mFox, "FXArc", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXArc, (void *) &SwigClassFXArc);
+  rb_define_alloc_func(SwigClassFXArc.klass, _wrap_FXArc_allocate);
+  rb_define_method(SwigClassFXArc.klass, "initialize", VALUEFUNC(_wrap_new_FXArc), -1);
+  rb_define_method(SwigClassFXArc.klass, "x=", VALUEFUNC(_wrap_FXArc_x_set), -1);
+  rb_define_method(SwigClassFXArc.klass, "x", VALUEFUNC(_wrap_FXArc_x_get), -1);
+  rb_define_method(SwigClassFXArc.klass, "y=", VALUEFUNC(_wrap_FXArc_y_set), -1);
+  rb_define_method(SwigClassFXArc.klass, "y", VALUEFUNC(_wrap_FXArc_y_get), -1);
+  rb_define_method(SwigClassFXArc.klass, "w=", VALUEFUNC(_wrap_FXArc_w_set), -1);
+  rb_define_method(SwigClassFXArc.klass, "w", VALUEFUNC(_wrap_FXArc_w_get), -1);
+  rb_define_method(SwigClassFXArc.klass, "h=", VALUEFUNC(_wrap_FXArc_h_set), -1);
+  rb_define_method(SwigClassFXArc.klass, "h", VALUEFUNC(_wrap_FXArc_h_get), -1);
+  rb_define_method(SwigClassFXArc.klass, "a=", VALUEFUNC(_wrap_FXArc_a_set), -1);
+  rb_define_method(SwigClassFXArc.klass, "a", VALUEFUNC(_wrap_FXArc_a_get), -1);
+  rb_define_method(SwigClassFXArc.klass, "b=", VALUEFUNC(_wrap_FXArc_b_set), -1);
+  rb_define_method(SwigClassFXArc.klass, "b", VALUEFUNC(_wrap_FXArc_b_get), -1);
+  SwigClassFXArc.mark = 0;
+  SwigClassFXArc.destroy = (void (*)(void *)) free_FXArc;
+  SwigClassFXArc.trackObjects = 0;
+  
+  SwigClassFXDC.klass = rb_define_class_under(mFox, "FXDC", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXDC, (void *) &SwigClassFXDC);
+  rb_define_alloc_func(SwigClassFXDC.klass, _wrap_FXDC_allocate);
+  rb_define_method(SwigClassFXDC.klass, "initialize", VALUEFUNC(_wrap_new_FXDC), -1);
+  rb_define_method(SwigClassFXDC.klass, "getApp", VALUEFUNC(_wrap_FXDC_getApp), -1);
+  rb_define_method(SwigClassFXDC.klass, "getForeground", VALUEFUNC(_wrap_FXDC_getForeground), -1);
+  rb_define_method(SwigClassFXDC.klass, "getBackground", VALUEFUNC(_wrap_FXDC_getBackground), -1);
+  rb_define_method(SwigClassFXDC.klass, "getDashPattern", VALUEFUNC(_wrap_FXDC_getDashPattern), -1);
+  rb_define_method(SwigClassFXDC.klass, "getDashOffset", VALUEFUNC(_wrap_FXDC_getDashOffset), -1);
+  rb_define_method(SwigClassFXDC.klass, "getLineWidth", VALUEFUNC(_wrap_FXDC_getLineWidth), -1);
+  rb_define_method(SwigClassFXDC.klass, "getLineCap", VALUEFUNC(_wrap_FXDC_getLineCap), -1);
+  rb_define_method(SwigClassFXDC.klass, "getLineJoin", VALUEFUNC(_wrap_FXDC_getLineJoin), -1);
+  rb_define_method(SwigClassFXDC.klass, "getLineStyle", VALUEFUNC(_wrap_FXDC_getLineStyle), -1);
+  rb_define_method(SwigClassFXDC.klass, "getFillStyle", VALUEFUNC(_wrap_FXDC_getFillStyle), -1);
+  rb_define_method(SwigClassFXDC.klass, "getFillRule", VALUEFUNC(_wrap_FXDC_getFillRule), -1);
+  rb_define_method(SwigClassFXDC.klass, "getFunction", VALUEFUNC(_wrap_FXDC_getFunction), -1);
+  rb_define_method(SwigClassFXDC.klass, "getTile", VALUEFUNC(_wrap_FXDC_getTile), -1);
+  rb_define_method(SwigClassFXDC.klass, "getStippleBitmap", VALUEFUNC(_wrap_FXDC_getStippleBitmap), -1);
+  rb_define_method(SwigClassFXDC.klass, "getStipplePattern", VALUEFUNC(_wrap_FXDC_getStipplePattern), -1);
+  rb_define_method(SwigClassFXDC.klass, "getClipRectangle", VALUEFUNC(_wrap_FXDC_getClipRectangle), -1);
+  rb_define_method(SwigClassFXDC.klass, "getClipX", VALUEFUNC(_wrap_FXDC_getClipX), -1);
+  rb_define_method(SwigClassFXDC.klass, "getClipY", VALUEFUNC(_wrap_FXDC_getClipY), -1);
+  rb_define_method(SwigClassFXDC.klass, "getClipWidth", VALUEFUNC(_wrap_FXDC_getClipWidth), -1);
+  rb_define_method(SwigClassFXDC.klass, "getClipHeight", VALUEFUNC(_wrap_FXDC_getClipHeight), -1);
+  rb_define_method(SwigClassFXDC.klass, "getFont", VALUEFUNC(_wrap_FXDC_getFont), -1);
+  rb_define_method(SwigClassFXDC.klass, "readPixel", VALUEFUNC(_wrap_FXDC_readPixel), -1);
+  rb_define_method(SwigClassFXDC.klass, "drawPoint", VALUEFUNC(_wrap_FXDC_drawPoint), -1);
+  rb_define_method(SwigClassFXDC.klass, "drawPoints", VALUEFUNC(_wrap_FXDC_drawPoints), -1);
+  rb_define_method(SwigClassFXDC.klass, "drawPointsRel", VALUEFUNC(_wrap_FXDC_drawPointsRel), -1);
+  rb_define_method(SwigClassFXDC.klass, "drawLine", VALUEFUNC(_wrap_FXDC_drawLine), -1);
+  rb_define_method(SwigClassFXDC.klass, "drawLines", VALUEFUNC(_wrap_FXDC_drawLines), -1);
+  rb_define_method(SwigClassFXDC.klass, "drawLinesRel", VALUEFUNC(_wrap_FXDC_drawLinesRel), -1);
+  rb_define_method(SwigClassFXDC.klass, "drawLineSegments", VALUEFUNC(_wrap_FXDC_drawLineSegments), -1);
+  rb_define_method(SwigClassFXDC.klass, "drawRectangle", VALUEFUNC(_wrap_FXDC_drawRectangle), -1);
+  rb_define_method(SwigClassFXDC.klass, "drawRectangles", VALUEFUNC(_wrap_FXDC_drawRectangles), -1);
+  rb_define_method(SwigClassFXDC.klass, "drawRoundRectangle", VALUEFUNC(_wrap_FXDC_drawRoundRectangle), -1);
+  rb_define_method(SwigClassFXDC.klass, "drawArc", VALUEFUNC(_wrap_FXDC_drawArc), -1);
+  rb_define_method(SwigClassFXDC.klass, "drawArcs", VALUEFUNC(_wrap_FXDC_drawArcs), -1);
+  rb_define_method(SwigClassFXDC.klass, "drawEllipse", VALUEFUNC(_wrap_FXDC_drawEllipse), -1);
+  rb_define_method(SwigClassFXDC.klass, "fillRectangle", VALUEFUNC(_wrap_FXDC_fillRectangle), -1);
+  rb_define_method(SwigClassFXDC.klass, "fillRectangles", VALUEFUNC(_wrap_FXDC_fillRectangles), -1);
+  rb_define_method(SwigClassFXDC.klass, "fillRoundRectangle", VALUEFUNC(_wrap_FXDC_fillRoundRectangle), -1);
+  rb_define_method(SwigClassFXDC.klass, "fillChord", VALUEFUNC(_wrap_FXDC_fillChord), -1);
+  rb_define_method(SwigClassFXDC.klass, "fillChords", VALUEFUNC(_wrap_FXDC_fillChords), -1);
+  rb_define_method(SwigClassFXDC.klass, "fillArc", VALUEFUNC(_wrap_FXDC_fillArc), -1);
+  rb_define_method(SwigClassFXDC.klass, "fillArcs", VALUEFUNC(_wrap_FXDC_fillArcs), -1);
+  rb_define_method(SwigClassFXDC.klass, "fillPolygon", VALUEFUNC(_wrap_FXDC_fillPolygon), -1);
+  rb_define_method(SwigClassFXDC.klass, "fillConcavePolygon", VALUEFUNC(_wrap_FXDC_fillConcavePolygon), -1);
+  rb_define_method(SwigClassFXDC.klass, "fillComplexPolygon", VALUEFUNC(_wrap_FXDC_fillComplexPolygon), -1);
+  rb_define_method(SwigClassFXDC.klass, "fillPolygonRel", VALUEFUNC(_wrap_FXDC_fillPolygonRel), -1);
+  rb_define_method(SwigClassFXDC.klass, "fillConcavePolygonRel", VALUEFUNC(_wrap_FXDC_fillConcavePolygonRel), -1);
+  rb_define_method(SwigClassFXDC.klass, "fillComplexPolygonRel", VALUEFUNC(_wrap_FXDC_fillComplexPolygonRel), -1);
+  rb_define_method(SwigClassFXDC.klass, "drawHashBox", VALUEFUNC(_wrap_FXDC_drawHashBox), -1);
+  rb_define_method(SwigClassFXDC.klass, "drawFocusRectangle", VALUEFUNC(_wrap_FXDC_drawFocusRectangle), -1);
+  rb_define_method(SwigClassFXDC.klass, "drawArea", VALUEFUNC(_wrap_FXDC_drawArea), -1);
+  rb_define_method(SwigClassFXDC.klass, "drawImage", VALUEFUNC(_wrap_FXDC_drawImage), -1);
+  rb_define_method(SwigClassFXDC.klass, "drawBitmap", VALUEFUNC(_wrap_FXDC_drawBitmap), -1);
+  rb_define_method(SwigClassFXDC.klass, "drawIcon", VALUEFUNC(_wrap_FXDC_drawIcon), -1);
+  rb_define_method(SwigClassFXDC.klass, "drawIconShaded", VALUEFUNC(_wrap_FXDC_drawIconShaded), -1);
+  rb_define_method(SwigClassFXDC.klass, "drawIconSunken", VALUEFUNC(_wrap_FXDC_drawIconSunken), -1);
+  rb_define_method(SwigClassFXDC.klass, "drawText", VALUEFUNC(_wrap_FXDC_drawText), -1);
+  rb_define_method(SwigClassFXDC.klass, "drawImageText", VALUEFUNC(_wrap_FXDC_drawImageText), -1);
+  rb_define_method(SwigClassFXDC.klass, "setForeground", VALUEFUNC(_wrap_FXDC_setForeground), -1);
+  rb_define_method(SwigClassFXDC.klass, "setBackground", VALUEFUNC(_wrap_FXDC_setBackground), -1);
+  rb_define_method(SwigClassFXDC.klass, "setDashes", VALUEFUNC(_wrap_FXDC_setDashes), -1);
+  rb_define_method(SwigClassFXDC.klass, "setLineWidth", VALUEFUNC(_wrap_FXDC_setLineWidth), -1);
+  rb_define_method(SwigClassFXDC.klass, "setLineCap", VALUEFUNC(_wrap_FXDC_setLineCap), -1);
+  rb_define_method(SwigClassFXDC.klass, "setLineJoin", VALUEFUNC(_wrap_FXDC_setLineJoin), -1);
+  rb_define_method(SwigClassFXDC.klass, "setLineStyle", VALUEFUNC(_wrap_FXDC_setLineStyle), -1);
+  rb_define_method(SwigClassFXDC.klass, "setFillStyle", VALUEFUNC(_wrap_FXDC_setFillStyle), -1);
+  rb_define_method(SwigClassFXDC.klass, "setFillRule", VALUEFUNC(_wrap_FXDC_setFillRule), -1);
+  rb_define_method(SwigClassFXDC.klass, "setFunction", VALUEFUNC(_wrap_FXDC_setFunction), -1);
+  rb_define_method(SwigClassFXDC.klass, "setTile", VALUEFUNC(_wrap_FXDC_setTile), -1);
+  rb_define_method(SwigClassFXDC.klass, "setStipple", VALUEFUNC(_wrap_FXDC_setStipple), -1);
+  rb_define_method(SwigClassFXDC.klass, "setClipRegion", VALUEFUNC(_wrap_FXDC_setClipRegion), -1);
+  rb_define_method(SwigClassFXDC.klass, "setClipRectangle", VALUEFUNC(_wrap_FXDC_setClipRectangle), -1);
+  rb_define_method(SwigClassFXDC.klass, "clearClipRectangle", VALUEFUNC(_wrap_FXDC_clearClipRectangle), -1);
+  rb_define_method(SwigClassFXDC.klass, "setClipMask", VALUEFUNC(_wrap_FXDC_setClipMask), -1);
+  rb_define_method(SwigClassFXDC.klass, "clearClipMask", VALUEFUNC(_wrap_FXDC_clearClipMask), -1);
+  rb_define_method(SwigClassFXDC.klass, "setFont", VALUEFUNC(_wrap_FXDC_setFont), -1);
+  rb_define_method(SwigClassFXDC.klass, "clipChildren", VALUEFUNC(_wrap_FXDC_clipChildren), -1);
+  SwigClassFXDC.mark = (void (*)(void *)) FXRbDC::markfunc;
+  SwigClassFXDC.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXDC.trackObjects = 0;
+  
+  SwigClassFXDCWindow.klass = rb_define_class_under(mFox, "FXDCWindow", ((swig_class *) SWIGTYPE_p_FXDC->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXDCWindow, (void *) &SwigClassFXDCWindow);
+  rb_define_alloc_func(SwigClassFXDCWindow.klass, _wrap_FXDCWindow_allocate);
+  rb_define_method(SwigClassFXDCWindow.klass, "initialize", VALUEFUNC(_wrap_new_FXDCWindow), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "begin", VALUEFUNC(_wrap_FXDCWindow_begin), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "end", VALUEFUNC(_wrap_FXDCWindow_end), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "readPixel", VALUEFUNC(_wrap_FXDCWindow_readPixel), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "drawPoint", VALUEFUNC(_wrap_FXDCWindow_drawPoint), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "drawPoints", VALUEFUNC(_wrap_FXDCWindow_drawPoints), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "drawPointsRel", VALUEFUNC(_wrap_FXDCWindow_drawPointsRel), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "drawLine", VALUEFUNC(_wrap_FXDCWindow_drawLine), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "drawLines", VALUEFUNC(_wrap_FXDCWindow_drawLines), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "drawLinesRel", VALUEFUNC(_wrap_FXDCWindow_drawLinesRel), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "drawLineSegments", VALUEFUNC(_wrap_FXDCWindow_drawLineSegments), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "drawRectangle", VALUEFUNC(_wrap_FXDCWindow_drawRectangle), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "drawRectangles", VALUEFUNC(_wrap_FXDCWindow_drawRectangles), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "drawRoundRectangle", VALUEFUNC(_wrap_FXDCWindow_drawRoundRectangle), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "drawArc", VALUEFUNC(_wrap_FXDCWindow_drawArc), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "drawArcs", VALUEFUNC(_wrap_FXDCWindow_drawArcs), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "drawEllipse", VALUEFUNC(_wrap_FXDCWindow_drawEllipse), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "fillRectangle", VALUEFUNC(_wrap_FXDCWindow_fillRectangle), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "fillRectangles", VALUEFUNC(_wrap_FXDCWindow_fillRectangles), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "fillRoundRectangle", VALUEFUNC(_wrap_FXDCWindow_fillRoundRectangle), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "fillChord", VALUEFUNC(_wrap_FXDCWindow_fillChord), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "fillChords", VALUEFUNC(_wrap_FXDCWindow_fillChords), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "fillArc", VALUEFUNC(_wrap_FXDCWindow_fillArc), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "fillArcs", VALUEFUNC(_wrap_FXDCWindow_fillArcs), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "fillPolygon", VALUEFUNC(_wrap_FXDCWindow_fillPolygon), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "fillConcavePolygon", VALUEFUNC(_wrap_FXDCWindow_fillConcavePolygon), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "fillComplexPolygon", VALUEFUNC(_wrap_FXDCWindow_fillComplexPolygon), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "fillPolygonRel", VALUEFUNC(_wrap_FXDCWindow_fillPolygonRel), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "fillConcavePolygonRel", VALUEFUNC(_wrap_FXDCWindow_fillConcavePolygonRel), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "fillComplexPolygonRel", VALUEFUNC(_wrap_FXDCWindow_fillComplexPolygonRel), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "drawHashBox", VALUEFUNC(_wrap_FXDCWindow_drawHashBox), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "drawFocusRectangle", VALUEFUNC(_wrap_FXDCWindow_drawFocusRectangle), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "drawArea", VALUEFUNC(_wrap_FXDCWindow_drawArea), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "drawImage", VALUEFUNC(_wrap_FXDCWindow_drawImage), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "drawBitmap", VALUEFUNC(_wrap_FXDCWindow_drawBitmap), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "drawIcon", VALUEFUNC(_wrap_FXDCWindow_drawIcon), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "drawIconShaded", VALUEFUNC(_wrap_FXDCWindow_drawIconShaded), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "drawIconSunken", VALUEFUNC(_wrap_FXDCWindow_drawIconSunken), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "drawText", VALUEFUNC(_wrap_FXDCWindow_drawText), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "drawImageText", VALUEFUNC(_wrap_FXDCWindow_drawImageText), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "setForeground", VALUEFUNC(_wrap_FXDCWindow_setForeground), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "setBackground", VALUEFUNC(_wrap_FXDCWindow_setBackground), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "setDashes", VALUEFUNC(_wrap_FXDCWindow_setDashes), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "setLineWidth", VALUEFUNC(_wrap_FXDCWindow_setLineWidth), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "setLineCap", VALUEFUNC(_wrap_FXDCWindow_setLineCap), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "setLineJoin", VALUEFUNC(_wrap_FXDCWindow_setLineJoin), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "setLineStyle", VALUEFUNC(_wrap_FXDCWindow_setLineStyle), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "setFillStyle", VALUEFUNC(_wrap_FXDCWindow_setFillStyle), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "setFillRule", VALUEFUNC(_wrap_FXDCWindow_setFillRule), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "setFunction", VALUEFUNC(_wrap_FXDCWindow_setFunction), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "setTile", VALUEFUNC(_wrap_FXDCWindow_setTile), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "setStipple", VALUEFUNC(_wrap_FXDCWindow_setStipple), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "setClipRegion", VALUEFUNC(_wrap_FXDCWindow_setClipRegion), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "setClipRectangle", VALUEFUNC(_wrap_FXDCWindow_setClipRectangle), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "clearClipRectangle", VALUEFUNC(_wrap_FXDCWindow_clearClipRectangle), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "setClipMask", VALUEFUNC(_wrap_FXDCWindow_setClipMask), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "clearClipMask", VALUEFUNC(_wrap_FXDCWindow_clearClipMask), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "setFont", VALUEFUNC(_wrap_FXDCWindow_setFont), -1);
+  rb_define_method(SwigClassFXDCWindow.klass, "clipChildren", VALUEFUNC(_wrap_FXDCWindow_clipChildren), -1);
+  SwigClassFXDCWindow.mark = (void (*)(void *)) FXRbDCWindow::markfunc;
+  SwigClassFXDCWindow.destroy = (void (*)(void *)) free_FXDCWindow;
+  SwigClassFXDCWindow.trackObjects = 0;
+  rb_define_const(mFox, "PRINT_DEST_PAPER", SWIG_From_int(static_cast< int >(PRINT_DEST_PAPER)));
+  rb_define_const(mFox, "PRINT_DEST_FILE", SWIG_From_int(static_cast< int >(PRINT_DEST_FILE)));
+  rb_define_const(mFox, "PRINT_PAGES_ALL", SWIG_From_int(static_cast< int >(PRINT_PAGES_ALL)));
+  rb_define_const(mFox, "PRINT_PAGES_EVEN", SWIG_From_int(static_cast< int >(PRINT_PAGES_EVEN)));
+  rb_define_const(mFox, "PRINT_PAGES_ODD", SWIG_From_int(static_cast< int >(PRINT_PAGES_ODD)));
+  rb_define_const(mFox, "PRINT_PAGES_RANGE", SWIG_From_int(static_cast< int >(PRINT_PAGES_RANGE)));
+  rb_define_const(mFox, "PRINT_COLLATE_NORMAL", SWIG_From_int(static_cast< int >(PRINT_COLLATE_NORMAL)));
+  rb_define_const(mFox, "PRINT_COLLATE_REVERSED", SWIG_From_int(static_cast< int >(PRINT_COLLATE_REVERSED)));
+  rb_define_const(mFox, "PRINT_PORTRAIT", SWIG_From_int(static_cast< int >(PRINT_PORTRAIT)));
+  rb_define_const(mFox, "PRINT_LANDSCAPE", SWIG_From_int(static_cast< int >(PRINT_LANDSCAPE)));
+  rb_define_const(mFox, "PRINT_BLACKANDWHITE", SWIG_From_int(static_cast< int >(PRINT_BLACKANDWHITE)));
+  rb_define_const(mFox, "PRINT_COLOR", SWIG_From_int(static_cast< int >(PRINT_COLOR)));
+  rb_define_const(mFox, "PRINT_NOBOUNDS", SWIG_From_int(static_cast< int >(PRINT_NOBOUNDS)));
+  rb_define_const(mFox, "MEDIA_CUSTOM", SWIG_From_int(static_cast< int >(MEDIA_CUSTOM)));
+  rb_define_const(mFox, "MEDIA_USLETTER", SWIG_From_int(static_cast< int >(MEDIA_USLETTER)));
+  rb_define_const(mFox, "MEDIA_LEGAL", SWIG_From_int(static_cast< int >(MEDIA_LEGAL)));
+  rb_define_const(mFox, "MEDIA_A4", SWIG_From_int(static_cast< int >(MEDIA_A4)));
+  rb_define_const(mFox, "MEDIA_ENVELOPE", SWIG_From_int(static_cast< int >(MEDIA_ENVELOPE)));
+  
+  SwigClassFXPSBounds.klass = rb_define_class_under(mFox, "FXPSBounds", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXPSBounds, (void *) &SwigClassFXPSBounds);
+  rb_define_alloc_func(SwigClassFXPSBounds.klass, _wrap_FXPSBounds_allocate);
+  rb_define_method(SwigClassFXPSBounds.klass, "initialize", VALUEFUNC(_wrap_new_FXPSBounds), -1);
+  rb_define_method(SwigClassFXPSBounds.klass, "xmin=", VALUEFUNC(_wrap_FXPSBounds_xmin_set), -1);
+  rb_define_method(SwigClassFXPSBounds.klass, "xmin", VALUEFUNC(_wrap_FXPSBounds_xmin_get), -1);
+  rb_define_method(SwigClassFXPSBounds.klass, "xmax=", VALUEFUNC(_wrap_FXPSBounds_xmax_set), -1);
+  rb_define_method(SwigClassFXPSBounds.klass, "xmax", VALUEFUNC(_wrap_FXPSBounds_xmax_get), -1);
+  rb_define_method(SwigClassFXPSBounds.klass, "ymin=", VALUEFUNC(_wrap_FXPSBounds_ymin_set), -1);
+  rb_define_method(SwigClassFXPSBounds.klass, "ymin", VALUEFUNC(_wrap_FXPSBounds_ymin_get), -1);
+  rb_define_method(SwigClassFXPSBounds.klass, "ymax=", VALUEFUNC(_wrap_FXPSBounds_ymax_set), -1);
+  rb_define_method(SwigClassFXPSBounds.klass, "ymax", VALUEFUNC(_wrap_FXPSBounds_ymax_get), -1);
+  SwigClassFXPSBounds.mark = 0;
+  SwigClassFXPSBounds.destroy = (void (*)(void *)) free_FXPSBounds;
+  SwigClassFXPSBounds.trackObjects = 0;
+  
+  SwigClassFXPrinter.klass = rb_define_class_under(mFox, "FXPrinter", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXPrinter, (void *) &SwigClassFXPrinter);
+  rb_define_alloc_func(SwigClassFXPrinter.klass, _wrap_FXPrinter_allocate);
+  rb_define_method(SwigClassFXPrinter.klass, "initialize", VALUEFUNC(_wrap_new_FXPrinter), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "name=", VALUEFUNC(_wrap_FXPrinter_name_set), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "name", VALUEFUNC(_wrap_FXPrinter_name_get), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "firstpage=", VALUEFUNC(_wrap_FXPrinter_firstpage_set), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "firstpage", VALUEFUNC(_wrap_FXPrinter_firstpage_get), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "lastpage=", VALUEFUNC(_wrap_FXPrinter_lastpage_set), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "lastpage", VALUEFUNC(_wrap_FXPrinter_lastpage_get), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "currentpage=", VALUEFUNC(_wrap_FXPrinter_currentpage_set), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "currentpage", VALUEFUNC(_wrap_FXPrinter_currentpage_get), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "frompage=", VALUEFUNC(_wrap_FXPrinter_frompage_set), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "frompage", VALUEFUNC(_wrap_FXPrinter_frompage_get), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "topage=", VALUEFUNC(_wrap_FXPrinter_topage_set), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "topage", VALUEFUNC(_wrap_FXPrinter_topage_get), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "mediasize=", VALUEFUNC(_wrap_FXPrinter_mediasize_set), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "mediasize", VALUEFUNC(_wrap_FXPrinter_mediasize_get), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "mediawidth=", VALUEFUNC(_wrap_FXPrinter_mediawidth_set), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "mediawidth", VALUEFUNC(_wrap_FXPrinter_mediawidth_get), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "mediaheight=", VALUEFUNC(_wrap_FXPrinter_mediaheight_set), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "mediaheight", VALUEFUNC(_wrap_FXPrinter_mediaheight_get), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "leftmargin=", VALUEFUNC(_wrap_FXPrinter_leftmargin_set), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "leftmargin", VALUEFUNC(_wrap_FXPrinter_leftmargin_get), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "rightmargin=", VALUEFUNC(_wrap_FXPrinter_rightmargin_set), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "rightmargin", VALUEFUNC(_wrap_FXPrinter_rightmargin_get), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "topmargin=", VALUEFUNC(_wrap_FXPrinter_topmargin_set), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "topmargin", VALUEFUNC(_wrap_FXPrinter_topmargin_get), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "bottommargin=", VALUEFUNC(_wrap_FXPrinter_bottommargin_set), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "bottommargin", VALUEFUNC(_wrap_FXPrinter_bottommargin_get), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "numcopies=", VALUEFUNC(_wrap_FXPrinter_numcopies_set), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "numcopies", VALUEFUNC(_wrap_FXPrinter_numcopies_get), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "flags=", VALUEFUNC(_wrap_FXPrinter_flags_set), -1);
+  rb_define_method(SwigClassFXPrinter.klass, "flags", VALUEFUNC(_wrap_FXPrinter_flags_get), -1);
+  SwigClassFXPrinter.mark = 0;
+  SwigClassFXPrinter.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXPrinter.trackObjects = 0;
+  
+  SwigClassFXDCPrint.klass = rb_define_class_under(mFox, "FXDCPrint", ((swig_class *) SWIGTYPE_p_FXDC->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXDCPrint, (void *) &SwigClassFXDCPrint);
+  rb_define_alloc_func(SwigClassFXDCPrint.klass, _wrap_FXDCPrint_allocate);
+  rb_define_method(SwigClassFXDCPrint.klass, "initialize", VALUEFUNC(_wrap_new_FXDCPrint), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "beginPrint", VALUEFUNC(_wrap_FXDCPrint_beginPrint), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "endPrint", VALUEFUNC(_wrap_FXDCPrint_endPrint), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "beginPage", VALUEFUNC(_wrap_FXDCPrint_beginPage), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "endPage", VALUEFUNC(_wrap_FXDCPrint_endPage), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "setContentRange", VALUEFUNC(_wrap_FXDCPrint_setContentRange), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "readPixel", VALUEFUNC(_wrap_FXDCPrint_readPixel), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "drawPoint", VALUEFUNC(_wrap_FXDCPrint_drawPoint), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "drawPoints", VALUEFUNC(_wrap_FXDCPrint_drawPoints), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "drawPointsRel", VALUEFUNC(_wrap_FXDCPrint_drawPointsRel), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "drawLine", VALUEFUNC(_wrap_FXDCPrint_drawLine), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "drawLines", VALUEFUNC(_wrap_FXDCPrint_drawLines), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "drawLinesRel", VALUEFUNC(_wrap_FXDCPrint_drawLinesRel), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "drawLineSegments", VALUEFUNC(_wrap_FXDCPrint_drawLineSegments), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "drawRectangle", VALUEFUNC(_wrap_FXDCPrint_drawRectangle), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "drawRectangles", VALUEFUNC(_wrap_FXDCPrint_drawRectangles), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "drawRoundRectangle", VALUEFUNC(_wrap_FXDCPrint_drawRoundRectangle), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "drawArc", VALUEFUNC(_wrap_FXDCPrint_drawArc), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "drawArcs", VALUEFUNC(_wrap_FXDCPrint_drawArcs), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "drawEllipse", VALUEFUNC(_wrap_FXDCPrint_drawEllipse), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "fillRectangle", VALUEFUNC(_wrap_FXDCPrint_fillRectangle), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "fillRectangles", VALUEFUNC(_wrap_FXDCPrint_fillRectangles), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "fillRoundRectangle", VALUEFUNC(_wrap_FXDCPrint_fillRoundRectangle), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "fillChord", VALUEFUNC(_wrap_FXDCPrint_fillChord), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "fillChords", VALUEFUNC(_wrap_FXDCPrint_fillChords), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "fillArc", VALUEFUNC(_wrap_FXDCPrint_fillArc), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "fillArcs", VALUEFUNC(_wrap_FXDCPrint_fillArcs), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "fillPolygon", VALUEFUNC(_wrap_FXDCPrint_fillPolygon), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "fillConcavePolygon", VALUEFUNC(_wrap_FXDCPrint_fillConcavePolygon), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "fillComplexPolygon", VALUEFUNC(_wrap_FXDCPrint_fillComplexPolygon), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "fillPolygonRel", VALUEFUNC(_wrap_FXDCPrint_fillPolygonRel), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "fillConcavePolygonRel", VALUEFUNC(_wrap_FXDCPrint_fillConcavePolygonRel), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "fillComplexPolygonRel", VALUEFUNC(_wrap_FXDCPrint_fillComplexPolygonRel), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "drawHashBox", VALUEFUNC(_wrap_FXDCPrint_drawHashBox), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "drawFocusRectangle", VALUEFUNC(_wrap_FXDCPrint_drawFocusRectangle), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "drawArea", VALUEFUNC(_wrap_FXDCPrint_drawArea), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "drawImage", VALUEFUNC(_wrap_FXDCPrint_drawImage), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "drawBitmap", VALUEFUNC(_wrap_FXDCPrint_drawBitmap), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "drawIcon", VALUEFUNC(_wrap_FXDCPrint_drawIcon), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "drawIconShaded", VALUEFUNC(_wrap_FXDCPrint_drawIconShaded), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "drawIconSunken", VALUEFUNC(_wrap_FXDCPrint_drawIconSunken), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "drawText", VALUEFUNC(_wrap_FXDCPrint_drawText), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "drawImageText", VALUEFUNC(_wrap_FXDCPrint_drawImageText), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "setForeground", VALUEFUNC(_wrap_FXDCPrint_setForeground), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "setBackground", VALUEFUNC(_wrap_FXDCPrint_setBackground), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "setDashes", VALUEFUNC(_wrap_FXDCPrint_setDashes), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "setLineWidth", VALUEFUNC(_wrap_FXDCPrint_setLineWidth), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "setLineCap", VALUEFUNC(_wrap_FXDCPrint_setLineCap), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "setLineJoin", VALUEFUNC(_wrap_FXDCPrint_setLineJoin), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "setLineStyle", VALUEFUNC(_wrap_FXDCPrint_setLineStyle), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "setFillStyle", VALUEFUNC(_wrap_FXDCPrint_setFillStyle), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "setFillRule", VALUEFUNC(_wrap_FXDCPrint_setFillRule), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "setFunction", VALUEFUNC(_wrap_FXDCPrint_setFunction), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "setTile", VALUEFUNC(_wrap_FXDCPrint_setTile), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "setStipple", VALUEFUNC(_wrap_FXDCPrint_setStipple), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "setClipRegion", VALUEFUNC(_wrap_FXDCPrint_setClipRegion), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "setClipRectangle", VALUEFUNC(_wrap_FXDCPrint_setClipRectangle), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "clearClipRectangle", VALUEFUNC(_wrap_FXDCPrint_clearClipRectangle), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "setClipMask", VALUEFUNC(_wrap_FXDCPrint_setClipMask), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "clearClipMask", VALUEFUNC(_wrap_FXDCPrint_clearClipMask), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "setFont", VALUEFUNC(_wrap_FXDCPrint_setFont), -1);
+  rb_define_method(SwigClassFXDCPrint.klass, "clipChildren", VALUEFUNC(_wrap_FXDCPrint_clipChildren), -1);
+  SwigClassFXDCPrint.mark = (void (*)(void *)) FXRbDCPrint::markfunc;
+  SwigClassFXDCPrint.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXDCPrint.trackObjects = 0;
+}
+
diff --git a/ext/fox16_c/dialogs_wrap.cpp b/ext/fox16_c/dialogs_wrap.cpp
new file mode 100644
index 00000000..d835e8ae
--- /dev/null
+++ b/ext/fox16_c/dialogs_wrap.cpp
@@ -0,0 +1,30062 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 3.0.12
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+
+#ifndef SWIGRUBY
+#define SWIGRUBY
+#endif
+
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
+};
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic C API SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "4"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/*  Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN           0x1
+
+
+/*
+   Flags/methods for returning states.
+
+   The SWIG conversion methods, as ConvertPtr, return an integer
+   that tells if the conversion was successful or not. And if not,
+   an error code can be returned (see swigerrors.swg for the codes).
+
+   Use the following macros/flags to set or process the returning
+   states.
+
+   In old versions of SWIG, code such as the following was usually written:
+
+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+       // success code
+     } else {
+       //fail code
+     }
+
+   Now you can be more explicit:
+
+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+    } else {
+      // fail code
+    }
+
+   which is the same really, but now you can also do
+
+    Type *ptr;
+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+      if (SWIG_IsNewObj(res) {
+        ...
+	delete *ptr;
+      } else {
+        ...
+      }
+    } else {
+      // fail code
+    }
+
+   I.e., now SWIG_ConvertPtr can return new objects and you can
+   identify the case and take care of the deallocation. Of course that
+   also requires SWIG_ConvertPtr to return new result values, such as
+
+      int SWIG_ConvertPtr(obj, ptr,...) {
+        if (<obj is ok>) {
+          if (<need new object>) {
+            *ptr = <ptr to new allocated object>;
+            return SWIG_NEWOBJ;
+          } else {
+            *ptr = <ptr to old object>;
+            return SWIG_OLDOBJ;
+          }
+        } else {
+          return SWIG_BADOBJ;
+        }
+      }
+
+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+   SWIG errors code.
+
+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+   allows to return the 'cast rank', for example, if you have this
+
+       int food(double)
+       int fooi(int);
+
+   and you call
+
+      food(1)   // cast rank '1'  (1 -> 1.0)
+      fooi(1)   // cast rank '0'
+
+   just use the SWIG_AddCast()/SWIG_CheckState()
+*/
+
+#define SWIG_OK                    (0)
+#define SWIG_ERROR                 (-1)
+#define SWIG_IsOK(r)               (r >= 0)
+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT         (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ                (SWIG_ERROR)
+#define SWIG_OLDOBJ                (SWIG_OK)
+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+#  ifndef SWIG_TypeRank
+#    define SWIG_TypeRank             unsigned long
+#  endif
+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
+#    define SWIG_MAXCASTRANK          (2)
+#  endif
+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+#  define SWIG_AddCast(r) (r)
+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *, int *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store information on one type */
+typedef struct swig_type_info {
+  const char             *name;			/* mangled name of this type */
+  const char             *str;			/* human readable name of this type */
+  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
+  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
+  void                   *clientdata;		/* language specific type data */
+  int                    owndata;		/* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
+  swig_converter_func     converter;		/* function to cast the void pointers */
+  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
+  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
+  size_t                 size;		        /* Number of types in this module */
+  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
+  swig_type_info         **type_initial;	/* Array of initially generated type structures */
+  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
+  void                    *clientdata;		/* Language specific module data */
+} swig_module_info;
+
+/*
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+  }
+  return (int)((l1 - f1) - (l2 - f2));
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCmp(const char *nb, const char *tb) {
+  int equiv = 1;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (equiv != 0 && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
+}
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
+}
+
+/*
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+  swig_type_info *lastty = ty;
+  if (!ty || !ty->dcast) return ty;
+  while (ty && (ty->dcast)) {
+    ty = (*ty->dcast)(ptr);
+    if (ty) lastty = ty;
+  }
+  return lastty;
+}
+
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+  return ty->name;
+}
+
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (!type) return NULL;
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
+  }
+  else
+    return type->name;
+}
+
+/*
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+  swig_cast_info *cast = ti->cast;
+  /* if (ti->clientdata == clientdata) return; */
+  ti->clientdata = clientdata;
+
+  while (cast) {
+    if (!cast->converter) {
+      swig_type_info *tc = cast->type;
+      if (!tc->clientdata) {
+	SWIG_TypeClientData(tc, clientdata);
+      }
+    }
+    cast = cast->next;
+  }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientData(ti, clientdata);
+  ti->owndata = 1;
+}
+
+/*
+  Search for a swig_type_info structure only by mangled name
+  Search is a O(log #types)
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+                            swig_module_info *end,
+		            const char *name) {
+  swig_module_info *iter = start;
+  do {
+    if (iter->size) {
+      size_t l = 0;
+      size_t r = iter->size - 1;
+      do {
+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
+	size_t i = (l + r) >> 1;
+	const char *iname = iter->types[i]->name;
+	if (iname) {
+	  int compare = strcmp(name, iname);
+	  if (compare == 0) {
+	    return iter->types[i];
+	  } else if (compare < 0) {
+	    if (i) {
+	      r = i - 1;
+	    } else {
+	      break;
+	    }
+	  } else if (compare > 0) {
+	    l = i + 1;
+	  }
+	} else {
+	  break; /* should never happen */
+	}
+      } while (l <= r);
+    }
+    iter = iter->next;
+  } while (iter != end);
+  return 0;
+}
+
+/*
+  Search for a swig_type_info structure for either a mangled name or a human readable name.
+  It first searches the mangled names of the types, which is a O(log #types)
+  If a type is not found it then searches the human readable names, which is O(#types).
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+                     swig_module_info *end,
+		     const char *name) {
+  /* STEP 1: Search the name field using binary search */
+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+  if (ret) {
+    return ret;
+  } else {
+    /* STEP 2: If the type hasn't been found, do a complete search
+       of the str field (the human readable name) */
+    swig_module_info *iter = start;
+    do {
+      size_t i = 0;
+      for (; i < iter->size; ++i) {
+	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+	  return iter->types[i];
+      }
+      iter = iter->next;
+    } while (iter != end);
+  }
+
+  /* neither found a match */
+  return 0;
+}
+
+/*
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+
+/*
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = (unsigned char)((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = (unsigned char)((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (unsigned char)(d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (unsigned char)(d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/*
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/*  Errors in SWIG */
+#define  SWIG_UnknownError    	   -1
+#define  SWIG_IOError        	   -2
+#define  SWIG_RuntimeError   	   -3
+#define  SWIG_IndexError     	   -4
+#define  SWIG_TypeError      	   -5
+#define  SWIG_DivisionByZero 	   -6
+#define  SWIG_OverflowError  	   -7
+#define  SWIG_SyntaxError    	   -8
+#define  SWIG_ValueError     	   -9
+#define  SWIG_SystemError    	   -10
+#define  SWIG_AttributeError 	   -11
+#define  SWIG_MemoryError    	   -12
+#define  SWIG_NullReferenceError   -13
+
+
+
+      #include <ruby.h>
+
+      #if defined(RB_METHOD_DEFINITION_DECL)
+      # define RUBY_VALUE_METHOD_FUNC(func) (func)
+      # define RUBY_INT_METHOD_FUNC(func) (func)
+      # define RUBY_VOID_METHOD_FUNC(func) (func)
+      # define RUBY_VOIDP_METHOD_FUNC(func) (func)
+      #else
+      # define RUBY_VALUE_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
+      # define RUBY_INT_METHOD_FUNC(func) ((int (*)(ANYARGS))(func))
+      # define RUBY_VOID_METHOD_FUNC(func) ((void (*)(ANYARGS))(func))
+      # define RUBY_VOIDP_METHOD_FUNC(func) ((void *(*)(ANYARGS))(func))
+      #endif
+
+
+/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
+ * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
+ * issue for now by disabling this.
+ * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
+ */
+#ifdef rb_intern
+# undef rb_intern
+#endif
+
+/* Remove global macros defined in Ruby's win32.h */
+#ifdef write
+# undef write
+#endif
+#ifdef read
+# undef read
+#endif
+#ifdef bind
+# undef bind
+#endif
+#ifdef close
+# undef close
+#endif
+#ifdef connect
+# undef connect
+#endif
+
+
+/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
+#ifndef NUM2LL
+#define NUM2LL(x) NUM2LONG((x))
+#endif
+#ifndef LL2NUM
+#define LL2NUM(x) INT2NUM((long) (x))
+#endif
+#ifndef ULL2NUM
+#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
+#endif
+
+/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
+#ifndef NUM2ULL
+#ifdef HAVE_LONG_LONG
+#define NUM2ULL(x) rb_num2ull((x))
+#else
+#define NUM2ULL(x) NUM2ULONG(x)
+#endif
+#endif
+
+/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
+/* Define these for older versions so we can just write code the new way */
+#ifndef RSTRING_LEN
+# define RSTRING_LEN(x) RSTRING(x)->len
+#endif
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(x) RSTRING(x)->ptr
+#endif
+#ifndef RSTRING_END
+# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
+#endif
+#ifndef RARRAY_LEN
+# define RARRAY_LEN(x) RARRAY(x)->len
+#endif
+#ifndef RARRAY_PTR
+# define RARRAY_PTR(x) RARRAY(x)->ptr
+#endif
+#ifndef RFLOAT_VALUE
+# define RFLOAT_VALUE(x) RFLOAT(x)->value
+#endif
+#ifndef DOUBLE2NUM
+# define DOUBLE2NUM(x) rb_float_new(x)
+#endif
+#ifndef RHASH_TBL
+# define RHASH_TBL(x) (RHASH(x)->tbl)
+#endif
+#ifndef RHASH_ITER_LEV
+# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
+#endif
+#ifndef RHASH_IFNONE
+# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
+#endif
+#ifndef RHASH_SIZE
+# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
+#endif
+#ifndef RHASH_EMPTY_P
+# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
+#endif
+#ifndef RSTRUCT_LEN
+# define RSTRUCT_LEN(x) RSTRUCT(x)->len
+#endif
+#ifndef RSTRUCT_PTR
+# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
+#endif
+
+
+
+/*
+ * Need to be very careful about how these macros are defined, especially
+ * when compiling C++ code or C code with an ANSI C compiler.
+ *
+ * VALUEFUNC(f) is a macro used to typecast a C function that implements
+ * a Ruby method so that it can be passed as an argument to API functions
+ * like rb_define_method() and rb_define_singleton_method().
+ *
+ * VOIDFUNC(f) is a macro used to typecast a C function that implements
+ * either the "mark" or "free" stuff for a Ruby Data object, so that it
+ * can be passed as an argument to API functions like Data_Wrap_Struct()
+ * and Data_Make_Struct().
+ */
+ 
+#ifdef __cplusplus
+#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
+#    define PROTECTFUNC(f) ((VALUE (*)()) f)
+#    define VALUEFUNC(f) ((VALUE (*)()) f)
+#    define VOIDFUNC(f)  ((void (*)()) f)
+#  else
+#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
+#      define PROTECTFUNC(f) ((VALUE (*)()) f)
+#      define VALUEFUNC(f) ((VALUE (*)()) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    else /* These definitions should work for Ruby 1.7+ */
+#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
+#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    endif
+#  endif
+#else
+#  define VALUEFUNC(f) (f)
+#  define VOIDFUNC(f) (f)
+#endif
+
+/* Don't use for expressions have side effect */
+#ifndef RB_STRING_VALUE
+#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
+#endif
+#ifndef StringValue
+#define StringValue(s) RB_STRING_VALUE(s)
+#endif
+#ifndef StringValuePtr
+#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
+#endif
+#ifndef StringValueLen
+#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
+#endif
+#ifndef SafeStringValue
+#define SafeStringValue(v) do {\
+    StringValue(v);\
+    rb_check_safe_str(v);\
+} while (0)
+#endif
+
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
+#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
+#endif
+
+static VALUE _mSWIG = Qnil;
+
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+
+/* Define some additional error types */
+#define SWIG_ObjectPreviouslyDeletedError  -100
+
+
+/* Define custom exceptions for errors that do not map to existing Ruby
+   exceptions.  Note this only works for C++ since a global cannot be
+   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/
+
+SWIGINTERN VALUE 
+getNullReferenceError(void) {
+  static int init = 0;
+  static VALUE rb_eNullReferenceError ;
+  if (!init) {
+    init = 1;
+    rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
+  }
+  return rb_eNullReferenceError;
+} 
+
+SWIGINTERN VALUE 
+getObjectPreviouslyDeletedError(void) {
+  static int init = 0;
+  static VALUE rb_eObjectPreviouslyDeleted ;
+  if (!init) {
+    init = 1;
+    rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
+  }
+  return rb_eObjectPreviouslyDeleted;
+} 
+
+
+SWIGINTERN VALUE
+SWIG_Ruby_ErrorType(int SWIG_code) {
+  VALUE type;
+  switch (SWIG_code) {
+  case SWIG_MemoryError:
+    type = rb_eNoMemError;
+    break;
+  case SWIG_IOError:
+    type = rb_eIOError;
+    break;
+  case SWIG_RuntimeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_IndexError:
+    type = rb_eIndexError;
+    break;
+  case SWIG_TypeError:
+    type = rb_eTypeError;
+    break;
+  case SWIG_DivisionByZero:
+    type = rb_eZeroDivError;
+    break;
+  case SWIG_OverflowError:
+    type = rb_eRangeError;
+    break;
+  case SWIG_SyntaxError:
+    type = rb_eSyntaxError;
+    break;
+  case SWIG_ValueError:
+    type = rb_eArgError;
+    break;
+  case SWIG_SystemError:
+    type = rb_eFatal;
+    break;
+  case SWIG_AttributeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_NullReferenceError:
+    type = getNullReferenceError();
+    break;
+  case SWIG_ObjectPreviouslyDeletedError:
+    type = getObjectPreviouslyDeletedError();
+    break;
+  case SWIG_UnknownError:
+    type = rb_eRuntimeError;
+    break;
+  default:
+    type = rb_eRuntimeError;
+  }
+  return type;
+}
+
+
+/* This function is called when a user inputs a wrong argument to
+   a method.
+ */
+SWIGINTERN 
+const char* Ruby_Format_TypeError( const char* msg,
+				   const char* type, 
+				   const char* name, 
+				   const int argn,
+				   VALUE input )
+{
+  char buf[128];
+  VALUE str;
+  VALUE asStr;
+  if ( msg && *msg )
+    {
+      str = rb_str_new2(msg);
+    }
+  else
+    {
+      str = rb_str_new(NULL, 0);
+    }
+
+  str = rb_str_cat2( str, "Expected argument " );
+  sprintf( buf, "%d of type ", argn-1 );
+  str = rb_str_cat2( str, buf );
+  str = rb_str_cat2( str, type );
+  str = rb_str_cat2( str, ", but got " );
+  str = rb_str_cat2( str, rb_obj_classname(input) );
+  str = rb_str_cat2( str, " " );
+  asStr = rb_inspect(input);
+  if ( RSTRING_LEN(asStr) > 30 )
+    {
+      str = rb_str_cat( str, StringValuePtr(asStr), 30 );
+      str = rb_str_cat2( str, "..." );
+    }
+  else
+    {
+      str = rb_str_append( str, asStr );
+    }
+
+  if ( name )
+    {
+      str = rb_str_cat2( str, "\n\tin SWIG method '" );
+      str = rb_str_cat2( str, name );
+      str = rb_str_cat2( str, "'" );
+    }
+
+  return StringValuePtr( str );
+}
+
+/* This function is called when an overloaded method fails */
+SWIGINTERN 
+void Ruby_Format_OverloadedError(
+				 const int argc,
+				 const int maxargs,
+				 const char* method, 
+				 const char* prototypes 
+				 )
+{
+  const char* msg = "Wrong # of arguments";
+  if ( argc <= maxargs ) msg = "Wrong arguments";
+  rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
+	   "Possible C/C++ prototypes are:\n%s",
+	   msg, method, prototypes);
+}
+
+/* -----------------------------------------------------------------------------
+ * rubytracking.swg
+ *
+ * This file contains support for tracking mappings from 
+ * Ruby objects to C++ objects.  This functionality is needed
+ * to implement mark functions for Ruby's mark and sweep
+ * garbage collector.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(ST_DATA_T_DEFINED)
+/* Needs to be explicitly included for Ruby 1.8 and earlier */
+#include <st.h>
+#endif
+
+/* Ruby 1.8 actually assumes the first case. */
+#if SIZEOF_VOIDP == SIZEOF_LONG
+#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
+#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
+#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
+#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
+#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
+#else
+#  error sizeof(void*) is not the same as long or long long
+#endif
+
+/* Global hash table to store Trackings from C/C++
+   structs to Ruby Objects. 
+*/
+static st_table* swig_ruby_trackings = NULL;
+
+static VALUE swig_ruby_trackings_count(ID id, VALUE *var) {
+  return SWIG2NUM(swig_ruby_trackings->num_entries);
+}
+
+
+/* Setup a hash table to store Trackings */
+SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
+  /* Create a hash table to store Trackings from C++
+     objects to Ruby objects. */
+
+  /* Try to see if some other .so has already created a 
+     tracking hash table, which we keep hidden in an instance var
+     in the SWIG module.
+     This is done to allow multiple DSOs to share the same
+     tracking table.
+  */
+  VALUE trackings_value = Qnil;
+  /* change the variable name so that we can mix modules
+     compiled with older SWIG's - this used to be called "@__trackings__" */
+  ID trackings_id = rb_intern( "@__safetrackings__" );
+  VALUE verbose = rb_gv_get("VERBOSE");
+  rb_gv_set("VERBOSE", Qfalse);
+  trackings_value = rb_ivar_get( _mSWIG, trackings_id );
+  rb_gv_set("VERBOSE", verbose);
+
+  /* The trick here is that we have to store the hash table
+  pointer in a Ruby variable. We do not want Ruby's GC to
+  treat this pointer as a Ruby object, so we convert it to
+  a Ruby numeric value. */
+  if (trackings_value == Qnil) {
+    /* No, it hasn't.  Create one ourselves */
+    swig_ruby_trackings = st_init_numtable();
+    rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
+  } else {
+    swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
+  }
+
+        rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", RUBY_VALUE_METHOD_FUNC(swig_ruby_trackings_count), RUBY_VOID_METHOD_FUNC((rb_gvar_setter_t*)NULL))
+;
+}
+
+/* Add a Tracking from a C/C++ struct to a Ruby object */
+SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
+  /* Store the mapping to the global hash table. */
+  st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
+}
+
+/* Get the Ruby object that owns the specified C/C++ struct */
+SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
+  /* Now lookup the value stored in the global hash table */
+  VALUE value;
+
+  if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
+    return value;
+  } else {
+    return Qnil;
+  }
+}
+
+/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
+   is very important to remove objects once they are destroyed
+   since the same memory address may be reused later to create
+   a new object. */
+SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
+  /* Delete the object from the hash table */
+  st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
+}
+
+/* This is a helper method that unlinks a Ruby object from its
+   underlying C++ object.  This is needed if the lifetime of the
+   Ruby object is longer than the C++ object */
+SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
+  VALUE object = SWIG_RubyInstanceFor(ptr);
+
+  if (object != Qnil) {
+    if (TYPE(object) != T_DATA)
+      abort();
+    DATA_PTR(object) = 0;
+  }
+}
+
+/* This is a helper method that iterates over all the trackings
+   passing the C++ object pointer and its related Ruby object
+   to the passed callback function. */
+
+/* Proxy method to abstract the internal trackings datatype */
+      static int swig_ruby_internal_iterate_callback(st_data_t ptr, st_data_t obj, st_data_t meth) {
+        ((void(*)(void*, VALUE))meth)((void*)ptr, (VALUE)obj);
+
+  return ST_CONTINUE;
+}
+
+SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
+  st_foreach(swig_ruby_trackings, RUBY_INT_METHOD_FUNC(swig_ruby_internal_iterate_callback), (st_data_t)meth);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Ruby API portion that goes into the runtime
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGINTERN VALUE
+SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
+  if (NIL_P(target)) {
+    target = o;
+  } else {
+    if (TYPE(target) != T_ARRAY) {
+      VALUE o2 = target;
+      target = rb_ary_new();
+      rb_ary_push(target, o2);
+    }
+    rb_ary_push(target, o);
+  }
+  return target;
+}
+
+/* For ruby1.8.4 and earlier. */
+#ifndef RUBY_INIT_STACK
+   RUBY_EXTERN void Init_stack(VALUE* addr);
+#  define RUBY_INIT_STACK \
+   VALUE variable_in_this_stack_frame; \
+   Init_stack(&variable_in_this_stack_frame);
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* -----------------------------------------------------------------------------
+ * rubyrun.swg
+ *
+ * This file contains the runtime support for Ruby modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
+#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
+#define swig_owntype                                    swig_ruby_owntype
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) 		SWIG_Ruby_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
+#define SWIG_Error(code, msg)            		rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
+#define SWIG_fail                        		goto fail				 
+
+
+/* Ruby-specific SWIG API */
+
+#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
+#define SWIG_define_class(ty)                        	SWIG_Ruby_define_class(ty)
+#define SWIG_NewClassInstance(value, ty)             	SWIG_Ruby_NewClassInstance(value, ty)
+#define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
+#define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  
+
+#include "assert.h"
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  VALUE klass;
+  VALUE mImpl;
+  void  (*mark)(void *);
+  void  (*destroy)(void *);
+  int trackObjects;
+} swig_class;
+
+
+/* Global pointer used to keep some internal SWIG stuff */
+static VALUE _cSWIG_Pointer = Qnil;
+static VALUE swig_runtime_data_type_pointer = Qnil;
+
+/* Global IDs used to keep some internal SWIG stuff */
+static ID swig_arity_id = 0;
+static ID swig_call_id  = 0;
+
+/*
+  If your swig extension is to be run within an embedded ruby and has
+  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
+  This will reset ruby's stack frame on each entry point from the main 
+  program the first time a virtual director function is invoked (in a 
+  non-recursive way).
+  If this is not done, you run the risk of Ruby trashing the stack.
+*/
+
+#ifdef RUBY_EMBEDDED
+
+#  define SWIG_INIT_STACK                            \
+      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
+      ++swig_virtual_calls;
+#  define SWIG_RELEASE_STACK --swig_virtual_calls;
+#  define Ruby_DirectorTypeMismatchException(x) \
+          rb_raise( rb_eTypeError, "%s", x ); return c_result;
+
+      static unsigned int swig_virtual_calls = 0;
+
+#else  /* normal non-embedded extension */
+
+#  define SWIG_INIT_STACK
+#  define SWIG_RELEASE_STACK
+#  define Ruby_DirectorTypeMismatchException(x) \
+          throw Swig::DirectorTypeMismatchException( x );
+
+#endif  /* RUBY_EMBEDDED */
+
+
+SWIGRUNTIME VALUE 
+getExceptionClass(void) {
+  static int init = 0;
+  static VALUE rubyExceptionClass ;
+  if (!init) {
+    init = 1;
+    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
+  }
+  return rubyExceptionClass;
+} 
+
+/* This code checks to see if the Ruby object being raised as part
+   of an exception inherits from the Ruby class Exception.  If so,
+   the object is simply returned.  If not, then a new Ruby exception
+   object is created and that will be returned to Ruby.*/
+SWIGRUNTIME VALUE
+SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
+  VALUE exceptionClass = getExceptionClass();
+  if (rb_obj_is_kind_of(obj, exceptionClass)) {
+    return obj;
+  }  else {
+    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
+  }
+}
+
+/* Initialize Ruby runtime support */
+SWIGRUNTIME void
+SWIG_Ruby_InitRuntime(void)
+{
+  if (_mSWIG == Qnil) {
+    _mSWIG = rb_define_module("SWIG");
+    swig_call_id  = rb_intern("call");
+    swig_arity_id = rb_intern("arity");
+  }
+}
+
+/* Define Ruby class for C type */
+SWIGRUNTIME void
+SWIG_Ruby_define_class(swig_type_info *type)
+{
+  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+  sprintf(klass_name, "TYPE%s", type->name);
+  if (NIL_P(_cSWIG_Pointer)) {
+    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
+    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
+  }
+  rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
+  free((void *) klass_name);
+}
+
+/* Create a new pointer object */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
+{
+  int own =  flags & SWIG_POINTER_OWN; 
+  int track;
+  char *klass_name;
+  swig_class *sklass;
+  VALUE klass;
+  VALUE obj;
+  
+  if (!ptr)
+    return Qnil;
+  
+  if (type->clientdata) {
+    sklass = (swig_class *) type->clientdata;
+		
+    /* Are we tracking this class and have we already returned this Ruby object? */
+    track = sklass->trackObjects;
+    if (track) {
+      obj = SWIG_RubyInstanceFor(ptr);
+      
+      /* Check the object's type and make sure it has the correct type.
+        It might not in cases where methods do things like 
+        downcast methods. */
+      if (obj != Qnil) {
+        VALUE value = rb_iv_get(obj, "@__swigtype__");
+        const char* type_name = RSTRING_PTR(value);
+				
+        if (strcmp(type->name, type_name) == 0) {
+          return obj;
+        }
+      }
+    }
+
+    /* Create a new Ruby object */
+    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
+			   ( own ? VOIDFUNC(sklass->destroy) : 
+			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
+			     ), ptr);
+
+    /* If tracking is on for this class then track this object. */
+    if (track) {
+      SWIG_RubyAddTracking(ptr, obj);
+    }
+  } else {
+    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+    sprintf(klass_name, "TYPE%s", type->name);
+    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
+    free((void *) klass_name);
+    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
+  }
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  
+  return obj;
+}
+
+/* Create a new class instance (always owned) */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
+{
+  VALUE obj;
+  swig_class *sklass = (swig_class *) type->clientdata;
+  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  return obj;
+}
+
+/* Get type mangle from class name */
+SWIGRUNTIMEINLINE char *
+SWIG_Ruby_MangleStr(VALUE obj)
+{
+  VALUE stype = rb_iv_get(obj, "@__swigtype__");
+  return StringValuePtr(stype);
+}
+
+/* Acquire a pointer value */
+typedef struct {
+  void (*datafree)(void *);
+  int own;
+} swig_ruby_owntype;
+
+SWIGRUNTIME swig_ruby_owntype
+SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
+  swig_ruby_owntype oldown = {0, 0};
+  if (obj) {
+    oldown.datafree = RDATA(obj)->dfree;
+    RDATA(obj)->dfree = own.datafree;
+  }
+  return oldown;
+}
+
+/* Convert a pointer value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
+{
+  char *c;
+  swig_cast_info *tc;
+  void *vptr = 0;
+
+  /* Grab the pointer */
+  if (NIL_P(obj)) {
+    if (ptr)
+      *ptr = 0;
+    return SWIG_OK;
+  } else {
+    if (TYPE(obj) != T_DATA) {
+      return SWIG_ERROR;
+    }
+    Data_Get_Struct(obj, void, vptr);
+  }
+  
+  if (own) {
+    own->datafree = RDATA(obj)->dfree;
+    own->own = 0;
+  }
+    
+  /* Check to see if the input object is giving up ownership
+     of the underlying C struct or C++ object.  If so then we
+     need to reset the destructor since the Ruby object no 
+     longer owns the underlying C++ object.*/ 
+  if (flags & SWIG_POINTER_DISOWN) {
+    /* Is tracking on for this class? */
+    int track = 0;
+    if (ty && ty->clientdata) {
+      swig_class *sklass = (swig_class *) ty->clientdata;
+      track = sklass->trackObjects;
+    }
+		
+    if (track) {
+      /* We are tracking objects for this class.  Thus we change the destructor
+       * to SWIG_RubyRemoveTracking.  This allows us to
+       * remove the mapping from the C++ to Ruby object
+       * when the Ruby object is garbage collected.  If we don't
+       * do this, then it is possible we will return a reference 
+       * to a Ruby object that no longer exists thereby crashing Ruby. */
+      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
+    } else {    
+      RDATA(obj)->dfree = 0;
+    }
+  }
+
+  /* Do type-checking if type info was provided */
+  if (ty) {
+    if (ty->clientdata) {
+      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
+        if (vptr == 0) {
+          /* The object has already been deleted */
+          return SWIG_ObjectPreviouslyDeletedError;
+        }
+      }
+    }
+    if ((c = SWIG_MangleStr(obj)) == NULL) {
+      return SWIG_ERROR;
+    }
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) {
+      return SWIG_ERROR;
+    } else {
+      if (ptr) {
+        if (tc->type == ty) {
+          *ptr = vptr;
+        } else {
+          int newmemory = 0;
+          *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
+          if (newmemory == SWIG_CAST_NEW_MEMORY) {
+            assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+            if (own)
+              own->own = own->own | SWIG_CAST_NEW_MEMORY;
+          }
+        }
+      }
+    }
+  } else {
+    if (ptr)
+      *ptr = vptr;
+  }
+  
+  return SWIG_OK;
+}
+
+/* Check convert */
+SWIGRUNTIMEINLINE int
+SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
+{
+  char *c = SWIG_MangleStr(obj);
+  if (!c) return 0;
+  return SWIG_TypeCheck(c,ty) != 0;
+}
+
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r, ptr, sz);
+  strcpy(r, type->name);
+  return rb_str_new2(result);
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c;
+
+  if (TYPE(obj) != T_STRING) goto type_error;
+  c = StringValuePtr(obj);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') goto type_error;
+  c++;
+  c = SWIG_UnpackData(c, ptr, sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) goto type_error;
+  }
+  return SWIG_OK;
+
+ type_error:
+  return SWIG_ERROR;
+}
+
+SWIGRUNTIME swig_module_info *
+SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
+{
+  VALUE pointer;
+  swig_module_info *ret = 0;
+  VALUE verbose = rb_gv_get("VERBOSE");
+
+ /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
+  rb_gv_set("VERBOSE", Qfalse);
+  
+  /* first check if pointer already created */
+  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  if (pointer != Qnil) {
+    Data_Get_Struct(pointer, swig_module_info, ret);
+  }
+
+  /* reinstate warnings */
+  rb_gv_set("VERBOSE", verbose);
+  return ret;
+}
+
+SWIGRUNTIME void 
+SWIG_Ruby_SetModule(swig_module_info *pointer)
+{
+  /* register a new class */
+  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
+  /* create and store the structure pointer to a global variable */
+  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
+  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
+}
+
+/* This function can be used to check whether a proc or method or similarly
+   callable function has been passed.  Usually used in a %typecheck, like:
+
+   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
+        $result = SWIG_Ruby_isCallable( $input );
+   }
+ */
+SWIGINTERN
+int SWIG_Ruby_isCallable( VALUE proc )
+{
+  if ( rb_respond_to( proc, swig_call_id ) )
+    return 1;
+  return 0;
+}
+
+/* This function can be used to check the arity (number of arguments)
+   a proc or method can take.  Usually used in a %typecheck.
+   Valid arities will be that equal to minimal or those < 0
+   which indicate a variable number of parameters at the end.
+ */
+SWIGINTERN
+int SWIG_Ruby_arity( VALUE proc, int minimal )
+{
+  if ( rb_respond_to( proc, swig_arity_id ) )
+    {
+      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
+      int arity = NUM2INT(num);
+      if ( arity < 0 && (arity+1) < -minimal ) return 1;
+      if ( arity == minimal ) return 1;
+      return 1;
+    }
+  return 0;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
+
+
+
+  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) 
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_p_FX4Splitter swig_types[0]
+#define SWIGTYPE_p_FX7Segment swig_types[1]
+#define SWIGTYPE_p_FXAccelTable swig_types[2]
+#define SWIGTYPE_p_FXApp swig_types[3]
+#define SWIGTYPE_p_FXArrowButton swig_types[4]
+#define SWIGTYPE_p_FXBitmap swig_types[5]
+#define SWIGTYPE_p_FXBitmapFrame swig_types[6]
+#define SWIGTYPE_p_FXButton swig_types[7]
+#define SWIGTYPE_p_FXCURCursor swig_types[8]
+#define SWIGTYPE_p_FXCanvas swig_types[9]
+#define SWIGTYPE_p_FXChoiceBox swig_types[10]
+#define SWIGTYPE_p_FXColorBar swig_types[11]
+#define SWIGTYPE_p_FXColorDialog swig_types[12]
+#define SWIGTYPE_p_FXColorRing swig_types[13]
+#define SWIGTYPE_p_FXColorSelector swig_types[14]
+#define SWIGTYPE_p_FXColorWell swig_types[15]
+#define SWIGTYPE_p_FXColorWheel swig_types[16]
+#define SWIGTYPE_p_FXComboBox swig_types[17]
+#define SWIGTYPE_p_FXComposite swig_types[18]
+#define SWIGTYPE_p_FXCursor swig_types[19]
+#define SWIGTYPE_p_FXDataTarget swig_types[20]
+#define SWIGTYPE_p_FXDebugTarget swig_types[21]
+#define SWIGTYPE_p_FXDelegator swig_types[22]
+#define SWIGTYPE_p_FXDial swig_types[23]
+#define SWIGTYPE_p_FXDialogBox swig_types[24]
+#define SWIGTYPE_p_FXDict swig_types[25]
+#define SWIGTYPE_p_FXDirBox swig_types[26]
+#define SWIGTYPE_p_FXDirDialog swig_types[27]
+#define SWIGTYPE_p_FXDirSelector swig_types[28]
+#define SWIGTYPE_p_FXDockBar swig_types[29]
+#define SWIGTYPE_p_FXDockHandler swig_types[30]
+#define SWIGTYPE_p_FXDockSite swig_types[31]
+#define SWIGTYPE_p_FXDockTitle swig_types[32]
+#define SWIGTYPE_p_FXDocument swig_types[33]
+#define SWIGTYPE_p_FXDragCorner swig_types[34]
+#define SWIGTYPE_p_FXDrawable swig_types[35]
+#define SWIGTYPE_p_FXDriveBox swig_types[36]
+#define SWIGTYPE_p_FXFileDialog swig_types[37]
+#define SWIGTYPE_p_FXFileDict swig_types[38]
+#define SWIGTYPE_p_FXFileSelector swig_types[39]
+#define SWIGTYPE_p_FXFileStream swig_types[40]
+#define SWIGTYPE_p_FXFont swig_types[41]
+#define SWIGTYPE_p_FXFontDesc swig_types[42]
+#define SWIGTYPE_p_FXFontDialog swig_types[43]
+#define SWIGTYPE_p_FXFontSelector swig_types[44]
+#define SWIGTYPE_p_FXFrame swig_types[45]
+#define SWIGTYPE_p_FXGIFCursor swig_types[46]
+#define SWIGTYPE_p_FXGradientBar swig_types[47]
+#define SWIGTYPE_p_FXGroupBox swig_types[48]
+#define SWIGTYPE_p_FXHeader swig_types[49]
+#define SWIGTYPE_p_FXHeaderItem swig_types[50]
+#define SWIGTYPE_p_FXHorizontalFrame swig_types[51]
+#define SWIGTYPE_p_FXHorizontalSeparator swig_types[52]
+#define SWIGTYPE_p_FXIcon swig_types[53]
+#define SWIGTYPE_p_FXIconDict swig_types[54]
+#define SWIGTYPE_p_FXId swig_types[55]
+#define SWIGTYPE_p_FXImage swig_types[56]
+#define SWIGTYPE_p_FXImageFrame swig_types[57]
+#define SWIGTYPE_p_FXImageView swig_types[58]
+#define SWIGTYPE_p_FXInputDialog swig_types[59]
+#define SWIGTYPE_p_FXKnob swig_types[60]
+#define SWIGTYPE_p_FXListBox swig_types[61]
+#define SWIGTYPE_p_FXMainWindow swig_types[62]
+#define SWIGTYPE_p_FXMatrix swig_types[63]
+#define SWIGTYPE_p_FXMemoryStream swig_types[64]
+#define SWIGTYPE_p_FXMessageBox swig_types[65]
+#define SWIGTYPE_p_FXObject swig_types[66]
+#define SWIGTYPE_p_FXPacker swig_types[67]
+#define SWIGTYPE_p_FXPopup swig_types[68]
+#define SWIGTYPE_p_FXPrintDialog swig_types[69]
+#define SWIGTYPE_p_FXPrinter swig_types[70]
+#define SWIGTYPE_p_FXProgressBar swig_types[71]
+#define SWIGTYPE_p_FXProgressDialog swig_types[72]
+#define SWIGTYPE_p_FXRealSlider swig_types[73]
+#define SWIGTYPE_p_FXRealSpinner swig_types[74]
+#define SWIGTYPE_p_FXRecentFiles swig_types[75]
+#define SWIGTYPE_p_FXRegion swig_types[76]
+#define SWIGTYPE_p_FXRegistry swig_types[77]
+#define SWIGTYPE_p_FXReplaceDialog swig_types[78]
+#define SWIGTYPE_p_FXRootWindow swig_types[79]
+#define SWIGTYPE_p_FXRuler swig_types[80]
+#define SWIGTYPE_p_FXRulerView swig_types[81]
+#define SWIGTYPE_p_FXScrollArea swig_types[82]
+#define SWIGTYPE_p_FXScrollBar swig_types[83]
+#define SWIGTYPE_p_FXScrollCorner swig_types[84]
+#define SWIGTYPE_p_FXScrollWindow swig_types[85]
+#define SWIGTYPE_p_FXSearchDialog swig_types[86]
+#define SWIGTYPE_p_FXSeparator swig_types[87]
+#define SWIGTYPE_p_FXSettings swig_types[88]
+#define SWIGTYPE_p_FXShell swig_types[89]
+#define SWIGTYPE_p_FXShutter swig_types[90]
+#define SWIGTYPE_p_FXShutterItem swig_types[91]
+#define SWIGTYPE_p_FXSlider swig_types[92]
+#define SWIGTYPE_p_FXSpinner swig_types[93]
+#define SWIGTYPE_p_FXSplashWindow swig_types[94]
+#define SWIGTYPE_p_FXSplitter swig_types[95]
+#define SWIGTYPE_p_FXSpring swig_types[96]
+#define SWIGTYPE_p_FXStatusBar swig_types[97]
+#define SWIGTYPE_p_FXStatusLine swig_types[98]
+#define SWIGTYPE_p_FXStream swig_types[99]
+#define SWIGTYPE_p_FXStringDict swig_types[100]
+#define SWIGTYPE_p_FXSwitcher swig_types[101]
+#define SWIGTYPE_p_FXTabBar swig_types[102]
+#define SWIGTYPE_p_FXTabBook swig_types[103]
+#define SWIGTYPE_p_FXTextField swig_types[104]
+#define SWIGTYPE_p_FXToolBar swig_types[105]
+#define SWIGTYPE_p_FXToolBarGrip swig_types[106]
+#define SWIGTYPE_p_FXToolBarShell swig_types[107]
+#define SWIGTYPE_p_FXToolBarTab swig_types[108]
+#define SWIGTYPE_p_FXToolTip swig_types[109]
+#define SWIGTYPE_p_FXTopWindow swig_types[110]
+#define SWIGTYPE_p_FXTranslator swig_types[111]
+#define SWIGTYPE_p_FXTreeListBox swig_types[112]
+#define SWIGTYPE_p_FXVerticalFrame swig_types[113]
+#define SWIGTYPE_p_FXVerticalSeparator swig_types[114]
+#define SWIGTYPE_p_FXVisual swig_types[115]
+#define SWIGTYPE_p_FXWindow swig_types[116]
+#define SWIGTYPE_p_FXWizard swig_types[117]
+#define SWIGTYPE_p_char swig_types[118]
+#define SWIGTYPE_p_double swig_types[119]
+#define SWIGTYPE_p_float swig_types[120]
+#define SWIGTYPE_p_int swig_types[121]
+#define SWIGTYPE_p_long swig_types[122]
+#define SWIGTYPE_p_short swig_types[123]
+#define SWIGTYPE_p_unsigned_char swig_types[124]
+#define SWIGTYPE_p_unsigned_int swig_types[125]
+#define SWIGTYPE_p_unsigned_long swig_types[126]
+#define SWIGTYPE_p_unsigned_short swig_types[127]
+static swig_type_info *swig_types[129];
+static swig_module_info swig_module = {swig_types, 128, 0, 0, 0, 0};
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
+
+/* -------- TYPES TABLE (END) -------- */
+
+#define SWIG_init    Init_dialogs
+#define SWIG_name    "Dialogs"
+
+
+
+#define SWIG_RUBY_THREAD_BEGIN_BLOCK
+#define SWIG_RUBY_THREAD_END_BLOCK
+
+
+#define SWIGVERSION 0x030012 
+#define SWIG_VERSION SWIGVERSION
+
+
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
+
+
+#include <stdexcept>
+
+
+#include "FXRbCommon.h"
+
+
+inline FXColor to_FXColor(VALUE obj){
+  if(TYPE(obj)==T_STRING){
+    return fxcolorfromname(StringValuePtr(obj));
+    }
+  else if(TYPE(obj)==T_SYMBOL){
+    return fxcolorfromname(rb_id2name(SYM2ID(obj)));
+    }
+  else{
+    return NUM2ULONG(obj);
+    }
+  }
+
+
+inline FXString to_FXString(VALUE obj){
+  if(!NIL_P(obj)){
+    Check_Type(obj,T_STRING);
+    return FXString(StringValuePtr(obj));
+    }
+  else{
+    return FXString::null;
+    }
+  }
+
+
+inline FXbool to_FXbool(VALUE obj){
+  if (obj == Qtrue || obj == Qfalse){
+    return (obj == Qtrue) ? TRUE : FALSE;
+    }
+  else{
+    return static_cast<FXbool>(NUM2UINT(obj));
+    }
+  }
+
+
+static swig_type_info* FXEventTypeInfo=0;
+
+inline void* to_FXEvent(VALUE obj){
+  void* ptr;
+  if(!FXEventTypeInfo){
+    FXEventTypeInfo=SWIG_TypeQuery("FXEvent *");
+    FXASSERT(FXEventTypeInfo!=0);
+    }
+  SWIG_ConvertPtr(obj,&ptr,FXEventTypeInfo,1);
+  return ptr;
+  }
+
+
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
+
+
+  #define SWIG_From_long   LONG2NUM 
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_int  (int value)
+{    
+  return SWIG_From_long  (value);
+}
+
+SWIGINTERN FXDialogBox *new_FXDialogBox__SWIG_0(FXApp *APP,FXString const &name,FXuint opts=DECOR_TITLE|DECOR_BORDER,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=10,FXint pr=10,FXint pt=10,FXint pb=10,FXint hs=4,FXint vs=4){
+      return new FXRbDialogBox(APP,name,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+SWIGINTERN FXDialogBox *new_FXDialogBox__SWIG_1(FXWindow *OWNER,FXString const &name,FXuint opts=DECOR_TITLE|DECOR_BORDER,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=10,FXint pr=10,FXint pt=10,FXint pb=10,FXint hs=4,FXint vs=4){
+      return new FXRbDialogBox(OWNER,name,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_bool  (bool value)
+{
+  return value ? Qtrue : Qfalse;
+}
+
+
+SWIGINTERN swig_type_info*
+SWIG_pchar_descriptor(void)
+{
+  static int init = 0;
+  static swig_type_info* info = 0;
+  if (!init) {
+    info = SWIG_TypeQuery("_p_char");
+    init = 1;
+  }
+  return info;
+}
+
+
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
+{
+  if (TYPE(obj) == T_STRING) {
+    char *cstr = StringValuePtr(obj); 
+    size_t size = RSTRING_LEN(obj) + 1;
+    if (cptr)  {
+      if (alloc) {
+	if (*alloc == SWIG_NEWOBJ) {
+	  *cptr = reinterpret_cast< char* >(memcpy(new char[size], cstr, sizeof(char)*(size)));
+	} else {
+	  *cptr = cstr;
+	  *alloc = SWIG_OLDOBJ;
+	}
+      }
+    }
+    if (psize) *psize = size;
+    return SWIG_OK;
+  } else {
+    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+    if (pchar_descriptor) {
+      void* vptr = 0;
+      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
+	if (cptr) *cptr = (char *)vptr;
+	if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
+	if (alloc) *alloc = SWIG_OLDOBJ;
+	return SWIG_OK;
+      }
+    }
+  }  
+  return SWIG_TypeError;
+}
+
+
+
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+  if (carray) {
+    if (size > LONG_MAX) {
+      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+      return pchar_descriptor ? 
+	SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : Qnil;
+    } else {
+      return rb_str_new(carray, static_cast< long >(size));
+    }
+  } else {
+    return Qnil;
+  }
+}
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtr(const char *cptr)
+{ 
+  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_long  (unsigned long value)
+{
+  return ULONG2NUM(value); 
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_int  (unsigned int value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+
+static swig_type_info *FXDialogBox_dynamic_cast(void **ptr) {
+    FXDialogBox **ppDialogBox = reinterpret_cast<FXDialogBox **>(ptr);
+    FXChoiceBox *pChoiceBox=dynamic_cast<FXChoiceBox*>(*ppDialogBox);
+    if(pChoiceBox){
+      *ptr=reinterpret_cast<void*>(pChoiceBox);
+      return SWIG_TypeQuery("FXChoiceBox *");
+      }
+    FXColorDialog *pColorDialog=dynamic_cast<FXColorDialog*>(*ppDialogBox);
+    if(pColorDialog){
+      *ptr=reinterpret_cast<void*>(pColorDialog);
+      return SWIG_TypeQuery("FXColorDialog *");
+      }
+    FXDirDialog *pDirDialog=dynamic_cast<FXDirDialog*>(*ppDialogBox);
+    if(pDirDialog){
+      *ptr=reinterpret_cast<void*>(pDirDialog);
+      return SWIG_TypeQuery("FXDirDialog *");
+      }
+    FXFileDialog *pFileDialog=dynamic_cast<FXFileDialog*>(*ppDialogBox);
+    if(pFileDialog){
+      *ptr=reinterpret_cast<void*>(pFileDialog);
+      return SWIG_TypeQuery("FXFileDialog *");
+      }
+    FXFontDialog *pFontDialog=dynamic_cast<FXFontDialog*>(*ppDialogBox);
+    if(pFontDialog){
+      *ptr=reinterpret_cast<void*>(pFontDialog);
+      return SWIG_TypeQuery("FXFontDialog *");
+      }
+    FXInputDialog *pInputDialog=dynamic_cast<FXInputDialog*>(*ppDialogBox);
+    if(pInputDialog){
+      *ptr=reinterpret_cast<void*>(pInputDialog);
+      return SWIG_TypeQuery("FXInputDialog *");
+      }
+    FXMessageBox *pMessageBox=dynamic_cast<FXMessageBox*>(*ppDialogBox);
+    if(pMessageBox){
+      *ptr=reinterpret_cast<void*>(pMessageBox);
+      return SWIG_TypeQuery("FXMessageBox *");
+      }
+    FXPrintDialog *pPrintDialog=dynamic_cast<FXPrintDialog*>(*ppDialogBox);
+    if(pPrintDialog){
+      *ptr=reinterpret_cast<void*>(pPrintDialog);
+      return SWIG_TypeQuery("FXPrintDialog *");
+      }
+    FXProgressDialog *pProgressDialog=dynamic_cast<FXProgressDialog*>(*ppDialogBox);
+    if(pProgressDialog){
+      *ptr=reinterpret_cast<void*>(pProgressDialog);
+      return SWIG_TypeQuery("FXProgressDialog *");
+      }
+    FXReplaceDialog *pReplaceDialog=dynamic_cast<FXReplaceDialog*>(*ppDialogBox);
+    if(pReplaceDialog){
+      *ptr=reinterpret_cast<void*>(pReplaceDialog);
+      return SWIG_TypeQuery("FXReplaceDialog *");
+      }
+    FXWizard *pWizard=dynamic_cast<FXWizard*>(*ppDialogBox);
+    if(pWizard){
+      *ptr=reinterpret_cast<void*>(pWizard);
+      return SWIG_TypeQuery("FXWizard *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXDirDialog *new_FXDirDialog__SWIG_0(FXWindow *owner,FXString const &name,FXuint opts=0,FXint x=0,FXint y=0,FXint w=400,FXint h=300){
+      return new FXRbDirDialog(owner,name,opts,x,y,w,h);
+      }
+SWIGINTERN FXDirDialog *new_FXDirDialog__SWIG_1(FXApp *a,FXString const &name,FXuint opts=0,FXint x=0,FXint y=0,FXint w=400,FXint h=300){
+      return new FXRbDirDialog(a,name,opts,x,y,w,h);
+      }
+SWIGINTERN FXFileDialog *new_FXFileDialog__SWIG_0(FXWindow *owner,FXString const &name,FXuint opts=0,FXint x=0,FXint y=0,FXint w=500,FXint h=300){
+      return new FXRbFileDialog(owner,name,opts,x,y,w,h);
+      }
+SWIGINTERN FXFileDialog *new_FXFileDialog__SWIG_1(FXApp *a,FXString const &name,FXuint opts=0,FXint x=0,FXint y=0,FXint w=500,FXint h=300){
+      return new FXRbFileDialog(a,name,opts,x,y,w,h);
+      }
+SWIGINTERN VALUE FXFileDialog_getFilenames(FXFileDialog const *self){
+        VALUE result = rb_ary_new();
+        FXString *filenames = self->getFilenames();
+        if (filenames) {
+            register FXString *p = filenames;
+            while ((*p) != FXString::null) {
+                rb_ary_push(result, to_ruby(*p));
+                p++;
+            }
+            delete [] filenames;
+        }
+        return result;
+    }
+SWIGINTERN void FXFileDialog_setPatternList(FXFileDialog *self,VALUE ary){
+      FXString patterns;
+      if(TYPE(ary)==T_STRING){
+        patterns=FXString(StringValuePtr(ary));
+        }
+      else if(TYPE(ary)==T_ARRAY){
+        for(long i=0; i<RARRAY_LEN(ary); i++){
+          VALUE obj=rb_ary_entry(ary,i);
+          Check_Type(obj,T_STRING);
+          patterns+=FXString(StringValuePtr(obj))+FXString("\n");
+          }
+        }
+      else{
+        rb_raise(rb_eArgError,"expected either a string, or an array of strings, as input");
+        }
+      self->setPatternList(patterns);
+      }
+SWIGINTERN VALUE FXFileDialog_getPatternList(FXFileDialog const *self){
+      FXString pat;
+      FXString patterns;
+      VALUE ary;
+      patterns=self->getPatternList();
+      ary=rb_ary_new();
+      for(FXint start=0;!(pat=patterns.section('\n',start)).empty();start++){
+	rb_ary_push(ary,to_ruby(pat.text()));
+        }
+      return ary;
+    }
+SWIGINTERN VALUE FXFileDialog_getOpenFilenames(FXWindow *owner,FXString const &caption,FXString const &path,FXString const &patterns="*",FXint initial=0){
+        VALUE result = rb_ary_new();
+        FXString *filenames = FXFileDialog::getOpenFilenames(owner, caption,
+          path, patterns, initial);
+        if (filenames) {
+            register FXString *p = filenames;
+            while ((*p) != FXString::null) {
+                rb_ary_push(result, to_ruby(*p));
+                p++;
+            }
+            delete [] filenames;
+        }
+        return result;
+    }
+SWIGINTERN FXColorDialog *new_FXColorDialog(FXWindow *owner,FXString const &name,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbColorDialog(owner,name,opts,x,y,w,h);
+      }
+SWIGINTERN FXFontDialog *new_FXFontDialog(FXWindow *owner,FXString const &name,FXuint opts=0,FXint x=0,FXint y=0,FXint w=600,FXint h=380){
+      return new FXRbFontDialog(owner,name,opts,x,y,w,h);
+      }
+SWIGINTERN FXFontDesc FXFontDialog_getFontSelection(FXFontDialog const *self){
+      FXFontDesc fontdesc;
+      self->getFontSelection(fontdesc);
+      return fontdesc;
+    }
+SWIGINTERN FXReplaceDialog *new_FXReplaceDialog(FXWindow *owner,FXString const &caption,FXIcon *ic=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbReplaceDialog(owner,caption,ic,opts,x,y,w,h);
+      }
+
+static swig_type_info *FXReplaceDialog_dynamic_cast(void **ptr) {
+    FXReplaceDialog **ppReplaceDialog = reinterpret_cast<FXReplaceDialog **>(ptr);
+    FXSearchDialog *pSearchDialog=dynamic_cast<FXSearchDialog*>(*ppReplaceDialog);
+    if(pSearchDialog){
+      *ptr=reinterpret_cast<void*>(pSearchDialog);
+      return SWIG_TypeQuery("FXSearchDialog *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXSearchDialog *new_FXSearchDialog(FXWindow *owner,FXString const &caption,FXIcon *ic=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbSearchDialog(owner,caption,ic,opts,x,y,w,h);
+      }
+SWIGINTERN FXInputDialog *new_FXInputDialog__SWIG_0(FXWindow *owner,FXString const &caption,FXString const &label,FXIcon *icon=0,FXuint opts=INPUTDIALOG_STRING,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbInputDialog(owner,caption,label,icon,opts,x,y,w,h);
+      }
+SWIGINTERN FXInputDialog *new_FXInputDialog__SWIG_1(FXApp *app,FXString const &caption,FXString const &label,FXIcon *icon=0,FXuint opts=INPUTDIALOG_STRING,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbInputDialog(app,caption,label,icon,opts,x,y,w,h);
+      }
+
+SWIGINTERN VALUE
+SWIG_ruby_failed(VALUE, VALUE)
+{
+  return Qnil;
+} 
+
+
+/*@SWIG:/usr/share/swig3.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE pargs){VALUE *args=(VALUE *)pargs;
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  double *res = (double *)(args[1]);
+  *res = NUM2DBL(obj); (void)type;
+  return obj;
+}
+/*@SWIG@*/
+
+SWIGINTERN int
+SWIG_AsVal_double (VALUE obj, double *val)
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FLOAT) || (type == T_FIXNUM) || (type == T_BIGNUM)) {
+    double v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_VALUE_METHOD_FUNC(SWIG_AUX_NUM2DBL), (VALUE)a, RUBY_VALUE_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+
+SWIGINTERN VALUE FXInputDialog_getLimits(FXInputDialog *self){
+      FXdouble lo, hi;
+      self->getLimits(lo, hi);
+      VALUE result = rb_ary_new();
+      rb_ary_push(result, rb_float_new(lo));
+      rb_ary_push(result, rb_float_new(hi));
+      return result;
+    }
+SWIGINTERN VALUE FXInputDialog_getString__SWIG_0(FXString const &initial,FXWindow *owner,FXString const &caption,FXString const &label,FXIcon *icon=0){
+      FXString result(initial);
+      if(FXInputDialog::getString(result,owner,caption,label,icon)){
+        return to_ruby(result);
+        }
+      else{
+        return Qnil;
+        }
+    }
+SWIGINTERN VALUE FXInputDialog_getString__SWIG_1(FXString const &initial,FXApp *app,FXString const &caption,FXString const &label,FXIcon *icon=0){
+      FXString result(initial);
+      if(FXInputDialog::getString(result,app,caption,label,icon)){
+        return to_ruby(result);
+        }
+      else{
+        return Qnil;
+        }
+    }
+SWIGINTERN VALUE FXInputDialog_getInteger__SWIG_0(FXint initial,FXWindow *owner,FXString const &caption,FXString const &label,FXIcon *icon=0,FXint lo=-2147483647,FXint hi=2147483647){
+      FXint result=initial;
+      if(FXInputDialog::getInteger(result,owner,caption,label,icon,lo,hi)){
+        return to_ruby(result);
+        }
+      else{
+        return Qnil;
+        }
+      }
+SWIGINTERN VALUE FXInputDialog_getInteger__SWIG_1(FXint initial,FXApp *app,FXString const &caption,FXString const &label,FXIcon *icon=0,FXint lo=-2147483647,FXint hi=2147483647){
+      FXint result=initial;
+      if(FXInputDialog::getInteger(result,app,caption,label,icon,lo,hi)){
+        return to_ruby(result);
+        }
+      else{
+        return Qnil;
+        }
+      }
+SWIGINTERN VALUE FXInputDialog_getReal__SWIG_0(FXdouble initial,FXWindow *owner,FXString const &caption,FXString const &label,FXIcon *icon=0,FXdouble lo=-1.797693134862315e+308,FXdouble hi=1.797693134862315e+308){
+      FXdouble result=initial;
+      if(FXInputDialog::getReal(result,owner,caption,label,icon,lo,hi)){
+        return to_ruby(result);
+        }
+      else{
+        return Qnil;
+        }
+      }
+SWIGINTERN VALUE FXInputDialog_getReal__SWIG_1(FXdouble initial,FXApp *app,FXString const &caption,FXString const &label,FXIcon *icon=0,FXdouble lo=-1.797693134862315e+308,FXdouble hi=1.797693134862315e+308){
+      FXdouble result=initial;
+      if(FXInputDialog::getReal(result,app,caption,label,icon,lo,hi)){
+        return to_ruby(result);
+        }
+      else{
+        return Qnil;
+        }
+      }
+SWIGINTERN FXPrintDialog *new_FXPrintDialog(FXWindow *owner,FXString const &name,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbPrintDialog(owner,name,opts,x,y,w,h);
+      }
+SWIGINTERN FXPrinter FXPrintDialog_getPrinter(FXPrintDialog *self){
+	FXPrinter pr;
+	self->getPrinter(pr);
+	return pr;
+    }
+SWIGINTERN FXProgressDialog *new_FXProgressDialog(FXWindow *owner,FXString const &caption,FXString const &label,FXuint opts=PROGRESSDIALOG_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbProgressDialog(owner,caption,label,opts,x,y,w,h);
+      }
+SWIGINTERN FXMessageBox *new_FXMessageBox__SWIG_0(FXWindow *owner,FXString const &caption,FXString const &text,FXIcon *ic=0,FXuint opts=0,FXint x=0,FXint y=0){
+      return new FXRbMessageBox(owner,caption,text,ic,opts,x,y);
+      }
+SWIGINTERN FXMessageBox *new_FXMessageBox__SWIG_1(FXApp *app,FXString const &caption,FXString const &text,FXIcon *ic=0,FXuint opts=0,FXint x=0,FXint y=0){
+      return new FXRbMessageBox(app,caption,text,ic,opts,x,y);
+      }
+SWIGINTERN FXWizard *new_FXWizard__SWIG_0(FXApp *a,FXString const &name,FXImage *image,FXuint opts=DECOR_TITLE|DECOR_BORDER|DECOR_RESIZE,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=10,FXint pr=10,FXint pt=10,FXint pb=10,FXint hs=10,FXint vs=10){
+      return new FXRbWizard(a,name,image,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+SWIGINTERN FXWizard *new_FXWizard__SWIG_1(FXWindow *owner,FXString const &name,FXImage *image,FXuint opts=DECOR_TITLE|DECOR_BORDER|DECOR_RESIZE,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=10,FXint pr=10,FXint pt=10,FXint pb=10,FXint hs=10,FXint vs=10){
+      return new FXRbWizard(owner,name,image,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+SWIGINTERN void FXWizard_setCurrentPanel(FXWizard *self,FXint index){
+      if(0<=index && index<self->getNumPanels()){
+        self->setCurrentPanel(index);
+        }
+      else{
+        rb_raise(rb_eIndexError,"panel index %d out of bounds",index);
+        }
+      }
+SWIGINTERN FXChoiceBox *new_FXChoiceBox__SWIG_0(FXWindow *owner,FXString const &caption,FXString const &text,FXIcon *icon,FXchar const **choices,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbChoiceBox(owner,caption,text,icon,choices,opts,x,y,w,h);
+      }
+SWIGINTERN FXChoiceBox *new_FXChoiceBox__SWIG_1(FXApp *app,FXString const &caption,FXString const &text,FXIcon *icon,FXchar const **choices,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbChoiceBox(app,caption,text,icon,choices,opts,x,y,w,h);
+      }
+static swig_class SwigClassFXDialogBox;
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_onCmdAccept(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","onCmdAccept", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdAccept", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdAccept(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_onCmdCancel(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","onCmdCancel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCancel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCancel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXDialogBox__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXString *arg2 = 0 ;
+  FXuint arg3 = (FXuint) DECOR_TITLE|DECOR_BORDER ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 10 ;
+  FXint arg9 = (FXint) 10 ;
+  FXint arg10 = (FXint) 10 ;
+  FXint arg11 = (FXint) 10 ;
+  FXint arg12 = (FXint) 4 ;
+  FXint arg13 = (FXint) 4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXDialogBox *result = 0 ;
+  
+  if ((argc < 2) || (argc > 13)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXDialogBox", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXDialogBox *)new_FXDialogBox__SWIG_0(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXDialogBox_allocate(VALUE self)
+#else
+_wrap_FXDialogBox_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXDialogBox);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXDialogBox__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXString *arg2 = 0 ;
+  FXuint arg3 = (FXuint) DECOR_TITLE|DECOR_BORDER ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 10 ;
+  FXint arg9 = (FXint) 10 ;
+  FXint arg10 = (FXint) 10 ;
+  FXint arg11 = (FXint) 10 ;
+  FXint arg12 = (FXint) 4 ;
+  FXint arg13 = (FXint) 4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXDialogBox *result = 0 ;
+  
+  if ((argc < 2) || (argc > 13)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXDialogBox", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXDialogBox *)new_FXDialogBox__SWIG_1(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXDialogBox(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[13];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 13) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 2) && (argc <= 13)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_new_FXDialogBox__SWIG_0(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXDialogBox__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXDialogBox__SWIG_0(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXDialogBox__SWIG_0(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXDialogBox__SWIG_0(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  if (argc <= 7) {
+                    return _wrap_new_FXDialogBox__SWIG_0(nargs, args, self);
+                  }
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    if (argc <= 8) {
+                      return _wrap_new_FXDialogBox__SWIG_0(nargs, args, self);
+                    }
+                    {
+                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
+                    }
+                    if (_v) {
+                      if (argc <= 9) {
+                        return _wrap_new_FXDialogBox__SWIG_0(nargs, args, self);
+                      }
+                      {
+                        _v = (TYPE(argv[9]) == T_FIXNUM || TYPE(argv[9]) == T_BIGNUM) ? 1 : 0;
+                      }
+                      if (_v) {
+                        if (argc <= 10) {
+                          return _wrap_new_FXDialogBox__SWIG_0(nargs, args, self);
+                        }
+                        {
+                          _v = (TYPE(argv[10]) == T_FIXNUM || TYPE(argv[10]) == T_BIGNUM) ? 1 : 0;
+                        }
+                        if (_v) {
+                          if (argc <= 11) {
+                            return _wrap_new_FXDialogBox__SWIG_0(nargs, args, self);
+                          }
+                          {
+                            _v = (TYPE(argv[11]) == T_FIXNUM || TYPE(argv[11]) == T_BIGNUM) ? 1 : 0;
+                          }
+                          if (_v) {
+                            if (argc <= 12) {
+                              return _wrap_new_FXDialogBox__SWIG_0(nargs, args, self);
+                            }
+                            {
+                              _v = (TYPE(argv[12]) == T_FIXNUM || TYPE(argv[12]) == T_BIGNUM) ? 1 : 0;
+                            }
+                            if (_v) {
+                              return _wrap_new_FXDialogBox__SWIG_0(nargs, args, self);
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 2) && (argc <= 13)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_new_FXDialogBox__SWIG_1(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXDialogBox__SWIG_1(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXDialogBox__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXDialogBox__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXDialogBox__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  if (argc <= 7) {
+                    return _wrap_new_FXDialogBox__SWIG_1(nargs, args, self);
+                  }
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    if (argc <= 8) {
+                      return _wrap_new_FXDialogBox__SWIG_1(nargs, args, self);
+                    }
+                    {
+                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
+                    }
+                    if (_v) {
+                      if (argc <= 9) {
+                        return _wrap_new_FXDialogBox__SWIG_1(nargs, args, self);
+                      }
+                      {
+                        _v = (TYPE(argv[9]) == T_FIXNUM || TYPE(argv[9]) == T_BIGNUM) ? 1 : 0;
+                      }
+                      if (_v) {
+                        if (argc <= 10) {
+                          return _wrap_new_FXDialogBox__SWIG_1(nargs, args, self);
+                        }
+                        {
+                          _v = (TYPE(argv[10]) == T_FIXNUM || TYPE(argv[10]) == T_BIGNUM) ? 1 : 0;
+                        }
+                        if (_v) {
+                          if (argc <= 11) {
+                            return _wrap_new_FXDialogBox__SWIG_1(nargs, args, self);
+                          }
+                          {
+                            _v = (TYPE(argv[11]) == T_FIXNUM || TYPE(argv[11]) == T_BIGNUM) ? 1 : 0;
+                          }
+                          if (_v) {
+                            if (argc <= 12) {
+                              return _wrap_new_FXDialogBox__SWIG_1(nargs, args, self);
+                            }
+                            {
+                              _v = (TYPE(argv[12]) == T_FIXNUM || TYPE(argv[12]) == T_BIGNUM) ? 1 : 0;
+                            }
+                            if (_v) {
+                              return _wrap_new_FXDialogBox__SWIG_1(nargs, args, self);
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 13, "FXDialogBox.new", 
+    "    FXDialogBox.new(FXApp *APP, FXString const &name, FXuint opts, FXint x, FXint y, FXint w, FXint h, FXint pl, FXint pr, FXint pt, FXint pb, FXint hs, FXint vs)\n"
+    "    FXDialogBox.new(FXWindow *OWNER, FXString const &name, FXuint opts, FXint x, FXint y, FXint w, FXint h, FXint pl, FXint pr, FXint pt, FXint pb, FXint hs, FXint vs)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_save(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDialogBox_save((FXDialogBox const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_load(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDialogBox_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_create(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  FXDialogBox_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_detach(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  FXDialogBox_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_destroy(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  FXDialogBox_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_resize(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDialogBox_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  result = (FXint)FXDialogBox_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  result = (FXint)FXDialogBox_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDialogBox_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDialogBox_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  result = (bool)FXDialogBox_canFocus((FXDialogBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  FXDialogBox_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  FXDialogBox_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXDialogBox_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXDialogBox_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_enable(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  FXDialogBox_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_disable(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  FXDialogBox_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  FXDialogBox_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_lower(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  FXDialogBox_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_move(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDialogBox_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_position(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDialogBox_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_layout(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  FXDialogBox_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_recalc(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  FXDialogBox_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_reparent(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXDialogBox_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_show__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  FXDialogBox_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_hide(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  FXDialogBox_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  result = (bool)FXDialogBox_isComposite((FXDialogBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_contains(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXDialogBox_contains((FXDialogBox const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  result = (bool)FXDialogBox_doesSaveUnder((FXDialogBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXDialogBox_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_tr(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXDialogBox_tr((FXDialogBox const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  FXDialogBox_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  FXDialogBox_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXDialogBox_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXDialogBox_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXDialogBox_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDialogBox_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDialogBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDialogBox_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDialogBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDialogBox_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDialogBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDialogBox_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  FXDialogBox_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_show__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  FXDialogBox_show(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDialogBox_show(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDialogBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXDialogBox_show__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDialogBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXDialogBox_show__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "show", 
+    "    void show()\n"
+    "    void show(FXuint placement)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_maximize(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","maximize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXDialogBox_maximize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_minimize(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","minimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXDialogBox_minimize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_restore(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXDialogBox_restore(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_close(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","close", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXDialogBox_close(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDialogBox_execute(int argc, VALUE *argv, VALUE self) {
+  FXDialogBox *arg1 = (FXDialogBox *) 0 ;
+  FXuint arg2 = (FXuint) PLACEMENT_CURSOR ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDialogBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDialogBox *","execute", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDialogBox * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  result = (FXuint)FXDialogBox_execute(arg1,arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXDirDialog;
+
+SWIGINTERN VALUE
+_wrap_new_FXDirDialog__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXString *arg2 = 0 ;
+  FXuint arg3 = (FXuint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 400 ;
+  FXint arg7 = (FXint) 300 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXDirDialog *result = 0 ;
+  
+  if ((argc < 2) || (argc > 7)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXDirDialog", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXDirDialog *)new_FXDirDialog__SWIG_0(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXDirDialog_allocate(VALUE self)
+#else
+_wrap_FXDirDialog_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXDirDialog);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXDirDialog__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXString *arg2 = 0 ;
+  FXuint arg3 = (FXuint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 400 ;
+  FXint arg7 = (FXint) 300 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXDirDialog *result = 0 ;
+  
+  if ((argc < 2) || (argc > 7)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXDirDialog", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXDirDialog *)new_FXDirDialog__SWIG_1(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXDirDialog(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[7];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 7) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 2) && (argc <= 7)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_new_FXDirDialog__SWIG_0(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXDirDialog__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXDirDialog__SWIG_0(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXDirDialog__SWIG_0(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXDirDialog__SWIG_0(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  return _wrap_new_FXDirDialog__SWIG_0(nargs, args, self);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 2) && (argc <= 7)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_new_FXDirDialog__SWIG_1(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXDirDialog__SWIG_1(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXDirDialog__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXDirDialog__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXDirDialog__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  return _wrap_new_FXDirDialog__SWIG_1(nargs, args, self);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 7, "FXDirDialog.new", 
+    "    FXDirDialog.new(FXWindow *owner, FXString const &name, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n"
+    "    FXDirDialog.new(FXApp *a, FXString const &name, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_setDirectory(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","setDirectory", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setDirectory((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_getDirectory(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog const *","getDirectory", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  result = ((FXDirDialog const *)arg1)->getDirectory();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_getShowFiles(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog const *","showFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  result = (FXbool)((FXDirDialog const *)arg1)->showFiles();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_setShowFiles(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","showFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->showFiles(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_getShowHiddenFiles(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog const *","showHiddenFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  result = (FXbool)((FXDirDialog const *)arg1)->showHiddenFiles();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_setShowHiddenFiles(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","showHiddenFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->showHiddenFiles(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_getMatchMode(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog const *","getMatchMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  result = (FXuint)((FXDirDialog const *)arg1)->getMatchMode();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_setMatchMode(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","setMatchMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setMatchMode(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_setDirBoxStyle(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","setDirBoxStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setDirBoxStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_getDirBoxStyle(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog const *","getDirBoxStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  result = (FXuint)((FXDirDialog const *)arg1)->getDirBoxStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_getOpenDirectory(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXString *arg2 = 0 ;
+  FXString *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  SwigValueWrapper< FXString > p3 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXDirDialog::getOpenDirectory", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  p3 = to_FXString(argv[2]); arg3 = &p3;
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = FXDirDialog::getOpenDirectory(arg1,(FXString const &)*arg2,(FXString const &)*arg3);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_save(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDirDialog_save((FXDirDialog const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_load(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDirDialog_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_create(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  FXDirDialog_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_detach(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  FXDirDialog_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_destroy(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  FXDirDialog_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_resize(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDirDialog_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  result = (FXint)FXDirDialog_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  result = (FXint)FXDirDialog_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDirDialog_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDirDialog_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  result = (bool)FXDirDialog_canFocus((FXDirDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  FXDirDialog_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  FXDirDialog_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXDirDialog_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXDirDialog_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_enable(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  FXDirDialog_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_disable(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  FXDirDialog_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  FXDirDialog_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_lower(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  FXDirDialog_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_move(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDirDialog_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_position(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDirDialog_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_layout(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  FXDirDialog_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_recalc(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  FXDirDialog_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_reparent(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXDirDialog_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_show__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  FXDirDialog_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_hide(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  FXDirDialog_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  result = (bool)FXDirDialog_isComposite((FXDirDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_contains(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXDirDialog_contains((FXDirDialog const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  result = (bool)FXDirDialog_doesSaveUnder((FXDirDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXDirDialog_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_tr(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXDirDialog_tr((FXDirDialog const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  FXDirDialog_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  FXDirDialog_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXDirDialog_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXDirDialog_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXDirDialog_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDirDialog_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDirDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDirDialog_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDirDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDirDialog_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDirDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDirDialog_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  FXDirDialog_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_show__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  FXDirDialog_show(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDirDialog_show(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDirDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXDirDialog_show__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDirDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXDirDialog_show__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "show", 
+    "    void show()\n"
+    "    void show(FXuint placement)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_maximize(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","maximize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXDirDialog_maximize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_minimize(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","minimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXDirDialog_minimize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_restore(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXDirDialog_restore(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_close(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","close", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXDirDialog_close(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirDialog_execute(int argc, VALUE *argv, VALUE self) {
+  FXDirDialog *arg1 = (FXDirDialog *) 0 ;
+  FXuint arg2 = (FXuint) PLACEMENT_CURSOR ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirDialog *","execute", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  result = (FXuint)FXDirDialog_execute(arg1,arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXFileDialog;
+
+SWIGINTERN VALUE
+_wrap_new_FXFileDialog__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXString *arg2 = 0 ;
+  FXuint arg3 = (FXuint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 500 ;
+  FXint arg7 = (FXint) 300 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXFileDialog *result = 0 ;
+  
+  if ((argc < 2) || (argc > 7)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXFileDialog", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXFileDialog *)new_FXFileDialog__SWIG_0(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXFileDialog_allocate(VALUE self)
+#else
+_wrap_FXFileDialog_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXFileDialog);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXFileDialog__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXString *arg2 = 0 ;
+  FXuint arg3 = (FXuint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 500 ;
+  FXint arg7 = (FXint) 300 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXFileDialog *result = 0 ;
+  
+  if ((argc < 2) || (argc > 7)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXFileDialog", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXFileDialog *)new_FXFileDialog__SWIG_1(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXFileDialog(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[7];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 7) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 2) && (argc <= 7)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_new_FXFileDialog__SWIG_0(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXFileDialog__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXFileDialog__SWIG_0(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXFileDialog__SWIG_0(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXFileDialog__SWIG_0(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  return _wrap_new_FXFileDialog__SWIG_0(nargs, args, self);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 2) && (argc <= 7)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_new_FXFileDialog__SWIG_1(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXFileDialog__SWIG_1(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXFileDialog__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXFileDialog__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXFileDialog__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  return _wrap_new_FXFileDialog__SWIG_1(nargs, args, self);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 7, "FXFileDialog.new", 
+    "    FXFileDialog.new(FXWindow *owner, FXString const &name, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n"
+    "    FXFileDialog.new(FXApp *a, FXString const &name, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_setFilename(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","setFilename", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setFilename((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getFilename(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","getFilename", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  result = ((FXFileDialog const *)arg1)->getFilename();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getFilenames(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","getFilenames", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  result = (VALUE)FXFileDialog_getFilenames((FXFileDialog const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_setPattern(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","setPattern", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setPattern((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getPattern(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","getPattern", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  result = ((FXFileDialog const *)arg1)->getPattern();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_setPatternList(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","setPatternList", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = argv[0];
+  FXFileDialog_setPatternList(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getPatternList(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","getPatternList", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  result = (VALUE)FXFileDialog_getPatternList((FXFileDialog const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_setCurrentPattern(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","setCurrentPattern", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setCurrentPattern(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getCurrentPattern(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","getCurrentPattern", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  result = (FXint)((FXFileDialog const *)arg1)->getCurrentPattern();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getPatternText(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","getPatternText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = ((FXFileDialog const *)arg1)->getPatternText(arg2);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_setPatternText(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","setPatternText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  (arg1)->setPatternText(arg2,(FXString const &)*arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_numPatterns(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","getNumPatterns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  result = (FXint)((FXFileDialog const *)arg1)->getNumPatterns();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_setAllowPatternEntry(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","allowPatternEntry", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->allowPatternEntry(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getAllowPatternEntry(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","allowPatternEntry", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  result = (FXbool)((FXFileDialog const *)arg1)->allowPatternEntry();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_setDirectory(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","setDirectory", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setDirectory((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getDirectory(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","getDirectory", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  result = ((FXFileDialog const *)arg1)->getDirectory();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_setItemSpace(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","setItemSpace", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setItemSpace(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getItemSpace(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","getItemSpace", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  result = (FXint)((FXFileDialog const *)arg1)->getItemSpace();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_setSelectMode(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","setSelectMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setSelectMode(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getSelectMode(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","getSelectMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  result = (FXuint)((FXFileDialog const *)arg1)->getSelectMode();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_setMatchMode(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","setMatchMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setMatchMode(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getMatchMode(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","getMatchMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  result = (FXuint)((FXFileDialog const *)arg1)->getMatchMode();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getShowHiddenFiles(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","showHiddenFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  result = (FXbool)((FXFileDialog const *)arg1)->showHiddenFiles();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_setShowHiddenFiles(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","showHiddenFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->showHiddenFiles(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getShowImages(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","showImages", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  result = (FXbool)((FXFileDialog const *)arg1)->showImages();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_setShowImages(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","showImages", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->showImages(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getImageSize(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","getImageSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  result = (FXint)((FXFileDialog const *)arg1)->getImageSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_setImageSize(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","setImageSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setImageSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_showReadOnly(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","showReadOnly", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->showReadOnly(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_shownReadOnly(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","shownReadOnly", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  result = (FXbool)((FXFileDialog const *)arg1)->shownReadOnly();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_setReadOnly(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","setReadOnly", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->setReadOnly(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getReadOnly(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","getReadOnly", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  result = (FXbool)((FXFileDialog const *)arg1)->getReadOnly();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_setFileBoxStyle(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","setFileBoxStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setFileBoxStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getFileBoxStyle(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","getFileBoxStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  result = (FXuint)((FXFileDialog const *)arg1)->getFileBoxStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_navigationAllowede___(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","allowNavigation", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->allowNavigation(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_navigationAllowedq___(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","allowNavigation", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  result = (FXbool)((FXFileDialog const *)arg1)->allowNavigation();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getOpenFilename(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXString *arg2 = 0 ;
+  FXString *arg3 = 0 ;
+  FXString const &arg4_defvalue = "*" ;
+  FXString *arg4 = (FXString *) &arg4_defvalue ;
+  FXint arg5 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  SwigValueWrapper< FXString > p3 ;
+  SwigValueWrapper< FXString > p4 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXFileDialog::getOpenFilename", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  p3 = to_FXString(argv[2]); arg3 = &p3;
+  if (argc > 3) {
+    p4 = to_FXString(argv[3]); arg4 = &p4;
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = FXFileDialog::getOpenFilename(arg1,(FXString const &)*arg2,(FXString const &)*arg3,(FXString const &)*arg4,arg5);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getOpenFilenames(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXString *arg2 = 0 ;
+  FXString *arg3 = 0 ;
+  FXString const &arg4_defvalue = "*" ;
+  FXString *arg4 = (FXString *) &arg4_defvalue ;
+  FXint arg5 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  SwigValueWrapper< FXString > p3 ;
+  SwigValueWrapper< FXString > p4 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXFileDialog_getOpenFilenames", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  p3 = to_FXString(argv[2]); arg3 = &p3;
+  if (argc > 3) {
+    p4 = to_FXString(argv[3]); arg4 = &p4;
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = (VALUE)FXFileDialog_getOpenFilenames(arg1,(FXString const &)*arg2,(FXString const &)*arg3,(FXString const &)*arg4,arg5);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getSaveFilename(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXString *arg2 = 0 ;
+  FXString *arg3 = 0 ;
+  FXString const &arg4_defvalue = "*" ;
+  FXString *arg4 = (FXString *) &arg4_defvalue ;
+  FXint arg5 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  SwigValueWrapper< FXString > p3 ;
+  SwigValueWrapper< FXString > p4 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXFileDialog::getSaveFilename", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  p3 = to_FXString(argv[2]); arg3 = &p3;
+  if (argc > 3) {
+    p4 = to_FXString(argv[3]); arg4 = &p4;
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = FXFileDialog::getSaveFilename(arg1,(FXString const &)*arg2,(FXString const &)*arg3,(FXString const &)*arg4,arg5);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getOpenDirectory(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXString *arg2 = 0 ;
+  FXString *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  SwigValueWrapper< FXString > p3 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXFileDialog::getOpenDirectory", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  p3 = to_FXString(argv[2]); arg3 = &p3;
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = FXFileDialog::getOpenDirectory(arg1,(FXString const &)*arg2,(FXString const &)*arg3);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_save(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXFileDialog_save((FXFileDialog const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_load(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXFileDialog_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_create(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  FXFileDialog_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_detach(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  FXFileDialog_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_destroy(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  FXFileDialog_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_resize(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXFileDialog_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  result = (FXint)FXFileDialog_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  result = (FXint)FXFileDialog_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXFileDialog_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXFileDialog_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  result = (bool)FXFileDialog_canFocus((FXFileDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  FXFileDialog_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  FXFileDialog_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXFileDialog_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXFileDialog_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_enable(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  FXFileDialog_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_disable(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  FXFileDialog_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  FXFileDialog_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_lower(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  FXFileDialog_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_move(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXFileDialog_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_position(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXFileDialog_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_layout(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  FXFileDialog_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_recalc(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  FXFileDialog_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_reparent(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXFileDialog_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_show__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  FXFileDialog_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_hide(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  FXFileDialog_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  result = (bool)FXFileDialog_isComposite((FXFileDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_contains(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXFileDialog_contains((FXFileDialog const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  result = (bool)FXFileDialog_doesSaveUnder((FXFileDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXFileDialog_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_tr(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXFileDialog_tr((FXFileDialog const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  FXFileDialog_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  FXFileDialog_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXFileDialog_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXFileDialog_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXFileDialog_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXFileDialog_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFileDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXFileDialog_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFileDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXFileDialog_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFileDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXFileDialog_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  FXFileDialog_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_show__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  FXFileDialog_show(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXFileDialog_show(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFileDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXFileDialog_show__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFileDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXFileDialog_show__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "show", 
+    "    void show()\n"
+    "    void show(FXuint placement)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_maximize(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","maximize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXFileDialog_maximize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_minimize(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","minimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXFileDialog_minimize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_restore(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXFileDialog_restore(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_close(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","close", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXFileDialog_close(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileDialog_execute(int argc, VALUE *argv, VALUE self) {
+  FXFileDialog *arg1 = (FXFileDialog *) 0 ;
+  FXuint arg2 = (FXuint) PLACEMENT_CURSOR ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileDialog *","execute", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  result = (FXuint)FXFileDialog_execute(arg1,arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXColorDialog;
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_onChgColor(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","onChgColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onChgColor", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2UINT(argv[2]));
+  result = (long)(arg1)->onChgColor(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_onCmdColor(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","onCmdColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdColor", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2UINT(argv[2]));
+  result = (long)(arg1)->onCmdColor(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXColorDialog_allocate(VALUE self)
+#else
+_wrap_FXColorDialog_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXColorDialog);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXColorDialog(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXString *arg2 = 0 ;
+  FXuint arg3 = (FXuint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXColorDialog *result = 0 ;
+  
+  if ((argc < 2) || (argc > 7)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXColorDialog", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXColorDialog *)new_FXColorDialog(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_setRGBA(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","setRGBA", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setRGBA(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_getRGBA(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog const *","getRGBA", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  result = (FXColor)((FXColorDialog const *)arg1)->getRGBA();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_isOpaqueOnly(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog const *","isOpaqueOnly", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  result = (FXbool)((FXColorDialog const *)arg1)->isOpaqueOnly();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_setOpaqueOnly(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","setOpaqueOnly", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->setOpaqueOnly(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_save(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXColorDialog_save((FXColorDialog const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_load(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXColorDialog_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_create(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  FXColorDialog_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_detach(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  FXColorDialog_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_destroy(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  FXColorDialog_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_resize(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXColorDialog_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  result = (FXint)FXColorDialog_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  result = (FXint)FXColorDialog_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXColorDialog_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXColorDialog_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  result = (bool)FXColorDialog_canFocus((FXColorDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  FXColorDialog_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  FXColorDialog_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXColorDialog_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXColorDialog_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_enable(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  FXColorDialog_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_disable(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  FXColorDialog_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  FXColorDialog_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_lower(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  FXColorDialog_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_move(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXColorDialog_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_position(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXColorDialog_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_layout(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  FXColorDialog_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_recalc(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  FXColorDialog_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_reparent(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXColorDialog_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_show__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  FXColorDialog_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_hide(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  FXColorDialog_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  result = (bool)FXColorDialog_isComposite((FXColorDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_contains(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXColorDialog_contains((FXColorDialog const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  result = (bool)FXColorDialog_doesSaveUnder((FXColorDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXColorDialog_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_tr(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXColorDialog_tr((FXColorDialog const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  FXColorDialog_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  FXColorDialog_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXColorDialog_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXColorDialog_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXColorDialog_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXColorDialog_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXColorDialog_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXColorDialog_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXColorDialog_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  FXColorDialog_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_show__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  FXColorDialog_show(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXColorDialog_show(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXColorDialog_show__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXColorDialog_show__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "show", 
+    "    void show()\n"
+    "    void show(FXuint placement)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_maximize(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","maximize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXColorDialog_maximize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_minimize(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","minimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXColorDialog_minimize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_restore(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXColorDialog_restore(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_close(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","close", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXColorDialog_close(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorDialog_execute(int argc, VALUE *argv, VALUE self) {
+  FXColorDialog *arg1 = (FXColorDialog *) 0 ;
+  FXuint arg2 = (FXuint) PLACEMENT_CURSOR ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorDialog *","execute", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  result = (FXuint)FXColorDialog_execute(arg1,arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXFontDialog;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXFontDialog_allocate(VALUE self)
+#else
+_wrap_FXFontDialog_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXFontDialog);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXFontDialog(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXString *arg2 = 0 ;
+  FXuint arg3 = (FXuint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 600 ;
+  FXint arg7 = (FXint) 380 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXFontDialog *result = 0 ;
+  
+  if ((argc < 2) || (argc > 7)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXFontDialog", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXFontDialog *)new_FXFontDialog(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_setFontSelection(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  FXFontDesc *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","setFontSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXFontDesc,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFontDesc const &","setFontSelection", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXFontDesc const &","setFontSelection", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXFontDesc * >(argp2);
+  (arg1)->setFontSelection((FXFontDesc const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_getFontSelection(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFontDesc result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog const *","getFontSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  result = FXFontDialog_getFontSelection((FXFontDialog const *)arg1);
+  {
+    FXFontDesc* resultptr = new FXFontDesc(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXFontDesc *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_save(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXFontDialog_save((FXFontDialog const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_load(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXFontDialog_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_create(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  FXFontDialog_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_detach(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  FXFontDialog_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_destroy(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  FXFontDialog_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_resize(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXFontDialog_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  result = (FXint)FXFontDialog_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  result = (FXint)FXFontDialog_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXFontDialog_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXFontDialog_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  result = (bool)FXFontDialog_canFocus((FXFontDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  FXFontDialog_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  FXFontDialog_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXFontDialog_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXFontDialog_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_enable(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  FXFontDialog_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_disable(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  FXFontDialog_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  FXFontDialog_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_lower(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  FXFontDialog_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_move(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXFontDialog_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_position(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXFontDialog_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_layout(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  FXFontDialog_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_recalc(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  FXFontDialog_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_reparent(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXFontDialog_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_show__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  FXFontDialog_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_hide(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  FXFontDialog_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  result = (bool)FXFontDialog_isComposite((FXFontDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_contains(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXFontDialog_contains((FXFontDialog const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  result = (bool)FXFontDialog_doesSaveUnder((FXFontDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXFontDialog_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_tr(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXFontDialog_tr((FXFontDialog const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  FXFontDialog_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  FXFontDialog_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXFontDialog_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXFontDialog_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXFontDialog_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXFontDialog_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFontDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXFontDialog_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFontDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXFontDialog_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFontDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXFontDialog_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  FXFontDialog_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_show__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  FXFontDialog_show(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXFontDialog_show(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFontDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXFontDialog_show__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFontDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXFontDialog_show__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "show", 
+    "    void show()\n"
+    "    void show(FXuint placement)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_maximize(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","maximize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXFontDialog_maximize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_minimize(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","minimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXFontDialog_minimize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_restore(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXFontDialog_restore(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_close(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","close", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXFontDialog_close(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontDialog_execute(int argc, VALUE *argv, VALUE self) {
+  FXFontDialog *arg1 = (FXFontDialog *) 0 ;
+  FXuint arg2 = (FXuint) PLACEMENT_CURSOR ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontDialog *","execute", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  result = (FXuint)FXFontDialog_execute(arg1,arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXReplaceDialog;
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_onCmdAll(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","onCmdAll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdAll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdAll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_onCmdNext(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","onCmdNext", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdNext", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdNext(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_onUpdDir(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","onUpdDir", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdDir", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdDir(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_onCmdDir(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","onCmdDir", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDir", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDir(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_onUpdMode(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","onUpdMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdMode", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdMode(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_onCmdMode(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","onCmdMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMode", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdMode(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_onSearchKey(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","onSearchKey", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSearchKey", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onSearchKey(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_onReplaceKey(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","onReplaceKey", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onReplaceKey", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onReplaceKey(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_onCmdSearchHist(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","onCmdSearchHist", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSearchHist", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSearchHist(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_onCmdReplaceHist(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","onCmdReplaceHist", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdReplaceHist", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdReplaceHist(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_onCmdAccept(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","onCmdAccept", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdAccept", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdAccept(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXReplaceDialog_allocate(VALUE self)
+#else
+_wrap_FXReplaceDialog_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXReplaceDialog);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXReplaceDialog(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXReplaceDialog *result = 0 ;
+  
+  if ((argc < 2) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXReplaceDialog", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","FXReplaceDialog", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXReplaceDialog *)new_FXReplaceDialog(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_setSearchText(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","setSearchText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setSearchText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_getSearchText(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog const *","getSearchText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  result = ((FXReplaceDialog const *)arg1)->getSearchText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_setReplaceText(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","setReplaceText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setReplaceText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_getReplaceText(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog const *","getReplaceText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  result = ((FXReplaceDialog const *)arg1)->getReplaceText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_setSearchMode(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","setSearchMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setSearchMode(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_getSearchMode(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog const *","getSearchMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  result = (FXuint)((FXReplaceDialog const *)arg1)->getSearchMode();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_save(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXReplaceDialog_save((FXReplaceDialog const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_load(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXReplaceDialog_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_create(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  FXReplaceDialog_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_detach(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  FXReplaceDialog_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_destroy(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  FXReplaceDialog_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_resize(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXReplaceDialog_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  result = (FXint)FXReplaceDialog_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  result = (FXint)FXReplaceDialog_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXReplaceDialog_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXReplaceDialog_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  result = (bool)FXReplaceDialog_canFocus((FXReplaceDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  FXReplaceDialog_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  FXReplaceDialog_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXReplaceDialog_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXReplaceDialog_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_enable(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  FXReplaceDialog_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_disable(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  FXReplaceDialog_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  FXReplaceDialog_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_lower(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  FXReplaceDialog_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_move(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXReplaceDialog_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_position(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXReplaceDialog_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_layout(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  FXReplaceDialog_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_recalc(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  FXReplaceDialog_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_reparent(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXReplaceDialog_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_show__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  FXReplaceDialog_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_hide(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  FXReplaceDialog_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  result = (bool)FXReplaceDialog_isComposite((FXReplaceDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_contains(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXReplaceDialog_contains((FXReplaceDialog const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  result = (bool)FXReplaceDialog_doesSaveUnder((FXReplaceDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXReplaceDialog_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_tr(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXReplaceDialog_tr((FXReplaceDialog const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  FXReplaceDialog_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  FXReplaceDialog_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXReplaceDialog_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXReplaceDialog_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXReplaceDialog_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXReplaceDialog_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXReplaceDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXReplaceDialog_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXReplaceDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXReplaceDialog_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXReplaceDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXReplaceDialog_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  FXReplaceDialog_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_show__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  FXReplaceDialog_show(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXReplaceDialog_show(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXReplaceDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXReplaceDialog_show__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXReplaceDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXReplaceDialog_show__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "show", 
+    "    void show()\n"
+    "    void show(FXuint placement)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_maximize(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","maximize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXReplaceDialog_maximize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_minimize(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","minimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXReplaceDialog_minimize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_restore(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXReplaceDialog_restore(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_close(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","close", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXReplaceDialog_close(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXReplaceDialog_execute(int argc, VALUE *argv, VALUE self) {
+  FXReplaceDialog *arg1 = (FXReplaceDialog *) 0 ;
+  FXuint arg2 = (FXuint) PLACEMENT_CURSOR ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXReplaceDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXReplaceDialog *","execute", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXReplaceDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  result = (FXuint)FXReplaceDialog_execute(arg1,arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXSearchDialog;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXSearchDialog_allocate(VALUE self)
+#else
+_wrap_FXSearchDialog_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXSearchDialog);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSearchDialog(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXSearchDialog *result = 0 ;
+  
+  if ((argc < 2) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXSearchDialog", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","FXSearchDialog", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXSearchDialog *)new_FXSearchDialog(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_save(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXSearchDialog_save((FXSearchDialog const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_load(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXSearchDialog_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_create(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  FXSearchDialog_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_detach(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  FXSearchDialog_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_destroy(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  FXSearchDialog_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_resize(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXSearchDialog_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  result = (FXint)FXSearchDialog_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  result = (FXint)FXSearchDialog_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXSearchDialog_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXSearchDialog_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  result = (bool)FXSearchDialog_canFocus((FXSearchDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  FXSearchDialog_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  FXSearchDialog_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXSearchDialog_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXSearchDialog_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_enable(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  FXSearchDialog_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_disable(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  FXSearchDialog_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  FXSearchDialog_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_lower(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  FXSearchDialog_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_move(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXSearchDialog_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_position(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXSearchDialog_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_layout(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  FXSearchDialog_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_recalc(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  FXSearchDialog_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_reparent(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXSearchDialog_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_show__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  FXSearchDialog_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_hide(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  FXSearchDialog_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  result = (bool)FXSearchDialog_isComposite((FXSearchDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_contains(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXSearchDialog_contains((FXSearchDialog const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  result = (bool)FXSearchDialog_doesSaveUnder((FXSearchDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXSearchDialog_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_tr(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXSearchDialog_tr((FXSearchDialog const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  FXSearchDialog_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  FXSearchDialog_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXSearchDialog_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXSearchDialog_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXSearchDialog_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXSearchDialog_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSearchDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSearchDialog_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSearchDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSearchDialog_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSearchDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSearchDialog_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  FXSearchDialog_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_show__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  FXSearchDialog_show(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXSearchDialog_show(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSearchDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXSearchDialog_show__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSearchDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXSearchDialog_show__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "show", 
+    "    void show()\n"
+    "    void show(FXuint placement)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_maximize(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","maximize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXSearchDialog_maximize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_minimize(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","minimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXSearchDialog_minimize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_restore(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXSearchDialog_restore(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_close(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","close", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXSearchDialog_close(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSearchDialog_execute(int argc, VALUE *argv, VALUE self) {
+  FXSearchDialog *arg1 = (FXSearchDialog *) 0 ;
+  FXuint arg2 = (FXuint) PLACEMENT_CURSOR ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSearchDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSearchDialog *","execute", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSearchDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  result = (FXuint)FXSearchDialog_execute(arg1,arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXInputDialog;
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_onCmdAccept(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","onCmdAccept", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdAccept", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdAccept(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXInputDialog__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXString *arg2 = 0 ;
+  FXString *arg3 = 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXuint arg5 = (FXuint) INPUTDIALOG_STRING ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  SwigValueWrapper< FXString > p3 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXInputDialog *result = 0 ;
+  
+  if ((argc < 3) || (argc > 9)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXInputDialog", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  p3 = to_FXString(argv[2]); arg3 = &p3;
+  if (argc > 3) {
+    res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","FXInputDialog", 4, argv[3] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXInputDialog *)new_FXInputDialog__SWIG_0(arg1,(FXString const &)*arg2,(FXString const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXInputDialog_allocate(VALUE self)
+#else
+_wrap_FXInputDialog_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXInputDialog);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXInputDialog__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXString *arg2 = 0 ;
+  FXString *arg3 = 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXuint arg5 = (FXuint) INPUTDIALOG_STRING ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  SwigValueWrapper< FXString > p3 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXInputDialog *result = 0 ;
+  
+  if ((argc < 3) || (argc > 9)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXInputDialog", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  p3 = to_FXString(argv[2]); arg3 = &p3;
+  if (argc > 3) {
+    res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","FXInputDialog", 4, argv[3] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXInputDialog *)new_FXInputDialog__SWIG_1(arg1,(FXString const &)*arg2,(FXString const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXInputDialog(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[9];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 9) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 3) && (argc <= 9)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXInputDialog__SWIG_0(nargs, args, self);
+          }
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXInputDialog__SWIG_0(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXInputDialog__SWIG_0(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXInputDialog__SWIG_0(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  if (argc <= 7) {
+                    return _wrap_new_FXInputDialog__SWIG_0(nargs, args, self);
+                  }
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    if (argc <= 8) {
+                      return _wrap_new_FXInputDialog__SWIG_0(nargs, args, self);
+                    }
+                    {
+                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
+                    }
+                    if (_v) {
+                      return _wrap_new_FXInputDialog__SWIG_0(nargs, args, self);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 3) && (argc <= 9)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXInputDialog__SWIG_1(nargs, args, self);
+          }
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXInputDialog__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXInputDialog__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXInputDialog__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  if (argc <= 7) {
+                    return _wrap_new_FXInputDialog__SWIG_1(nargs, args, self);
+                  }
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    if (argc <= 8) {
+                      return _wrap_new_FXInputDialog__SWIG_1(nargs, args, self);
+                    }
+                    {
+                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
+                    }
+                    if (_v) {
+                      return _wrap_new_FXInputDialog__SWIG_1(nargs, args, self);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 9, "FXInputDialog.new", 
+    "    FXInputDialog.new(FXWindow *owner, FXString const &caption, FXString const &label, FXIcon *icon, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n"
+    "    FXInputDialog.new(FXApp *app, FXString const &caption, FXString const &label, FXIcon *icon, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_getText(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog const *","getText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  result = ((FXInputDialog const *)arg1)->getText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_setText(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","setText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_setNumColumns(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","setNumColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setNumColumns(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_getNumColumns(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog const *","getNumColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  result = (FXint)((FXInputDialog const *)arg1)->getNumColumns();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_setLimits(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","setLimits", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","setLimits", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","setLimits", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  (arg1)->setLimits(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_getLimits(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","getLimits", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  result = (VALUE)FXInputDialog_getLimits(arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_getString__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXString *arg1 = 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXString *arg3 = 0 ;
+  FXString *arg4 = 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  SwigValueWrapper< FXString > p1 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  SwigValueWrapper< FXString > p4 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  p1 = to_FXString(argv[0]); arg1 = &p1;
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","FXInputDialog_getString__SWIG_0", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  p3 = to_FXString(argv[2]); arg3 = &p3;
+  p4 = to_FXString(argv[3]); arg4 = &p4;
+  if (argc > 4) {
+    res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","FXInputDialog_getString__SWIG_0", 5, argv[4] )); 
+    }
+    arg5 = reinterpret_cast< FXIcon * >(argp5);
+  }
+  {
+    if (!arg2) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = (VALUE)FXInputDialog_getString__SWIG_0((FXString const &)*arg1,arg2,(FXString const &)*arg3,(FXString const &)*arg4,arg5);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_getString__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXString *arg1 = 0 ;
+  FXApp *arg2 = (FXApp *) 0 ;
+  FXString *arg3 = 0 ;
+  FXString *arg4 = 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  SwigValueWrapper< FXString > p1 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  SwigValueWrapper< FXString > p4 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  p1 = to_FXString(argv[0]); arg1 = &p1;
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXApp *","FXInputDialog_getString__SWIG_1", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXApp * >(argp2);
+  p3 = to_FXString(argv[2]); arg3 = &p3;
+  p4 = to_FXString(argv[3]); arg4 = &p4;
+  if (argc > 4) {
+    res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","FXInputDialog_getString__SWIG_1", 5, argv[4] )); 
+    }
+    arg5 = reinterpret_cast< FXIcon * >(argp5);
+  }
+  {
+    if (!arg2) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = (VALUE)FXInputDialog_getString__SWIG_1((FXString const &)*arg1,arg2,(FXString const &)*arg3,(FXString const &)*arg4,arg5);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXInputDialog_getString(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 5) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 4) && (argc <= 5)) {
+    int _v;
+    {
+      _v = (NIL_P(argv[0]) || TYPE(argv[0]) == T_STRING) ? 1 : 0;
+    }
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXWindow, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (NIL_P(argv[3]) || TYPE(argv[3]) == T_STRING) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXInputDialog_getString__SWIG_0(nargs, args, self);
+            }
+            void *vptr = 0;
+            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_FXIcon, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              return _wrap_FXInputDialog_getString__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 4) && (argc <= 5)) {
+    int _v;
+    {
+      _v = (NIL_P(argv[0]) || TYPE(argv[0]) == T_STRING) ? 1 : 0;
+    }
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXApp, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (NIL_P(argv[3]) || TYPE(argv[3]) == T_STRING) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXInputDialog_getString__SWIG_1(nargs, args, self);
+            }
+            void *vptr = 0;
+            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_FXIcon, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              return _wrap_FXInputDialog_getString__SWIG_1(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 5, "getString", 
+    "    VALUE getString(FXString const &initial, FXWindow *owner, FXString const &caption, FXString const &label, FXIcon *icon)\n"
+    "    VALUE getString(FXString const &initial, FXApp *app, FXString const &caption, FXString const &label, FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_getInteger__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXint arg1 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXString *arg3 = 0 ;
+  FXString *arg4 = 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  FXint arg6 = (FXint) -2147483647 ;
+  FXint arg7 = (FXint) 2147483647 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  SwigValueWrapper< FXString > p4 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 7)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  arg1 = NUM2INT(argv[0]);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","FXInputDialog_getInteger__SWIG_0", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  p3 = to_FXString(argv[2]); arg3 = &p3;
+  p4 = to_FXString(argv[3]); arg4 = &p4;
+  if (argc > 4) {
+    res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","FXInputDialog_getInteger__SWIG_0", 5, argv[4] )); 
+    }
+    arg5 = reinterpret_cast< FXIcon * >(argp5);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  {
+    if (!arg2) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = (VALUE)FXInputDialog_getInteger__SWIG_0(arg1,arg2,(FXString const &)*arg3,(FXString const &)*arg4,arg5,arg6,arg7);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_getInteger__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXint arg1 ;
+  FXApp *arg2 = (FXApp *) 0 ;
+  FXString *arg3 = 0 ;
+  FXString *arg4 = 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  FXint arg6 = (FXint) -2147483647 ;
+  FXint arg7 = (FXint) 2147483647 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  SwigValueWrapper< FXString > p4 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 7)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  arg1 = NUM2INT(argv[0]);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXApp *","FXInputDialog_getInteger__SWIG_1", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXApp * >(argp2);
+  p3 = to_FXString(argv[2]); arg3 = &p3;
+  p4 = to_FXString(argv[3]); arg4 = &p4;
+  if (argc > 4) {
+    res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","FXInputDialog_getInteger__SWIG_1", 5, argv[4] )); 
+    }
+    arg5 = reinterpret_cast< FXIcon * >(argp5);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  {
+    if (!arg2) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = (VALUE)FXInputDialog_getInteger__SWIG_1(arg1,arg2,(FXString const &)*arg3,(FXString const &)*arg4,arg5,arg6,arg7);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXInputDialog_getInteger(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[7];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 7) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 4) && (argc <= 7)) {
+    int _v;
+    {
+      _v = (TYPE(argv[0]) == T_FIXNUM || TYPE(argv[0]) == T_BIGNUM) ? 1 : 0;
+    }
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXWindow, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (NIL_P(argv[3]) || TYPE(argv[3]) == T_STRING) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXInputDialog_getInteger__SWIG_0(nargs, args, self);
+            }
+            void *vptr = 0;
+            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_FXIcon, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_FXInputDialog_getInteger__SWIG_0(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_FXInputDialog_getInteger__SWIG_0(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  return _wrap_FXInputDialog_getInteger__SWIG_0(nargs, args, self);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 4) && (argc <= 7)) {
+    int _v;
+    {
+      _v = (TYPE(argv[0]) == T_FIXNUM || TYPE(argv[0]) == T_BIGNUM) ? 1 : 0;
+    }
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXApp, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (NIL_P(argv[3]) || TYPE(argv[3]) == T_STRING) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXInputDialog_getInteger__SWIG_1(nargs, args, self);
+            }
+            void *vptr = 0;
+            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_FXIcon, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_FXInputDialog_getInteger__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_FXInputDialog_getInteger__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  return _wrap_FXInputDialog_getInteger__SWIG_1(nargs, args, self);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 7, "getInteger", 
+    "    VALUE getInteger(FXint initial, FXWindow *owner, FXString const &caption, FXString const &label, FXIcon *icon, FXint lo, FXint hi)\n"
+    "    VALUE getInteger(FXint initial, FXApp *app, FXString const &caption, FXString const &label, FXIcon *icon, FXint lo, FXint hi)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_getReal__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXdouble arg1 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXString *arg3 = 0 ;
+  FXString *arg4 = 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  FXdouble arg6 = (FXdouble) -1.797693134862315e+308 ;
+  FXdouble arg7 = (FXdouble) 1.797693134862315e+308 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  SwigValueWrapper< FXString > p4 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  double val6 ;
+  int ecode6 = 0 ;
+  double val7 ;
+  int ecode7 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 7)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXdouble","FXInputDialog_getReal__SWIG_0", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXdouble >(val1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","FXInputDialog_getReal__SWIG_0", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  p3 = to_FXString(argv[2]); arg3 = &p3;
+  p4 = to_FXString(argv[3]); arg4 = &p4;
+  if (argc > 4) {
+    res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","FXInputDialog_getReal__SWIG_0", 5, argv[4] )); 
+    }
+    arg5 = reinterpret_cast< FXIcon * >(argp5);
+  }
+  if (argc > 5) {
+    ecode6 = SWIG_AsVal_double(argv[5], &val6);
+    if (!SWIG_IsOK(ecode6)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "FXdouble","FXInputDialog_getReal__SWIG_0", 6, argv[5] ));
+    } 
+    arg6 = static_cast< FXdouble >(val6);
+  }
+  if (argc > 6) {
+    ecode7 = SWIG_AsVal_double(argv[6], &val7);
+    if (!SWIG_IsOK(ecode7)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "FXdouble","FXInputDialog_getReal__SWIG_0", 7, argv[6] ));
+    } 
+    arg7 = static_cast< FXdouble >(val7);
+  }
+  {
+    if (!arg2) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = (VALUE)FXInputDialog_getReal__SWIG_0(arg1,arg2,(FXString const &)*arg3,(FXString const &)*arg4,arg5,arg6,arg7);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_getReal__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXdouble arg1 ;
+  FXApp *arg2 = (FXApp *) 0 ;
+  FXString *arg3 = 0 ;
+  FXString *arg4 = 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  FXdouble arg6 = (FXdouble) -1.797693134862315e+308 ;
+  FXdouble arg7 = (FXdouble) 1.797693134862315e+308 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  SwigValueWrapper< FXString > p4 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  double val6 ;
+  int ecode6 = 0 ;
+  double val7 ;
+  int ecode7 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 7)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXdouble","FXInputDialog_getReal__SWIG_1", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXdouble >(val1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXApp *","FXInputDialog_getReal__SWIG_1", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXApp * >(argp2);
+  p3 = to_FXString(argv[2]); arg3 = &p3;
+  p4 = to_FXString(argv[3]); arg4 = &p4;
+  if (argc > 4) {
+    res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","FXInputDialog_getReal__SWIG_1", 5, argv[4] )); 
+    }
+    arg5 = reinterpret_cast< FXIcon * >(argp5);
+  }
+  if (argc > 5) {
+    ecode6 = SWIG_AsVal_double(argv[5], &val6);
+    if (!SWIG_IsOK(ecode6)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "FXdouble","FXInputDialog_getReal__SWIG_1", 6, argv[5] ));
+    } 
+    arg6 = static_cast< FXdouble >(val6);
+  }
+  if (argc > 6) {
+    ecode7 = SWIG_AsVal_double(argv[6], &val7);
+    if (!SWIG_IsOK(ecode7)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "FXdouble","FXInputDialog_getReal__SWIG_1", 7, argv[6] ));
+    } 
+    arg7 = static_cast< FXdouble >(val7);
+  }
+  {
+    if (!arg2) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = (VALUE)FXInputDialog_getReal__SWIG_1(arg1,arg2,(FXString const &)*arg3,(FXString const &)*arg4,arg5,arg6,arg7);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXInputDialog_getReal(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[7];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 7) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 4) && (argc <= 7)) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXWindow, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (NIL_P(argv[3]) || TYPE(argv[3]) == T_STRING) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXInputDialog_getReal__SWIG_0(nargs, args, self);
+            }
+            void *vptr = 0;
+            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_FXIcon, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_FXInputDialog_getReal__SWIG_0(nargs, args, self);
+              }
+              {
+                int res = SWIG_AsVal_double(argv[5], NULL);
+                _v = SWIG_CheckState(res);
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_FXInputDialog_getReal__SWIG_0(nargs, args, self);
+                }
+                {
+                  int res = SWIG_AsVal_double(argv[6], NULL);
+                  _v = SWIG_CheckState(res);
+                }
+                if (_v) {
+                  return _wrap_FXInputDialog_getReal__SWIG_0(nargs, args, self);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 4) && (argc <= 7)) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXApp, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (NIL_P(argv[3]) || TYPE(argv[3]) == T_STRING) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXInputDialog_getReal__SWIG_1(nargs, args, self);
+            }
+            void *vptr = 0;
+            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_FXIcon, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_FXInputDialog_getReal__SWIG_1(nargs, args, self);
+              }
+              {
+                int res = SWIG_AsVal_double(argv[5], NULL);
+                _v = SWIG_CheckState(res);
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_FXInputDialog_getReal__SWIG_1(nargs, args, self);
+                }
+                {
+                  int res = SWIG_AsVal_double(argv[6], NULL);
+                  _v = SWIG_CheckState(res);
+                }
+                if (_v) {
+                  return _wrap_FXInputDialog_getReal__SWIG_1(nargs, args, self);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 7, "getReal", 
+    "    VALUE getReal(FXdouble initial, FXWindow *owner, FXString const &caption, FXString const &label, FXIcon *icon, FXdouble lo, FXdouble hi)\n"
+    "    VALUE getReal(FXdouble initial, FXApp *app, FXString const &caption, FXString const &label, FXIcon *icon, FXdouble lo, FXdouble hi)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_save(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXInputDialog_save((FXInputDialog const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_load(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXInputDialog_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_create(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  FXInputDialog_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_detach(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  FXInputDialog_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_destroy(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  FXInputDialog_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_resize(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXInputDialog_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  result = (FXint)FXInputDialog_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  result = (FXint)FXInputDialog_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXInputDialog_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXInputDialog_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  result = (bool)FXInputDialog_canFocus((FXInputDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  FXInputDialog_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  FXInputDialog_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXInputDialog_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXInputDialog_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_enable(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  FXInputDialog_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_disable(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  FXInputDialog_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  FXInputDialog_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_lower(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  FXInputDialog_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_move(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXInputDialog_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_position(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXInputDialog_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_layout(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  FXInputDialog_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_recalc(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  FXInputDialog_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_reparent(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXInputDialog_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_show__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  FXInputDialog_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_hide(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  FXInputDialog_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  result = (bool)FXInputDialog_isComposite((FXInputDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_contains(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXInputDialog_contains((FXInputDialog const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  result = (bool)FXInputDialog_doesSaveUnder((FXInputDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXInputDialog_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_tr(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXInputDialog_tr((FXInputDialog const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  FXInputDialog_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  FXInputDialog_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXInputDialog_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXInputDialog_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXInputDialog_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXInputDialog_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXInputDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXInputDialog_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXInputDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXInputDialog_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXInputDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXInputDialog_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  FXInputDialog_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_show__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  FXInputDialog_show(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXInputDialog_show(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXInputDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXInputDialog_show__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXInputDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXInputDialog_show__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "show", 
+    "    void show()\n"
+    "    void show(FXuint placement)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_maximize(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","maximize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXInputDialog_maximize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_minimize(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","minimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXInputDialog_minimize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_restore(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXInputDialog_restore(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_close(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","close", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXInputDialog_close(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXInputDialog_execute(int argc, VALUE *argv, VALUE self) {
+  FXInputDialog *arg1 = (FXInputDialog *) 0 ;
+  FXuint arg2 = (FXuint) PLACEMENT_CURSOR ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXInputDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXInputDialog *","execute", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXInputDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  result = (FXuint)FXInputDialog_execute(arg1,arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXPrintDialog;
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onCmdToPrinter(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onCmdToPrinter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdToPrinter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdToPrinter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onUpdToPrinter(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onUpdToPrinter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdToPrinter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdToPrinter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onCmdToFile(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onCmdToFile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdToFile", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdToFile(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onUpdToFile(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onUpdToFile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdToFile", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdToFile(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onCmdBrowse(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onCmdBrowse", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdBrowse", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdBrowse(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onUpdBrowse(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onUpdBrowse", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdBrowse", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdBrowse(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onCmdProps(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onCmdProps", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdProps", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdProps(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onUpdProps(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onUpdProps", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdProps", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdProps(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onCmdPortrait(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onCmdPortrait", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdPortrait", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdPortrait(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onUpdPortrait(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onUpdPortrait", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdPortrait", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdPortrait(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onCmdLandscape(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onCmdLandscape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdLandscape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdLandscape(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onUpdLandscape(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onUpdLandscape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdLandscape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdLandscape(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onCmdPages(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onCmdPages", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdPages", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdPages(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onUpdPages(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onUpdPages", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdPages", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdPages(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onCmdColor(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onCmdColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdColor", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdColor(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onUpdColor(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onUpdColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdColor", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdColor(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onCmdGray(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onCmdGray", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGray", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGray(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onUpdGray(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onUpdGray", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdGray", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdGray(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onCmdNumCopies(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onCmdNumCopies", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdNumCopies", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdNumCopies(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onUpdNumCopies(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onUpdNumCopies", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdNumCopies", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdNumCopies(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onCmdFirstPage(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onCmdFirstPage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdFirstPage", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdFirstPage(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onUpdFirstPage(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onUpdFirstPage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdFirstPage", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdFirstPage(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onCmdLastPage(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onCmdLastPage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdLastPage", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdLastPage(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onUpdLastPage(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onUpdLastPage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdLastPage", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdLastPage(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onCmdCollateNormal(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onCmdCollateNormal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCollateNormal", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCollateNormal(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onUpdCollateNormal(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onUpdCollateNormal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdCollateNormal", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdCollateNormal(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onCmdCollateReversed(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onCmdCollateReversed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCollateReversed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCollateReversed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onUpdCollateReversed(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onUpdCollateReversed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdCollateReversed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdCollateReversed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onCmdFileName(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onCmdFileName", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdFileName", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdFileName(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onUpdFileName(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onUpdFileName", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdFileName", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdFileName(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onCmdPrinterName(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onCmdPrinterName", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdPrinterName", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdPrinterName(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onUpdPrinterName(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onUpdPrinterName", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdPrinterName", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdPrinterName(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onCmdAccept(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onCmdAccept", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdAccept", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdAccept(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onCmdMedia(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onCmdMedia", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMedia", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdMedia(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_onUpdMedia(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","onUpdMedia", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdMedia", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdMedia(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXPrintDialog_allocate(VALUE self)
+#else
+_wrap_FXPrintDialog_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXPrintDialog);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXPrintDialog(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXString *arg2 = 0 ;
+  FXuint arg3 = (FXuint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXPrintDialog *result = 0 ;
+  
+  if ((argc < 2) || (argc > 7)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXPrintDialog", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXPrintDialog *)new_FXPrintDialog(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_setPrinter(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXPrinter *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","setPrinter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXPrinter,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXPrinter const &","setPrinter", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXPrinter const &","setPrinter", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXPrinter * >(argp2);
+  (arg1)->setPrinter((FXPrinter const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_getPrinter(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPrinter result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","getPrinter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  result = FXPrintDialog_getPrinter(arg1);
+  {
+    FXPrinter *resultptr = new FXPrinter(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXPrinter *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_save(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXPrintDialog_save((FXPrintDialog const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_load(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXPrintDialog_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_create(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  FXPrintDialog_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_detach(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  FXPrintDialog_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_destroy(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  FXPrintDialog_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_resize(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXPrintDialog_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  result = (FXint)FXPrintDialog_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  result = (FXint)FXPrintDialog_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXPrintDialog_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXPrintDialog_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  result = (bool)FXPrintDialog_canFocus((FXPrintDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  FXPrintDialog_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  FXPrintDialog_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXPrintDialog_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXPrintDialog_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_enable(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  FXPrintDialog_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_disable(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  FXPrintDialog_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  FXPrintDialog_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_lower(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  FXPrintDialog_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_move(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXPrintDialog_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_position(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXPrintDialog_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_layout(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  FXPrintDialog_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_recalc(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  FXPrintDialog_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_reparent(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXPrintDialog_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_show__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  FXPrintDialog_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_hide(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  FXPrintDialog_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  result = (bool)FXPrintDialog_isComposite((FXPrintDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_contains(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXPrintDialog_contains((FXPrintDialog const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  result = (bool)FXPrintDialog_doesSaveUnder((FXPrintDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXPrintDialog_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_tr(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXPrintDialog_tr((FXPrintDialog const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  FXPrintDialog_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  FXPrintDialog_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXPrintDialog_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXPrintDialog_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXPrintDialog_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXPrintDialog_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXPrintDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXPrintDialog_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXPrintDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXPrintDialog_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXPrintDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXPrintDialog_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  FXPrintDialog_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_show__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  FXPrintDialog_show(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXPrintDialog_show(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXPrintDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXPrintDialog_show__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXPrintDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXPrintDialog_show__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "show", 
+    "    void show()\n"
+    "    void show(FXuint placement)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_maximize(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","maximize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXPrintDialog_maximize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_minimize(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","minimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXPrintDialog_minimize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_restore(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXPrintDialog_restore(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_close(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","close", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXPrintDialog_close(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPrintDialog_execute(int argc, VALUE *argv, VALUE self) {
+  FXPrintDialog *arg1 = (FXPrintDialog *) 0 ;
+  FXuint arg2 = (FXuint) PLACEMENT_CURSOR ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPrintDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPrintDialog *","execute", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPrintDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  result = (FXuint)FXPrintDialog_execute(arg1,arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXProgressDialog;
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXint) NUM2INT(argv[2]);
+    arg4 = static_cast<void*>(&value4);
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_onCmdSetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","onCmdSetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_onCmdGetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","onCmdGetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_onCmdCancel(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","onCmdCancel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCancel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCancel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXProgressDialog_allocate(VALUE self)
+#else
+_wrap_FXProgressDialog_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXProgressDialog);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXProgressDialog(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXString *arg2 = 0 ;
+  FXString *arg3 = 0 ;
+  FXuint arg4 = (FXuint) PROGRESSDIALOG_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  SwigValueWrapper< FXString > p3 ;
+  FXProgressDialog *result = 0 ;
+  
+  if ((argc < 3) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXProgressDialog", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  p3 = to_FXString(argv[2]); arg3 = &p3;
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXProgressDialog *)new_FXProgressDialog(arg1,(FXString const &)*arg2,(FXString const &)*arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_setMessage(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","setMessage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setMessage((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_getMessage(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog const *","getMessage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  result = ((FXProgressDialog const *)arg1)->getMessage();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_setBarStyle(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","setBarStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setBarStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_getBarStyle(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog const *","getBarStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  result = (FXuint)((FXProgressDialog const *)arg1)->getBarStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_setProgress(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","setProgress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setProgress(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_getProgress(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog const *","getProgress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  result = (FXuint)((FXProgressDialog const *)arg1)->getProgress();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_setTotal(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","setTotal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setTotal(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_getTotal(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog const *","getTotal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  result = (FXuint)((FXProgressDialog const *)arg1)->getTotal();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_increment(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","increment", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->increment(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_isCancelled(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog const *","isCancelled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  result = (FXbool)((FXProgressDialog const *)arg1)->isCancelled();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_setCancelled(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","setCancelled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->setCancelled(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_save(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXProgressDialog_save((FXProgressDialog const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_load(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXProgressDialog_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_create(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  FXProgressDialog_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_detach(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  FXProgressDialog_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_destroy(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  FXProgressDialog_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_resize(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXProgressDialog_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  result = (FXint)FXProgressDialog_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  result = (FXint)FXProgressDialog_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXProgressDialog_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXProgressDialog_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  result = (bool)FXProgressDialog_canFocus((FXProgressDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  FXProgressDialog_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  FXProgressDialog_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXProgressDialog_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXProgressDialog_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_enable(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  FXProgressDialog_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_disable(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  FXProgressDialog_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  FXProgressDialog_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_lower(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  FXProgressDialog_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_move(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXProgressDialog_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_position(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXProgressDialog_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_layout(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  FXProgressDialog_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_recalc(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  FXProgressDialog_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_reparent(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXProgressDialog_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_show__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  FXProgressDialog_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_hide(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  FXProgressDialog_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  result = (bool)FXProgressDialog_isComposite((FXProgressDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_contains(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXProgressDialog_contains((FXProgressDialog const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  result = (bool)FXProgressDialog_doesSaveUnder((FXProgressDialog const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXProgressDialog_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_tr(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXProgressDialog_tr((FXProgressDialog const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  FXProgressDialog_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  FXProgressDialog_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXProgressDialog_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXProgressDialog_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXProgressDialog_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXProgressDialog_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXProgressDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXProgressDialog_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXProgressDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXProgressDialog_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXProgressDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXProgressDialog_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  FXProgressDialog_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_show__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  FXProgressDialog_show(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXProgressDialog_show(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXProgressDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXProgressDialog_show__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXProgressDialog, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXProgressDialog_show__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "show", 
+    "    void show()\n"
+    "    void show(FXuint placement)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_maximize(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","maximize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXProgressDialog_maximize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_minimize(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","minimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXProgressDialog_minimize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_restore(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXProgressDialog_restore(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_close(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","close", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXProgressDialog_close(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressDialog_execute(int argc, VALUE *argv, VALUE self) {
+  FXProgressDialog *arg1 = (FXProgressDialog *) 0 ;
+  FXuint arg2 = (FXuint) PLACEMENT_CURSOR ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressDialog, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressDialog *","execute", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressDialog * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  result = (FXuint)FXProgressDialog_execute(arg1,arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMessageBox;
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_onCmdClicked(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","onCmdClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_onCmdCancel(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","onCmdCancel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCancel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCancel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMessageBox__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXString *arg2 = 0 ;
+  FXString *arg3 = 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXuint arg5 = (FXuint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  SwigValueWrapper< FXString > p3 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXMessageBox *result = 0 ;
+  
+  if ((argc < 3) || (argc > 7)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXMessageBox", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  p3 = to_FXString(argv[2]); arg3 = &p3;
+  if (argc > 3) {
+    res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","FXMessageBox", 4, argv[3] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXMessageBox *)new_FXMessageBox__SWIG_0(arg1,(FXString const &)*arg2,(FXString const &)*arg3,arg4,arg5,arg6,arg7);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMessageBox_allocate(VALUE self)
+#else
+_wrap_FXMessageBox_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMessageBox);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMessageBox__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXString *arg2 = 0 ;
+  FXString *arg3 = 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXuint arg5 = (FXuint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  SwigValueWrapper< FXString > p3 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXMessageBox *result = 0 ;
+  
+  if ((argc < 3) || (argc > 7)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXMessageBox", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  p3 = to_FXString(argv[2]); arg3 = &p3;
+  if (argc > 3) {
+    res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","FXMessageBox", 4, argv[3] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXMessageBox *)new_FXMessageBox__SWIG_1(arg1,(FXString const &)*arg2,(FXString const &)*arg3,arg4,arg5,arg6,arg7);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXMessageBox(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[7];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 7) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 3) && (argc <= 7)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXMessageBox__SWIG_0(nargs, args, self);
+          }
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXMessageBox__SWIG_0(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXMessageBox__SWIG_0(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXMessageBox__SWIG_0(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  return _wrap_new_FXMessageBox__SWIG_0(nargs, args, self);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 3) && (argc <= 7)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXMessageBox__SWIG_1(nargs, args, self);
+          }
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXMessageBox__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXMessageBox__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXMessageBox__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  return _wrap_new_FXMessageBox__SWIG_1(nargs, args, self);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 7, "FXMessageBox.new", 
+    "    FXMessageBox.new(FXWindow *owner, FXString const &caption, FXString const &text, FXIcon *ic, FXuint opts, FXint x, FXint y)\n"
+    "    FXMessageBox.new(FXApp *app, FXString const &caption, FXString const &text, FXIcon *ic, FXuint opts, FXint x, FXint y)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_error__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXuint arg2 ;
+  char *arg3 = (char *) 0 ;
+  char *arg4 = (char *) 0 ;
+  char *arg5 = (char *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res3 ;
+  char *buf3 = 0 ;
+  int alloc3 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXMessageBox::error", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2UINT(argv[1]);
+  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","FXMessageBox::error", 3, argv[2] ));
+  }
+  arg3 = reinterpret_cast< char * >(buf3);
+  {
+    arg4 = (char*)"%s";
+    arg5 = RSTRING_PTR(argv[3]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = (FXuint)FXMessageBox::error(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return vresult;
+fail:
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_error__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuint arg2 ;
+  char *arg3 = (char *) 0 ;
+  char *arg4 = (char *) 0 ;
+  char *arg5 = (char *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res3 ;
+  char *buf3 = 0 ;
+  int alloc3 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXMessageBox::error", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2UINT(argv[1]);
+  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","FXMessageBox::error", 3, argv[2] ));
+  }
+  arg3 = reinterpret_cast< char * >(buf3);
+  {
+    arg4 = (char*)"%s";
+    arg5 = RSTRING_PTR(argv[3]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = (FXuint)FXMessageBox::error(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return vresult;
+fail:
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMessageBox_error(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 4) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXMessageBox_error__SWIG_0(nargs, args, self);
+            }
+            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              return _wrap_FXMessageBox_error__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXMessageBox_error__SWIG_1(nargs, args, self);
+            }
+            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              return _wrap_FXMessageBox_error__SWIG_1(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXMessageBox.error", 
+    "    FXuint FXMessageBox.error(FXWindow *owner, FXuint opts, char const *caption, char const *message_format, char const *message_string)\n"
+    "    FXuint FXMessageBox.error(FXApp *app, FXuint opts, char const *caption, char const *message_format, char const *message_string)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_warning__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXuint arg2 ;
+  char *arg3 = (char *) 0 ;
+  char *arg4 = (char *) 0 ;
+  char *arg5 = (char *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res3 ;
+  char *buf3 = 0 ;
+  int alloc3 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXMessageBox::warning", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2UINT(argv[1]);
+  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","FXMessageBox::warning", 3, argv[2] ));
+  }
+  arg3 = reinterpret_cast< char * >(buf3);
+  {
+    arg4 = (char*)"%s";
+    arg5 = RSTRING_PTR(argv[3]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = (FXuint)FXMessageBox::warning(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return vresult;
+fail:
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_warning__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuint arg2 ;
+  char *arg3 = (char *) 0 ;
+  char *arg4 = (char *) 0 ;
+  char *arg5 = (char *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res3 ;
+  char *buf3 = 0 ;
+  int alloc3 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXMessageBox::warning", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2UINT(argv[1]);
+  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","FXMessageBox::warning", 3, argv[2] ));
+  }
+  arg3 = reinterpret_cast< char * >(buf3);
+  {
+    arg4 = (char*)"%s";
+    arg5 = RSTRING_PTR(argv[3]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = (FXuint)FXMessageBox::warning(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return vresult;
+fail:
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMessageBox_warning(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 4) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXMessageBox_warning__SWIG_0(nargs, args, self);
+            }
+            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              return _wrap_FXMessageBox_warning__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXMessageBox_warning__SWIG_1(nargs, args, self);
+            }
+            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              return _wrap_FXMessageBox_warning__SWIG_1(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXMessageBox.warning", 
+    "    FXuint FXMessageBox.warning(FXWindow *owner, FXuint opts, char const *caption, char const *message_format, char const *message_string)\n"
+    "    FXuint FXMessageBox.warning(FXApp *app, FXuint opts, char const *caption, char const *message_format, char const *message_string)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_question__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXuint arg2 ;
+  char *arg3 = (char *) 0 ;
+  char *arg4 = (char *) 0 ;
+  char *arg5 = (char *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res3 ;
+  char *buf3 = 0 ;
+  int alloc3 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXMessageBox::question", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2UINT(argv[1]);
+  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","FXMessageBox::question", 3, argv[2] ));
+  }
+  arg3 = reinterpret_cast< char * >(buf3);
+  {
+    arg4 = (char*)"%s";
+    arg5 = RSTRING_PTR(argv[3]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = (FXuint)FXMessageBox::question(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return vresult;
+fail:
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_question__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuint arg2 ;
+  char *arg3 = (char *) 0 ;
+  char *arg4 = (char *) 0 ;
+  char *arg5 = (char *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res3 ;
+  char *buf3 = 0 ;
+  int alloc3 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXMessageBox::question", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2UINT(argv[1]);
+  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","FXMessageBox::question", 3, argv[2] ));
+  }
+  arg3 = reinterpret_cast< char * >(buf3);
+  {
+    arg4 = (char*)"%s";
+    arg5 = RSTRING_PTR(argv[3]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = (FXuint)FXMessageBox::question(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return vresult;
+fail:
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMessageBox_question(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 4) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXMessageBox_question__SWIG_0(nargs, args, self);
+            }
+            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              return _wrap_FXMessageBox_question__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXMessageBox_question__SWIG_1(nargs, args, self);
+            }
+            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              return _wrap_FXMessageBox_question__SWIG_1(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXMessageBox.question", 
+    "    FXuint FXMessageBox.question(FXWindow *owner, FXuint opts, char const *caption, char const *message_format, char const *message_string)\n"
+    "    FXuint FXMessageBox.question(FXApp *app, FXuint opts, char const *caption, char const *message_format, char const *message_string)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_information__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXuint arg2 ;
+  char *arg3 = (char *) 0 ;
+  char *arg4 = (char *) 0 ;
+  char *arg5 = (char *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res3 ;
+  char *buf3 = 0 ;
+  int alloc3 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXMessageBox::information", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2UINT(argv[1]);
+  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","FXMessageBox::information", 3, argv[2] ));
+  }
+  arg3 = reinterpret_cast< char * >(buf3);
+  {
+    arg4 = (char*)"%s";
+    arg5 = RSTRING_PTR(argv[3]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = (FXuint)FXMessageBox::information(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return vresult;
+fail:
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_information__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuint arg2 ;
+  char *arg3 = (char *) 0 ;
+  char *arg4 = (char *) 0 ;
+  char *arg5 = (char *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res3 ;
+  char *buf3 = 0 ;
+  int alloc3 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXMessageBox::information", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2UINT(argv[1]);
+  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","FXMessageBox::information", 3, argv[2] ));
+  }
+  arg3 = reinterpret_cast< char * >(buf3);
+  {
+    arg4 = (char*)"%s";
+    arg5 = RSTRING_PTR(argv[3]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = (FXuint)FXMessageBox::information(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return vresult;
+fail:
+  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMessageBox_information(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 4) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXMessageBox_information__SWIG_0(nargs, args, self);
+            }
+            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              return _wrap_FXMessageBox_information__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXMessageBox_information__SWIG_1(nargs, args, self);
+            }
+            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              return _wrap_FXMessageBox_information__SWIG_1(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXMessageBox.information", 
+    "    FXuint FXMessageBox.information(FXWindow *owner, FXuint opts, char const *caption, char const *message_format, char const *message_string)\n"
+    "    FXuint FXMessageBox.information(FXApp *app, FXuint opts, char const *caption, char const *message_format, char const *message_string)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_save(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMessageBox_save((FXMessageBox const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_load(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMessageBox_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_create(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  FXMessageBox_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_detach(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  FXMessageBox_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_destroy(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  FXMessageBox_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_resize(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMessageBox_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  result = (FXint)FXMessageBox_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  result = (FXint)FXMessageBox_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMessageBox_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMessageBox_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  result = (bool)FXMessageBox_canFocus((FXMessageBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  FXMessageBox_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  FXMessageBox_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXMessageBox_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMessageBox_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_enable(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  FXMessageBox_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_disable(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  FXMessageBox_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  FXMessageBox_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_lower(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  FXMessageBox_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_move(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMessageBox_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_position(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXMessageBox_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_layout(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  FXMessageBox_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_recalc(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  FXMessageBox_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_reparent(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXMessageBox_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_show__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  FXMessageBox_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_hide(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  FXMessageBox_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  result = (bool)FXMessageBox_isComposite((FXMessageBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_contains(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXMessageBox_contains((FXMessageBox const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  result = (bool)FXMessageBox_doesSaveUnder((FXMessageBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXMessageBox_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_tr(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXMessageBox_tr((FXMessageBox const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  FXMessageBox_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  FXMessageBox_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXMessageBox_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXMessageBox_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXMessageBox_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMessageBox_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMessageBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMessageBox_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMessageBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMessageBox_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMessageBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMessageBox_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  FXMessageBox_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_show__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  FXMessageBox_show(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMessageBox_show(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMessageBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXMessageBox_show__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMessageBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXMessageBox_show__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "show", 
+    "    void show()\n"
+    "    void show(FXuint placement)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_maximize(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","maximize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXMessageBox_maximize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_minimize(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","minimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXMessageBox_minimize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_restore(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXMessageBox_restore(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_close(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","close", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXMessageBox_close(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMessageBox_execute(int argc, VALUE *argv, VALUE self) {
+  FXMessageBox *arg1 = (FXMessageBox *) 0 ;
+  FXuint arg2 = (FXuint) PLACEMENT_CURSOR ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMessageBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMessageBox *","execute", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMessageBox * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  result = (FXuint)FXMessageBox_execute(arg1,arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXWizard;
+
+SWIGINTERN VALUE
+_wrap_FXWizard_onUpdFinish(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","onUpdFinish", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdFinish", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdFinish(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_onCmdNext(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","onCmdNext", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdNext", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdNext(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_onUpdNext(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","onUpdNext", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdNext", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdNext(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_onCmdBack(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","onCmdBack", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdBack", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdBack(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_onUpdBack(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","onUpdBack", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdBack", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdBack(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXWizard__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXString *arg2 = 0 ;
+  FXImage *arg3 = (FXImage *) 0 ;
+  FXuint arg4 = (FXuint) DECOR_TITLE|DECOR_BORDER|DECOR_RESIZE ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 10 ;
+  FXint arg10 = (FXint) 10 ;
+  FXint arg11 = (FXint) 10 ;
+  FXint arg12 = (FXint) 10 ;
+  FXint arg13 = (FXint) 10 ;
+  FXint arg14 = (FXint) 10 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXWizard *result = 0 ;
+  
+  if ((argc < 3) || (argc > 14)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXWizard", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXImage *","FXWizard", 3, argv[2] )); 
+  }
+  arg3 = reinterpret_cast< FXImage * >(argp3);
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  if (argc > 13) {
+    arg14 = NUM2INT(argv[13]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXWizard *)new_FXWizard__SWIG_0(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXWizard_allocate(VALUE self)
+#else
+_wrap_FXWizard_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXWizard);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXWizard__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXString *arg2 = 0 ;
+  FXImage *arg3 = (FXImage *) 0 ;
+  FXuint arg4 = (FXuint) DECOR_TITLE|DECOR_BORDER|DECOR_RESIZE ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 10 ;
+  FXint arg10 = (FXint) 10 ;
+  FXint arg11 = (FXint) 10 ;
+  FXint arg12 = (FXint) 10 ;
+  FXint arg13 = (FXint) 10 ;
+  FXint arg14 = (FXint) 10 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXWizard *result = 0 ;
+  
+  if ((argc < 3) || (argc > 14)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXWizard", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXImage *","FXWizard", 3, argv[2] )); 
+  }
+  arg3 = reinterpret_cast< FXImage * >(argp3);
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  if (argc > 13) {
+    arg14 = NUM2INT(argv[13]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXWizard *)new_FXWizard__SWIG_1(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXWizard(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[14];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 14) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 3) && (argc <= 14)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXImage, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXWizard__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXWizard__SWIG_0(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXWizard__SWIG_0(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXWizard__SWIG_0(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  if (argc <= 7) {
+                    return _wrap_new_FXWizard__SWIG_0(nargs, args, self);
+                  }
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    if (argc <= 8) {
+                      return _wrap_new_FXWizard__SWIG_0(nargs, args, self);
+                    }
+                    {
+                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
+                    }
+                    if (_v) {
+                      if (argc <= 9) {
+                        return _wrap_new_FXWizard__SWIG_0(nargs, args, self);
+                      }
+                      {
+                        _v = (TYPE(argv[9]) == T_FIXNUM || TYPE(argv[9]) == T_BIGNUM) ? 1 : 0;
+                      }
+                      if (_v) {
+                        if (argc <= 10) {
+                          return _wrap_new_FXWizard__SWIG_0(nargs, args, self);
+                        }
+                        {
+                          _v = (TYPE(argv[10]) == T_FIXNUM || TYPE(argv[10]) == T_BIGNUM) ? 1 : 0;
+                        }
+                        if (_v) {
+                          if (argc <= 11) {
+                            return _wrap_new_FXWizard__SWIG_0(nargs, args, self);
+                          }
+                          {
+                            _v = (TYPE(argv[11]) == T_FIXNUM || TYPE(argv[11]) == T_BIGNUM) ? 1 : 0;
+                          }
+                          if (_v) {
+                            if (argc <= 12) {
+                              return _wrap_new_FXWizard__SWIG_0(nargs, args, self);
+                            }
+                            {
+                              _v = (TYPE(argv[12]) == T_FIXNUM || TYPE(argv[12]) == T_BIGNUM) ? 1 : 0;
+                            }
+                            if (_v) {
+                              if (argc <= 13) {
+                                return _wrap_new_FXWizard__SWIG_0(nargs, args, self);
+                              }
+                              {
+                                _v = (TYPE(argv[13]) == T_FIXNUM || TYPE(argv[13]) == T_BIGNUM) ? 1 : 0;
+                              }
+                              if (_v) {
+                                return _wrap_new_FXWizard__SWIG_0(nargs, args, self);
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 3) && (argc <= 14)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXImage, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXWizard__SWIG_1(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXWizard__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXWizard__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXWizard__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  if (argc <= 7) {
+                    return _wrap_new_FXWizard__SWIG_1(nargs, args, self);
+                  }
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    if (argc <= 8) {
+                      return _wrap_new_FXWizard__SWIG_1(nargs, args, self);
+                    }
+                    {
+                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
+                    }
+                    if (_v) {
+                      if (argc <= 9) {
+                        return _wrap_new_FXWizard__SWIG_1(nargs, args, self);
+                      }
+                      {
+                        _v = (TYPE(argv[9]) == T_FIXNUM || TYPE(argv[9]) == T_BIGNUM) ? 1 : 0;
+                      }
+                      if (_v) {
+                        if (argc <= 10) {
+                          return _wrap_new_FXWizard__SWIG_1(nargs, args, self);
+                        }
+                        {
+                          _v = (TYPE(argv[10]) == T_FIXNUM || TYPE(argv[10]) == T_BIGNUM) ? 1 : 0;
+                        }
+                        if (_v) {
+                          if (argc <= 11) {
+                            return _wrap_new_FXWizard__SWIG_1(nargs, args, self);
+                          }
+                          {
+                            _v = (TYPE(argv[11]) == T_FIXNUM || TYPE(argv[11]) == T_BIGNUM) ? 1 : 0;
+                          }
+                          if (_v) {
+                            if (argc <= 12) {
+                              return _wrap_new_FXWizard__SWIG_1(nargs, args, self);
+                            }
+                            {
+                              _v = (TYPE(argv[12]) == T_FIXNUM || TYPE(argv[12]) == T_BIGNUM) ? 1 : 0;
+                            }
+                            if (_v) {
+                              if (argc <= 13) {
+                                return _wrap_new_FXWizard__SWIG_1(nargs, args, self);
+                              }
+                              {
+                                _v = (TYPE(argv[13]) == T_FIXNUM || TYPE(argv[13]) == T_BIGNUM) ? 1 : 0;
+                              }
+                              if (_v) {
+                                return _wrap_new_FXWizard__SWIG_1(nargs, args, self);
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 14, "FXWizard.new", 
+    "    FXWizard.new(FXApp *a, FXString const &name, FXImage *image, FXuint opts, FXint x, FXint y, FXint w, FXint h, FXint pl, FXint pr, FXint pt, FXint pb, FXint hs, FXint vs)\n"
+    "    FXWizard.new(FXWindow *owner, FXString const &name, FXImage *image, FXuint opts, FXint x, FXint y, FXint w, FXint h, FXint pl, FXint pr, FXint pt, FXint pb, FXint hs, FXint vs)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_buttonFrame(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXHorizontalFrame *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard const *","buttonFrame", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  result = (FXHorizontalFrame *)((FXWizard const *)arg1)->buttonFrame();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_advanceButton(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXButton *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard const *","advanceButton", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  result = (FXButton *)((FXWizard const *)arg1)->advanceButton();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXButton, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_retreatButton(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXButton *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard const *","retreatButton", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  result = (FXButton *)((FXWizard const *)arg1)->retreatButton();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXButton, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_finishButton(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXButton *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard const *","finishButton", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  result = (FXButton *)((FXWizard const *)arg1)->finishButton();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXButton, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_cancelButton(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXButton *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard const *","cancelButton", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  result = (FXButton *)((FXWizard const *)arg1)->cancelButton();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXButton, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_getContainer(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXSwitcher *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard const *","getContainer", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  result = (FXSwitcher *)((FXWizard const *)arg1)->getContainer();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_setImage(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXImage *arg2 = (FXImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","setImage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXImage *","setImage", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXImage * >(argp2);
+  (arg1)->setImage(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_getImage(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXImage *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard const *","getImage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  result = (FXImage *)((FXWizard const *)arg1)->getImage();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXImage, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_getNumPanels(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard const *","getNumPanels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  result = (FXint)((FXWizard const *)arg1)->getNumPanels();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_setCurrentPanel(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","setCurrentPanel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXWizard_setCurrentPanel(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_getCurrentPanel(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard const *","getCurrentPanel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  result = (FXint)((FXWizard const *)arg1)->getCurrentPanel();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_save(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXWizard_save((FXWizard const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_load(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXWizard_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_create(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  FXWizard_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_detach(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  FXWizard_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_destroy(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  FXWizard_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_resize(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXWizard_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  result = (FXint)FXWizard_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  result = (FXint)FXWizard_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXWizard_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXWizard_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  result = (bool)FXWizard_canFocus((FXWizard const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  FXWizard_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  FXWizard_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXWizard_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXWizard_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_enable(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  FXWizard_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_disable(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  FXWizard_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  FXWizard_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_lower(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  FXWizard_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_move(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXWizard_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_position(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXWizard_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_layout(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  FXWizard_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_recalc(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  FXWizard_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_reparent(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXWizard_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_show__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  FXWizard_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_hide(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  FXWizard_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  result = (bool)FXWizard_isComposite((FXWizard const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_contains(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXWizard_contains((FXWizard const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  result = (bool)FXWizard_doesSaveUnder((FXWizard const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXWizard_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_tr(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXWizard_tr((FXWizard const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  FXWizard_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  FXWizard_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXWizard_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXWizard_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXWizard_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXWizard_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWizard, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXWizard_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWizard, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXWizard_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWizard, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXWizard_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  FXWizard_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_show__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  FXWizard_show(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXWizard_show(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWizard, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXWizard_show__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWizard, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXWizard_show__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "show", 
+    "    void show()\n"
+    "    void show(FXuint placement)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_maximize(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","maximize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXWizard_maximize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_minimize(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","minimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXWizard_minimize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_restore(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXWizard_restore(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_close(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","close", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXWizard_close(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXWizard_execute(int argc, VALUE *argv, VALUE self) {
+  FXWizard *arg1 = (FXWizard *) 0 ;
+  FXuint arg2 = (FXuint) PLACEMENT_CURSOR ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXWizard, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWizard *","execute", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXWizard * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  result = (FXuint)FXWizard_execute(arg1,arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXChoiceBox;
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_onCmdClicked(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","onCmdClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_onCmdCancel(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","onCmdCancel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCancel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCancel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXChoiceBox__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXString *arg2 = 0 ;
+  FXString *arg3 = 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXchar **arg5 = (FXchar **) 0 ;
+  FXuint arg6 = (FXuint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  SwigValueWrapper< FXString > p3 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXChoiceBox *result = 0 ;
+  
+  if ((argc < 5) || (argc > 10)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXChoiceBox", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  p3 = to_FXString(argv[2]); arg3 = &p3;
+  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","FXChoiceBox", 4, argv[3] )); 
+  }
+  arg4 = reinterpret_cast< FXIcon * >(argp4);
+  {
+    arg5 = NULL;
+    if(!NIL_P(argv[4])){
+      Check_Type(argv[4], T_ARRAY);
+      if (FXMALLOC(&arg5, FXchar *, RARRAY_LEN(argv[4])+1)) {
+        for (long i = 0; i < RARRAY_LEN(argv[4]); i++) {
+          VALUE e = rb_ary_entry(argv[4], i);
+          arg5[i] = (FXchar *) StringValuePtr(e);
+        }
+        arg5[RARRAY_LEN(argv[4])] = 0;
+      }
+    }
+  }
+  if (argc > 5) {
+    arg6 = NUM2UINT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXChoiceBox *)new_FXChoiceBox__SWIG_0(arg1,(FXString const &)*arg2,(FXString const &)*arg3,arg4,(char const **)arg5,arg6,arg7,arg8,arg9,arg10);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  FXFREE(&arg5);
+  return self;
+fail:
+  FXFREE(&arg5);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXChoiceBox_allocate(VALUE self)
+#else
+_wrap_FXChoiceBox_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXChoiceBox);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXChoiceBox__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXString *arg2 = 0 ;
+  FXString *arg3 = 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXchar **arg5 = (FXchar **) 0 ;
+  FXuint arg6 = (FXuint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  SwigValueWrapper< FXString > p3 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXChoiceBox *result = 0 ;
+  
+  if ((argc < 5) || (argc > 10)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXChoiceBox", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  p3 = to_FXString(argv[2]); arg3 = &p3;
+  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","FXChoiceBox", 4, argv[3] )); 
+  }
+  arg4 = reinterpret_cast< FXIcon * >(argp4);
+  {
+    arg5 = NULL;
+    if(!NIL_P(argv[4])){
+      Check_Type(argv[4], T_ARRAY);
+      if (FXMALLOC(&arg5, FXchar *, RARRAY_LEN(argv[4])+1)) {
+        for (long i = 0; i < RARRAY_LEN(argv[4]); i++) {
+          VALUE e = rb_ary_entry(argv[4], i);
+          arg5[i] = (FXchar *) StringValuePtr(e);
+        }
+        arg5[RARRAY_LEN(argv[4])] = 0;
+      }
+    }
+  }
+  if (argc > 5) {
+    arg6 = NUM2UINT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXChoiceBox *)new_FXChoiceBox__SWIG_1(arg1,(FXString const &)*arg2,(FXString const &)*arg3,arg4,(char const **)arg5,arg6,arg7,arg8,arg9,arg10);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  FXFREE(&arg5);
+  return self;
+fail:
+  FXFREE(&arg5);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXChoiceBox(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[10];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 10) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 5) && (argc <= 10)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_ARRAY) ? 1 : 0;
+              if (_v != 0) {
+                for (long i = 0; i < RARRAY_LEN(argv[4]); i++) {
+                  if (TYPE(rb_ary_entry(argv[4], i)) != T_STRING) {
+                    _v = 0;
+                    break;
+                  }
+                }
+              }
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXChoiceBox__SWIG_0(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXChoiceBox__SWIG_0(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  if (argc <= 7) {
+                    return _wrap_new_FXChoiceBox__SWIG_0(nargs, args, self);
+                  }
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    if (argc <= 8) {
+                      return _wrap_new_FXChoiceBox__SWIG_0(nargs, args, self);
+                    }
+                    {
+                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
+                    }
+                    if (_v) {
+                      if (argc <= 9) {
+                        return _wrap_new_FXChoiceBox__SWIG_0(nargs, args, self);
+                      }
+                      {
+                        _v = (TYPE(argv[9]) == T_FIXNUM || TYPE(argv[9]) == T_BIGNUM) ? 1 : 0;
+                      }
+                      if (_v) {
+                        return _wrap_new_FXChoiceBox__SWIG_0(nargs, args, self);
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 5) && (argc <= 10)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_ARRAY) ? 1 : 0;
+              if (_v != 0) {
+                for (long i = 0; i < RARRAY_LEN(argv[4]); i++) {
+                  if (TYPE(rb_ary_entry(argv[4], i)) != T_STRING) {
+                    _v = 0;
+                    break;
+                  }
+                }
+              }
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXChoiceBox__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXChoiceBox__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  if (argc <= 7) {
+                    return _wrap_new_FXChoiceBox__SWIG_1(nargs, args, self);
+                  }
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    if (argc <= 8) {
+                      return _wrap_new_FXChoiceBox__SWIG_1(nargs, args, self);
+                    }
+                    {
+                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
+                    }
+                    if (_v) {
+                      if (argc <= 9) {
+                        return _wrap_new_FXChoiceBox__SWIG_1(nargs, args, self);
+                      }
+                      {
+                        _v = (TYPE(argv[9]) == T_FIXNUM || TYPE(argv[9]) == T_BIGNUM) ? 1 : 0;
+                      }
+                      if (_v) {
+                        return _wrap_new_FXChoiceBox__SWIG_1(nargs, args, self);
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 10, "FXChoiceBox.new", 
+    "    FXChoiceBox.new(FXWindow *owner, FXString const &caption, FXString const &text, FXIcon *icon, FXchar const **choices, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n"
+    "    FXChoiceBox.new(FXApp *app, FXString const &caption, FXString const &text, FXIcon *icon, FXchar const **choices, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_ask__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXuint arg2 ;
+  FXString *arg3 = 0 ;
+  FXString *arg4 = 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  FXchar **arg6 = (FXchar **) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  SwigValueWrapper< FXString > p4 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXChoiceBox::ask", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2UINT(argv[1]);
+  p3 = to_FXString(argv[2]); arg3 = &p3;
+  p4 = to_FXString(argv[3]); arg4 = &p4;
+  res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res5)) {
+    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","FXChoiceBox::ask", 5, argv[4] )); 
+  }
+  arg5 = reinterpret_cast< FXIcon * >(argp5);
+  {
+    arg6 = NULL;
+    if(!NIL_P(argv[5])){
+      Check_Type(argv[5], T_ARRAY);
+      if (FXMALLOC(&arg6, FXchar *, RARRAY_LEN(argv[5])+1)) {
+        for (long i = 0; i < RARRAY_LEN(argv[5]); i++) {
+          VALUE e = rb_ary_entry(argv[5], i);
+          arg6[i] = (FXchar *) StringValuePtr(e);
+        }
+        arg6[RARRAY_LEN(argv[5])] = 0;
+      }
+    }
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = (FXint)FXChoiceBox::ask(arg1,arg2,(FXString const &)*arg3,(FXString const &)*arg4,arg5,(char const **)arg6);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  FXFREE(&arg6);
+  return vresult;
+fail:
+  FXFREE(&arg6);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_ask__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuint arg2 ;
+  FXString *arg3 = 0 ;
+  FXString *arg4 = 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  FXchar **arg6 = (FXchar **) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  SwigValueWrapper< FXString > p4 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXChoiceBox::ask", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2UINT(argv[1]);
+  p3 = to_FXString(argv[2]); arg3 = &p3;
+  p4 = to_FXString(argv[3]); arg4 = &p4;
+  res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res5)) {
+    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","FXChoiceBox::ask", 5, argv[4] )); 
+  }
+  arg5 = reinterpret_cast< FXIcon * >(argp5);
+  {
+    arg6 = NULL;
+    if(!NIL_P(argv[5])){
+      Check_Type(argv[5], T_ARRAY);
+      if (FXMALLOC(&arg6, FXchar *, RARRAY_LEN(argv[5])+1)) {
+        for (long i = 0; i < RARRAY_LEN(argv[5]); i++) {
+          VALUE e = rb_ary_entry(argv[5], i);
+          arg6[i] = (FXchar *) StringValuePtr(e);
+        }
+        arg6[RARRAY_LEN(argv[5])] = 0;
+      }
+    }
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = (FXint)FXChoiceBox::ask(arg1,arg2,(FXString const &)*arg3,(FXString const &)*arg4,arg5,(char const **)arg6);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  FXFREE(&arg6);
+  return vresult;
+fail:
+  FXFREE(&arg6);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXChoiceBox_ask(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 6) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 6) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (NIL_P(argv[3]) || TYPE(argv[3]) == T_STRING) ? 1 : 0;
+          }
+          if (_v) {
+            void *vptr = 0;
+            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_FXIcon, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              {
+                _v = (TYPE(argv[5]) == T_ARRAY) ? 1 : 0;
+                if (_v != 0) {
+                  for (long i = 0; i < RARRAY_LEN(argv[5]); i++) {
+                    if (TYPE(rb_ary_entry(argv[5], i)) != T_STRING) {
+                      _v = 0;
+                      break;
+                    }
+                  }
+                }
+              }
+              if (_v) {
+                return _wrap_FXChoiceBox_ask__SWIG_0(nargs, args, self);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if (argc == 6) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (NIL_P(argv[3]) || TYPE(argv[3]) == T_STRING) ? 1 : 0;
+          }
+          if (_v) {
+            void *vptr = 0;
+            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_FXIcon, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              {
+                _v = (TYPE(argv[5]) == T_ARRAY) ? 1 : 0;
+                if (_v != 0) {
+                  for (long i = 0; i < RARRAY_LEN(argv[5]); i++) {
+                    if (TYPE(rb_ary_entry(argv[5], i)) != T_STRING) {
+                      _v = 0;
+                      break;
+                    }
+                  }
+                }
+              }
+              if (_v) {
+                return _wrap_FXChoiceBox_ask__SWIG_1(nargs, args, self);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "FXChoiceBox.ask", 
+    "    FXint FXChoiceBox.ask(FXWindow *owner, FXuint opts, FXString const &caption, FXString const &text, FXIcon *icon, FXchar const **choices)\n"
+    "    FXint FXChoiceBox.ask(FXApp *app, FXuint opts, FXString const &caption, FXString const &text, FXIcon *icon, FXchar const **choices)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_save(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXChoiceBox_save((FXChoiceBox const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_load(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXChoiceBox_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_create(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  FXChoiceBox_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_detach(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  FXChoiceBox_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_destroy(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  FXChoiceBox_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_resize(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXChoiceBox_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  result = (FXint)FXChoiceBox_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  result = (FXint)FXChoiceBox_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXChoiceBox_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXChoiceBox_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  result = (bool)FXChoiceBox_canFocus((FXChoiceBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  FXChoiceBox_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  FXChoiceBox_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXChoiceBox_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXChoiceBox_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_enable(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  FXChoiceBox_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_disable(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  FXChoiceBox_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  FXChoiceBox_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_lower(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  FXChoiceBox_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_move(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXChoiceBox_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_position(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXChoiceBox_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_layout(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  FXChoiceBox_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_recalc(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  FXChoiceBox_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_reparent(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXChoiceBox_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_show__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  FXChoiceBox_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_hide(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  FXChoiceBox_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  result = (bool)FXChoiceBox_isComposite((FXChoiceBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_contains(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXChoiceBox_contains((FXChoiceBox const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  result = (bool)FXChoiceBox_doesSaveUnder((FXChoiceBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXChoiceBox_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_tr(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXChoiceBox_tr((FXChoiceBox const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  FXChoiceBox_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  FXChoiceBox_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXChoiceBox_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXChoiceBox_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXChoiceBox_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXChoiceBox_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXChoiceBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXChoiceBox_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXChoiceBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXChoiceBox_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXChoiceBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXChoiceBox_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  FXChoiceBox_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_show__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  FXChoiceBox_show(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXChoiceBox_show(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXChoiceBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXChoiceBox_show__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXChoiceBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXChoiceBox_show__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "show", 
+    "    void show()\n"
+    "    void show(FXuint placement)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_maximize(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","maximize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXChoiceBox_maximize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_minimize(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","minimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXChoiceBox_minimize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_restore(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXChoiceBox_restore(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_close(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","close", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXChoiceBox_close(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXChoiceBox_execute(int argc, VALUE *argv, VALUE self) {
+  FXChoiceBox *arg1 = (FXChoiceBox *) 0 ;
+  FXuint arg2 = (FXuint) PLACEMENT_CURSOR ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXChoiceBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXChoiceBox *","execute", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXChoiceBox * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  result = (FXuint)FXChoiceBox_execute(arg1,arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_FXDriveBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXMessageBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXMessageBox *) x));
+}
+static void *_p_FXToolBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolTipTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXTabBookTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXFileDialogTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXFileDialog *) x));
+}
+static void *_p_FXReplaceDialogTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXReplaceDialog *) x));
+}
+static void *_p_FXProgressDialogTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXProgressDialog *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXShell *) x));
+}
+static void *_p_FXStatusBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXScrollArea *) x));
+}
+static void *_p_FXPopupTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXComboBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FX4SplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXSplitter *) x));
+}
+static void *_p_FXDialogBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXDialogBox *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXPackerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXPacker *) x));
+}
+static void *_p_FXDirBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXSwitcherTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXShutterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXDockSiteTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXRulerViewTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXMatrixTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXShutterItemTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXWizardTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXWizard *) x));
+}
+static void *_p_FXDockBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXChoiceBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXChoiceBox *) x));
+}
+static void *_p_FXTabBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXImageViewTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXDirDialogTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXDirDialog *) x));
+}
+static void *_p_FXColorDialogTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXColorDialog *) x));
+}
+static void *_p_FXFontDialogTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXFontDialog *) x));
+}
+static void *_p_FXSearchDialogTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *)(FXDialogBox *)(FXReplaceDialog *) ((FXSearchDialog *) x));
+}
+static void *_p_FXInputDialogTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXInputDialog *) x));
+}
+static void *_p_FXPrintDialogTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXPrintDialog *) x));
+}
+static void *_p_FXSpringTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXSearchDialogTo_p_FXReplaceDialog(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXReplaceDialog *)  ((FXSearchDialog *) x));
+}
+static void *_p_FXPopupTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *)  ((FXPopup *) x));
+}
+static void *_p_FXInputDialogTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *)(FXDialogBox *) ((FXInputDialog *) x));
+}
+static void *_p_FXSearchDialogTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *)(FXDialogBox *)(FXReplaceDialog *) ((FXSearchDialog *) x));
+}
+static void *_p_FXFontDialogTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *)(FXDialogBox *) ((FXFontDialog *) x));
+}
+static void *_p_FXColorDialogTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *)(FXDialogBox *) ((FXColorDialog *) x));
+}
+static void *_p_FXDirDialogTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *)(FXDialogBox *) ((FXDirDialog *) x));
+}
+static void *_p_FXPrintDialogTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *)(FXDialogBox *) ((FXPrintDialog *) x));
+}
+static void *_p_FXMessageBoxTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *)(FXDialogBox *) ((FXMessageBox *) x));
+}
+static void *_p_FXToolTipTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *)  ((FXToolTip *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *)  ((FXTopWindow *) x));
+}
+static void *_p_FXChoiceBoxTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *)(FXDialogBox *) ((FXChoiceBox *) x));
+}
+static void *_p_FXWizardTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *)(FXDialogBox *) ((FXWizard *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXReplaceDialogTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *)(FXDialogBox *) ((FXReplaceDialog *) x));
+}
+static void *_p_FXFileDialogTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *)(FXDialogBox *) ((FXFileDialog *) x));
+}
+static void *_p_FXProgressDialogTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *)(FXDialogBox *) ((FXProgressDialog *) x));
+}
+static void *_p_FXDialogBoxTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *) ((FXDialogBox *) x));
+}
+static void *_p_FXMessageBoxTo_p_FXTopWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTopWindow *) (FXDialogBox *) ((FXMessageBox *) x));
+}
+static void *_p_FXPrintDialogTo_p_FXTopWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTopWindow *) (FXDialogBox *) ((FXPrintDialog *) x));
+}
+static void *_p_FXInputDialogTo_p_FXTopWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTopWindow *) (FXDialogBox *) ((FXInputDialog *) x));
+}
+static void *_p_FXSearchDialogTo_p_FXTopWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTopWindow *) (FXDialogBox *)(FXReplaceDialog *) ((FXSearchDialog *) x));
+}
+static void *_p_FXFontDialogTo_p_FXTopWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTopWindow *) (FXDialogBox *) ((FXFontDialog *) x));
+}
+static void *_p_FXColorDialogTo_p_FXTopWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTopWindow *) (FXDialogBox *) ((FXColorDialog *) x));
+}
+static void *_p_FXDirDialogTo_p_FXTopWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTopWindow *) (FXDialogBox *) ((FXDirDialog *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXTopWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTopWindow *)  ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXTopWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTopWindow *)  ((FXMainWindow *) x));
+}
+static void *_p_FXChoiceBoxTo_p_FXTopWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTopWindow *) (FXDialogBox *) ((FXChoiceBox *) x));
+}
+static void *_p_FXWizardTo_p_FXTopWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTopWindow *) (FXDialogBox *) ((FXWizard *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXTopWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTopWindow *)  ((FXToolBarShell *) x));
+}
+static void *_p_FXProgressDialogTo_p_FXTopWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTopWindow *) (FXDialogBox *) ((FXProgressDialog *) x));
+}
+static void *_p_FXReplaceDialogTo_p_FXTopWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTopWindow *) (FXDialogBox *) ((FXReplaceDialog *) x));
+}
+static void *_p_FXFileDialogTo_p_FXTopWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTopWindow *) (FXDialogBox *) ((FXFileDialog *) x));
+}
+static void *_p_FXDialogBoxTo_p_FXTopWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTopWindow *)  ((FXDialogBox *) x));
+}
+static void *_p_FXGradientBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShutterItemTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXMatrixTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXDialogBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXDialogBox *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXWizardTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXWizard *) x));
+}
+static void *_p_FXChoiceBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXChoiceBox *) x));
+}
+static void *_p_FXHeaderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXSplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSpringTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXProgressBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXFileDialogTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXFileDialog *) x));
+}
+static void *_p_FXReplaceDialogTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXReplaceDialog *) x));
+}
+static void *_p_FXProgressDialogTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXProgressDialog *) x));
+}
+static void *_p_FXToolTipTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXDockSiteTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXCanvasTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXCanvas *) x));
+}
+static void *_p_FXColorWheelTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXMessageBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXMessageBox *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXScrollBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXScrollBar *) x));
+}
+static void *_p_FXComboBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStatusBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXKnobTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXRulerViewTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXStatusLineTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXDockBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXDirDialogTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXDirDialog *) x));
+}
+static void *_p_FXColorDialogTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXColorDialog *) x));
+}
+static void *_p_FXFontDialogTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXFontDialog *) x));
+}
+static void *_p_FXSearchDialogTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *)(FXReplaceDialog *) ((FXSearchDialog *) x));
+}
+static void *_p_FXInputDialogTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXInputDialog *) x));
+}
+static void *_p_FXPrintDialogTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXPrintDialog *) x));
+}
+static void *_p_FXShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXToolBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXDirBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXStatusBarTo_p_FXHorizontalFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXHorizontalFrame *)  ((FXStatusBar *) x));
+}
+static void *_p_FXDirDialogTo_p_FXDialogBox(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDialogBox *)  ((FXDirDialog *) x));
+}
+static void *_p_FXColorDialogTo_p_FXDialogBox(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDialogBox *)  ((FXColorDialog *) x));
+}
+static void *_p_FXFontDialogTo_p_FXDialogBox(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDialogBox *)  ((FXFontDialog *) x));
+}
+static void *_p_FXSearchDialogTo_p_FXDialogBox(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDialogBox *) (FXReplaceDialog *) ((FXSearchDialog *) x));
+}
+static void *_p_FXInputDialogTo_p_FXDialogBox(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDialogBox *)  ((FXInputDialog *) x));
+}
+static void *_p_FXPrintDialogTo_p_FXDialogBox(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDialogBox *)  ((FXPrintDialog *) x));
+}
+static void *_p_FXMessageBoxTo_p_FXDialogBox(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDialogBox *)  ((FXMessageBox *) x));
+}
+static void *_p_FXChoiceBoxTo_p_FXDialogBox(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDialogBox *)  ((FXChoiceBox *) x));
+}
+static void *_p_FXFileDialogTo_p_FXDialogBox(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDialogBox *)  ((FXFileDialog *) x));
+}
+static void *_p_FXReplaceDialogTo_p_FXDialogBox(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDialogBox *)  ((FXReplaceDialog *) x));
+}
+static void *_p_FXProgressDialogTo_p_FXDialogBox(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDialogBox *)  ((FXProgressDialog *) x));
+}
+static void *_p_FXWizardTo_p_FXDialogBox(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDialogBox *)  ((FXWizard *) x));
+}
+static void *_p_FXDocumentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDocument *) x));
+}
+static void *_p_FXGradientBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXRegistryTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *)(FXSettings *) ((FXRegistry *) x));
+}
+static void *_p_FXHeaderItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXHeaderItem *) x));
+}
+static void *_p_FXShutterItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXIconDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXIconDict *) x));
+}
+static void *_p_FXMatrixTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXFileDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXFileDict *) x));
+}
+static void *_p_FXDialogBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXDialogBox *) x));
+}
+static void *_p_FXRecentFilesTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXRecentFiles *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXDrawableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXDrawable *) x));
+}
+static void *_p_FXWizardTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXWizard *) x));
+}
+static void *_p_FXChoiceBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXChoiceBox *) x));
+}
+static void *_p_FXAppTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXApp *) x));
+}
+static void *_p_FXHeaderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXTranslatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXTranslator *) x));
+}
+static void *_p_FX4SplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FXSpringTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXIdTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXId *) x));
+}
+static void *_p_FXProgressBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXFileDialogTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXFileDialog *) x));
+}
+static void *_p_FXReplaceDialogTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXReplaceDialog *) x));
+}
+static void *_p_FXProgressDialogTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXProgressDialog *) x));
+}
+static void *_p_FXToolTipTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXSettingsTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXSettings *) x));
+}
+static void *_p_FXDockSiteTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDebugTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDebugTarget *) x));
+}
+static void *_p_FXDataTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDataTarget *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXCanvasTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXListBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXColorWheelTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXMessageBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXMessageBox *) x));
+}
+static void *_p_FXVisualTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXVisual *) x));
+}
+static void *_p_FXScrollBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXFontTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXFont *) x));
+}
+static void *_p_FXComboBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStringDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXStringDict *) x));
+}
+static void *_p_FXStatusBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXDelegatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDelegator *) x));
+}
+static void *_p_FXAccelTableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXAccelTable *) x));
+}
+static void *_p_FXCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXKnobTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRulerViewTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXStatusLineTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXDockBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXDirDialogTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXDirDialog *) x));
+}
+static void *_p_FXColorDialogTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXColorDialog *) x));
+}
+static void *_p_FXFontDialogTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXFontDialog *) x));
+}
+static void *_p_FXSearchDialogTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *)(FXReplaceDialog *) ((FXSearchDialog *) x));
+}
+static void *_p_FXInputDialogTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXInputDialog *) x));
+}
+static void *_p_FXPrintDialogTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXPrintDialog *) x));
+}
+static void *_p_FXDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDict *) x));
+}
+static void *_p_FXShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXToolBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDirBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXGradientBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShutterItemTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXMatrixTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXDialogBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXDialogBox *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXWizardTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXWizard *) x));
+}
+static void *_p_FXChoiceBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXChoiceBox *) x));
+}
+static void *_p_FXHeaderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXSplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSpringTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXProgressBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXFileDialogTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXFileDialog *) x));
+}
+static void *_p_FXReplaceDialogTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXReplaceDialog *) x));
+}
+static void *_p_FXProgressDialogTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXProgressDialog *) x));
+}
+static void *_p_FXToolTipTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXDockSiteTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXCanvasTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXColorWheelTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXMessageBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXMessageBox *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXScrollBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXComboBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStatusBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXKnobTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXRulerViewTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXStatusLineTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *)  ((FXWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXDockBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXDirDialogTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXDirDialog *) x));
+}
+static void *_p_FXColorDialogTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXColorDialog *) x));
+}
+static void *_p_FXFontDialogTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXFontDialog *) x));
+}
+static void *_p_FXSearchDialogTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *)(FXReplaceDialog *) ((FXSearchDialog *) x));
+}
+static void *_p_FXInputDialogTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXInputDialog *) x));
+}
+static void *_p_FXPrintDialogTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXPrintDialog *) x));
+}
+static void *_p_FXShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXToolBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXDirBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXFileStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXFileStream *) x));
+}
+static void *_p_FXMemoryStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXMemoryStream *) x));
+}
+static void *_p_FXGradientBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShutterItemTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXMatrixTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXDialogBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXDialogBox *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXDrawableTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXDrawable *) x));
+}
+static void *_p_FXWizardTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXWizard *) x));
+}
+static void *_p_FXChoiceBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXChoiceBox *) x));
+}
+static void *_p_FXHeaderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXSplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSpringTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXProgressBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXFileDialogTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXFileDialog *) x));
+}
+static void *_p_FXReplaceDialogTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXReplaceDialog *) x));
+}
+static void *_p_FXProgressDialogTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXProgressDialog *) x));
+}
+static void *_p_FXToolTipTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXDockSiteTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXCanvasTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXColorWheelTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXMessageBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXMessageBox *) x));
+}
+static void *_p_FXVisualTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXVisual *) x));
+}
+static void *_p_FXScrollBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXFontTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXFont *) x));
+}
+static void *_p_FXComboBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStatusBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXCursor *) x));
+}
+static void *_p_FXKnobTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRulerViewTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXStatusLineTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXMainWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXDockBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXDirDialogTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXDirDialog *) x));
+}
+static void *_p_FXColorDialogTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXColorDialog *) x));
+}
+static void *_p_FXFontDialogTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXFontDialog *) x));
+}
+static void *_p_FXSearchDialogTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *)(FXReplaceDialog *) ((FXSearchDialog *) x));
+}
+static void *_p_FXInputDialogTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXInputDialog *) x));
+}
+static void *_p_FXPrintDialogTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *)(FXDialogBox *) ((FXPrintDialog *) x));
+}
+static void *_p_FXShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXToolBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDirBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static swig_type_info _swigt__p_FXApp = {"_p_FXApp", "FXApp *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXBitmap = {"_p_FXBitmap", "FXBitmap *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXButton = {"_p_FXButton", "FXButton *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXChoiceBox = {"_p_FXChoiceBox", "FXChoiceBox *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXColorDialog = {"_p_FXColorDialog", "FXColorDialog *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXComposite = {"_p_FXComposite", "FXComposite *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDriveBox = {"_p_FXDriveBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBar = {"_p_FXToolBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolTip = {"_p_FXToolTip", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTabBook = {"_p_FXTabBook", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGroupBox = {"_p_FXGroupBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusBar = {"_p_FXStatusBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollArea = {"_p_FXScrollArea", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPopup = {"_p_FXPopup", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollWindow = {"_p_FXScrollWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRootWindow = {"_p_FXRootWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplashWindow = {"_p_FXSplashWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMainWindow = {"_p_FXMainWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXComboBox = {"_p_FXComboBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalFrame = {"_p_FXVerticalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FX4Splitter = {"_p_FX4Splitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplitter = {"_p_FXSplitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSpinner = {"_p_FXSpinner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRealSpinner = {"_p_FXRealSpinner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPacker = {"_p_FXPacker", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDirBox = {"_p_FXDirBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFontSelector = {"_p_FXFontSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorSelector = {"_p_FXColorSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileSelector = {"_p_FXFileSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDirSelector = {"_p_FXDirSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutter = {"_p_FXShutter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockSite = {"_p_FXDockSite", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRulerView = {"_p_FXRulerView", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTreeListBox = {"_p_FXTreeListBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXListBox = {"_p_FXListBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMatrix = {"_p_FXMatrix", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutterItem = {"_p_FXShutterItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockBar = {"_p_FXDockBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTabBar = {"_p_FXTabBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImageView = {"_p_FXImageView", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSpring = {"_p_FXSpring", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarShell = {"_p_FXToolBarShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDialogBox = {"_p_FXDialogBox", "FXDialogBox *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDirDialog = {"_p_FXDirDialog", "FXDirDialog *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDrawable = {"_p_FXDrawable", "FXDrawable *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGradientBar = {"_p_FXGradientBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorBar = {"_p_FXColorBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTextField = {"_p_FXTextField", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarTab = {"_p_FXToolBarTab", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollCorner = {"_p_FXScrollCorner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXArrowButton = {"_p_FXArrowButton", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHeader = {"_p_FXHeader", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImageFrame = {"_p_FXImageFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSeparator = {"_p_FXSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalSeparator = {"_p_FXHorizontalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalSeparator = {"_p_FXVerticalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXKnob = {"_p_FXKnob", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXProgressBar = {"_p_FXProgressBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXBitmapFrame = {"_p_FXBitmapFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRealSlider = {"_p_FXRealSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSlider = {"_p_FXSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorRing = {"_p_FXColorRing", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockHandler = {"_p_FXDockHandler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCanvas = {"_p_FXCanvas", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWheel = {"_p_FXColorWheel", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDial = {"_p_FXDial", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarGrip = {"_p_FXToolBarGrip", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollBar = {"_p_FXScrollBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFrame = {"_p_FXFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FX7Segment = {"_p_FX7Segment", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockTitle = {"_p_FXDockTitle", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusLine = {"_p_FXStatusLine", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWell = {"_p_FXColorWell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDragCorner = {"_p_FXDragCorner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRuler = {"_p_FXRuler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileDialog = {"_p_FXFileDialog", "FXFileDialog *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFontDesc = {"_p_FXFontDesc", "FXFontDesc *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFontDialog = {"_p_FXFontDialog", "FXFontDialog *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXHorizontalFrame = {"_p_FXHorizontalFrame", "FXHorizontalFrame *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXIcon = {"_p_FXIcon", "FXIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXId = {"_p_FXId", "FXId *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFont = {"_p_FXFont", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVisual = {"_p_FXVisual", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCursor = {"_p_FXCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCURCursor = {"_p_FXCURCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGIFCursor = {"_p_FXGIFCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImage = {"_p_FXImage", "FXImage *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXInputDialog = {"_p_FXInputDialog", "FXInputDialog *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMessageBox = {"_p_FXMessageBox", "FXMessageBox *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXObject = {"_p_FXObject", "FXObject *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDocument = {"_p_FXDocument", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRegistry = {"_p_FXRegistry", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHeaderItem = {"_p_FXHeaderItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXIconDict = {"_p_FXIconDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileDict = {"_p_FXFileDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRecentFiles = {"_p_FXRecentFiles", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTranslator = {"_p_FXTranslator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDict = {"_p_FXDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSettings = {"_p_FXSettings", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDataTarget = {"_p_FXDataTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDebugTarget = {"_p_FXDebugTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStringDict = {"_p_FXStringDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDelegator = {"_p_FXDelegator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXAccelTable = {"_p_FXAccelTable", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPrintDialog = {"_p_FXPrintDialog", "FXPrintDialog *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXPrinter = {"_p_FXPrinter", "FXPrinter *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXProgressDialog = {"_p_FXProgressDialog", "FXProgressDialog *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRegion = {"_p_FXRegion", "FXRegion *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXReplaceDialog = {"_p_FXReplaceDialog", "FXReplaceDialog *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXSearchDialog = {"_p_FXSearchDialog", "FXSearchDialog *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXShell = {"_p_FXShell", "FXShell *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXStream = {"_p_FXStream", "FXStream *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFileStream = {"_p_FXFileStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMemoryStream = {"_p_FXMemoryStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSwitcher = {"_p_FXSwitcher", "FXSwitcher *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXTopWindow = {"_p_FXTopWindow", "FXTopWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXWindow = {"_p_FXWindow", "FXWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXWizard = {"_p_FXWizard", "FXWizard *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_char = {"_p_char", "char *|FXchar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "double *|FXdouble *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_float = {"_p_float", "float *|FXfloat *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "FXint *|int *|FXInputHandle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_long = {"_p_long", "long *|FXTime *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_short = {"_p_short", "short *|FXshort *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "FXuchar *|unsigned char *|FXbool *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "FXwchar *|FXDragType *|unsigned int *|FXuint *|FXColor *|FXSelector *|FXHotKey *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|FXuval *|FXPixel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|FXushort *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_FX4Splitter,
+  &_swigt__p_FX7Segment,
+  &_swigt__p_FXAccelTable,
+  &_swigt__p_FXApp,
+  &_swigt__p_FXArrowButton,
+  &_swigt__p_FXBitmap,
+  &_swigt__p_FXBitmapFrame,
+  &_swigt__p_FXButton,
+  &_swigt__p_FXCURCursor,
+  &_swigt__p_FXCanvas,
+  &_swigt__p_FXChoiceBox,
+  &_swigt__p_FXColorBar,
+  &_swigt__p_FXColorDialog,
+  &_swigt__p_FXColorRing,
+  &_swigt__p_FXColorSelector,
+  &_swigt__p_FXColorWell,
+  &_swigt__p_FXColorWheel,
+  &_swigt__p_FXComboBox,
+  &_swigt__p_FXComposite,
+  &_swigt__p_FXCursor,
+  &_swigt__p_FXDataTarget,
+  &_swigt__p_FXDebugTarget,
+  &_swigt__p_FXDelegator,
+  &_swigt__p_FXDial,
+  &_swigt__p_FXDialogBox,
+  &_swigt__p_FXDict,
+  &_swigt__p_FXDirBox,
+  &_swigt__p_FXDirDialog,
+  &_swigt__p_FXDirSelector,
+  &_swigt__p_FXDockBar,
+  &_swigt__p_FXDockHandler,
+  &_swigt__p_FXDockSite,
+  &_swigt__p_FXDockTitle,
+  &_swigt__p_FXDocument,
+  &_swigt__p_FXDragCorner,
+  &_swigt__p_FXDrawable,
+  &_swigt__p_FXDriveBox,
+  &_swigt__p_FXFileDialog,
+  &_swigt__p_FXFileDict,
+  &_swigt__p_FXFileSelector,
+  &_swigt__p_FXFileStream,
+  &_swigt__p_FXFont,
+  &_swigt__p_FXFontDesc,
+  &_swigt__p_FXFontDialog,
+  &_swigt__p_FXFontSelector,
+  &_swigt__p_FXFrame,
+  &_swigt__p_FXGIFCursor,
+  &_swigt__p_FXGradientBar,
+  &_swigt__p_FXGroupBox,
+  &_swigt__p_FXHeader,
+  &_swigt__p_FXHeaderItem,
+  &_swigt__p_FXHorizontalFrame,
+  &_swigt__p_FXHorizontalSeparator,
+  &_swigt__p_FXIcon,
+  &_swigt__p_FXIconDict,
+  &_swigt__p_FXId,
+  &_swigt__p_FXImage,
+  &_swigt__p_FXImageFrame,
+  &_swigt__p_FXImageView,
+  &_swigt__p_FXInputDialog,
+  &_swigt__p_FXKnob,
+  &_swigt__p_FXListBox,
+  &_swigt__p_FXMainWindow,
+  &_swigt__p_FXMatrix,
+  &_swigt__p_FXMemoryStream,
+  &_swigt__p_FXMessageBox,
+  &_swigt__p_FXObject,
+  &_swigt__p_FXPacker,
+  &_swigt__p_FXPopup,
+  &_swigt__p_FXPrintDialog,
+  &_swigt__p_FXPrinter,
+  &_swigt__p_FXProgressBar,
+  &_swigt__p_FXProgressDialog,
+  &_swigt__p_FXRealSlider,
+  &_swigt__p_FXRealSpinner,
+  &_swigt__p_FXRecentFiles,
+  &_swigt__p_FXRegion,
+  &_swigt__p_FXRegistry,
+  &_swigt__p_FXReplaceDialog,
+  &_swigt__p_FXRootWindow,
+  &_swigt__p_FXRuler,
+  &_swigt__p_FXRulerView,
+  &_swigt__p_FXScrollArea,
+  &_swigt__p_FXScrollBar,
+  &_swigt__p_FXScrollCorner,
+  &_swigt__p_FXScrollWindow,
+  &_swigt__p_FXSearchDialog,
+  &_swigt__p_FXSeparator,
+  &_swigt__p_FXSettings,
+  &_swigt__p_FXShell,
+  &_swigt__p_FXShutter,
+  &_swigt__p_FXShutterItem,
+  &_swigt__p_FXSlider,
+  &_swigt__p_FXSpinner,
+  &_swigt__p_FXSplashWindow,
+  &_swigt__p_FXSplitter,
+  &_swigt__p_FXSpring,
+  &_swigt__p_FXStatusBar,
+  &_swigt__p_FXStatusLine,
+  &_swigt__p_FXStream,
+  &_swigt__p_FXStringDict,
+  &_swigt__p_FXSwitcher,
+  &_swigt__p_FXTabBar,
+  &_swigt__p_FXTabBook,
+  &_swigt__p_FXTextField,
+  &_swigt__p_FXToolBar,
+  &_swigt__p_FXToolBarGrip,
+  &_swigt__p_FXToolBarShell,
+  &_swigt__p_FXToolBarTab,
+  &_swigt__p_FXToolTip,
+  &_swigt__p_FXTopWindow,
+  &_swigt__p_FXTranslator,
+  &_swigt__p_FXTreeListBox,
+  &_swigt__p_FXVerticalFrame,
+  &_swigt__p_FXVerticalSeparator,
+  &_swigt__p_FXVisual,
+  &_swigt__p_FXWindow,
+  &_swigt__p_FXWizard,
+  &_swigt__p_char,
+  &_swigt__p_double,
+  &_swigt__p_float,
+  &_swigt__p_int,
+  &_swigt__p_long,
+  &_swigt__p_short,
+  &_swigt__p_unsigned_char,
+  &_swigt__p_unsigned_int,
+  &_swigt__p_unsigned_long,
+  &_swigt__p_unsigned_short,
+};
+
+static swig_cast_info _swigc__p_FXApp[] = {  {&_swigt__p_FXApp, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBitmap[] = {  {&_swigt__p_FXBitmap, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXButton[] = {  {&_swigt__p_FXButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXChoiceBox[] = {  {&_swigt__p_FXChoiceBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorDialog[] = {  {&_swigt__p_FXColorDialog, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDriveBox[] = {{&_swigt__p_FXDriveBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBar[] = {{&_swigt__p_FXToolBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolTip[] = {{&_swigt__p_FXToolTip, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabBook[] = {{&_swigt__p_FXTabBook, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGroupBox[] = {{&_swigt__p_FXGroupBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusBar[] = {{&_swigt__p_FXStatusBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollArea[] = {{&_swigt__p_FXScrollArea, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPopup[] = {{&_swigt__p_FXPopup, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollWindow[] = {{&_swigt__p_FXScrollWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRootWindow[] = {{&_swigt__p_FXRootWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplashWindow[] = {{&_swigt__p_FXSplashWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMainWindow[] = {{&_swigt__p_FXMainWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComboBox[] = {{&_swigt__p_FXComboBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalFrame[] = {{&_swigt__p_FXVerticalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FX4Splitter[] = {{&_swigt__p_FX4Splitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplitter[] = {{&_swigt__p_FXSplitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpinner[] = {{&_swigt__p_FXSpinner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSpinner[] = {{&_swigt__p_FXRealSpinner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPacker[] = {{&_swigt__p_FXPacker, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirBox[] = {{&_swigt__p_FXDirBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFontSelector[] = {{&_swigt__p_FXFontSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorSelector[] = {{&_swigt__p_FXColorSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileSelector[] = {{&_swigt__p_FXFileSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirSelector[] = {{&_swigt__p_FXDirSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutter[] = {{&_swigt__p_FXShutter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockSite[] = {{&_swigt__p_FXDockSite, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRulerView[] = {{&_swigt__p_FXRulerView, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTreeListBox[] = {{&_swigt__p_FXTreeListBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXListBox[] = {{&_swigt__p_FXListBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMatrix[] = {{&_swigt__p_FXMatrix, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutterItem[] = {{&_swigt__p_FXShutterItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockBar[] = {{&_swigt__p_FXDockBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabBar[] = {{&_swigt__p_FXTabBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageView[] = {{&_swigt__p_FXImageView, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpring[] = {{&_swigt__p_FXSpring, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarShell[] = {{&_swigt__p_FXToolBarShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComposite[] = {  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMessageBox, _p_FXMessageBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXComposite, 0, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXComposite, 0, 0},  {&_swigt__p_FXFileDialog, _p_FXFileDialogTo_p_FXComposite, 0, 0},  {&_swigt__p_FXReplaceDialog, _p_FXReplaceDialogTo_p_FXComposite, 0, 0},  {&_swigt__p_FXProgressDialog, _p_FXProgressDialogTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXComposite, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXComposite, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDialogBox, _p_FXDialogBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXComposite, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXComposite, 0, 0},  {&_swigt__p_FXWizard, _p_FXWizardTo_p_FXComposite, 0, 0},  {&_swigt__p_FXChoiceBox, _p_FXChoiceBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXComposite, 0, 0},  {&_swigt__p_FXInputDialog, _p_FXInputDialogTo_p_FXComposite, 0, 0},  {&_swigt__p_FXFontDialog, _p_FXFontDialogTo_p_FXComposite, 0, 0},  {&_swigt__p_FXColorDialog, _p_FXColorDialogTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDirDialog, _p_FXDirDialogTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSearchDialog, _p_FXSearchDialogTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPrintDialog, _p_FXPrintDialogTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXComposite, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXComposite, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDialogBox[] = {  {&_swigt__p_FXDialogBox, 0, 0, 0},  {&_swigt__p_FXDirDialog, _p_FXDirDialogTo_p_FXDialogBox, 0, 0},  {&_swigt__p_FXColorDialog, _p_FXColorDialogTo_p_FXDialogBox, 0, 0},  {&_swigt__p_FXFontDialog, _p_FXFontDialogTo_p_FXDialogBox, 0, 0},  {&_swigt__p_FXSearchDialog, _p_FXSearchDialogTo_p_FXDialogBox, 0, 0},  {&_swigt__p_FXInputDialog, _p_FXInputDialogTo_p_FXDialogBox, 0, 0},  {&_swigt__p_FXPrintDialog, _p_FXPrintDialogTo_p_FXDialogBox, 0, 0},  {&_swigt__p_FXMessageBox, _p_FXMessageBoxTo_p_FXDialogBox, 0, 0},  {&_swigt__p_FXChoiceBox, _p_FXChoiceBoxTo_p_FXDialogBox, 0, 0},  {&_swigt__p_FXFileDialog, _p_FXFileDialogTo_p_FXDialogBox, 0, 0},  {&_swigt__p_FXReplaceDialog, _p_FXReplaceDialogTo_p_FXDialogBox, 0, 0},  {&_swigt__p_FXProgressDialog, _p_FXProgressDialogTo_p_FXDialogBox, 0, 0},  {&_swigt__p_FXWizard, _p_FXWizardTo_p_FXDialogBox, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirDialog[] = {  {&_swigt__p_FXDirDialog, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGradientBar[] = {{&_swigt__p_FXGradientBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorBar[] = {{&_swigt__p_FXColorBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTextField[] = {{&_swigt__p_FXTextField, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarTab[] = {{&_swigt__p_FXToolBarTab, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollCorner[] = {{&_swigt__p_FXScrollCorner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXArrowButton[] = {{&_swigt__p_FXArrowButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeader[] = {{&_swigt__p_FXHeader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageFrame[] = {{&_swigt__p_FXImageFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSeparator[] = {{&_swigt__p_FXSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalSeparator[] = {{&_swigt__p_FXHorizontalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalSeparator[] = {{&_swigt__p_FXVerticalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXKnob[] = {{&_swigt__p_FXKnob, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXProgressBar[] = {{&_swigt__p_FXProgressBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBitmapFrame[] = {{&_swigt__p_FXBitmapFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSlider[] = {{&_swigt__p_FXRealSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSlider[] = {{&_swigt__p_FXSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorRing[] = {{&_swigt__p_FXColorRing, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockHandler[] = {{&_swigt__p_FXDockHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCanvas[] = {{&_swigt__p_FXCanvas, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWheel[] = {{&_swigt__p_FXColorWheel, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDial[] = {{&_swigt__p_FXDial, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarGrip[] = {{&_swigt__p_FXToolBarGrip, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollBar[] = {{&_swigt__p_FXScrollBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFrame[] = {{&_swigt__p_FXFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FX7Segment[] = {{&_swigt__p_FX7Segment, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockTitle[] = {{&_swigt__p_FXDockTitle, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusLine[] = {{&_swigt__p_FXStatusLine, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWell[] = {{&_swigt__p_FXColorWell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDragCorner[] = {{&_swigt__p_FXDragCorner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRuler[] = {{&_swigt__p_FXRuler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDrawable[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDialogBox, _p_FXDialogBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDrawable, 0, 0, 0},  {&_swigt__p_FXWizard, _p_FXWizardTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXChoiceBox, _p_FXChoiceBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFileDialog, _p_FXFileDialogTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXReplaceDialog, _p_FXReplaceDialogTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXProgressDialog, _p_FXProgressDialogTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMessageBox, _p_FXMessageBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFontDialog, _p_FXFontDialogTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorDialog, _p_FXColorDialogTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirDialog, _p_FXDirDialogTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSearchDialog, _p_FXSearchDialogTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXInputDialog, _p_FXInputDialogTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPrintDialog, _p_FXPrintDialogTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXDrawable, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileDialog[] = {  {&_swigt__p_FXFileDialog, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFontDesc[] = {  {&_swigt__p_FXFontDesc, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFontDialog[] = {  {&_swigt__p_FXFontDialog, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalFrame[] = {  {&_swigt__p_FXHorizontalFrame, 0, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXHorizontalFrame, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIcon[] = {  {&_swigt__p_FXIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFont[] = {{&_swigt__p_FXFont, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVisual[] = {{&_swigt__p_FXVisual, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCursor[] = {{&_swigt__p_FXCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCURCursor[] = {{&_swigt__p_FXCURCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGIFCursor[] = {{&_swigt__p_FXGIFCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXId[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXId, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXId, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXId, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXId, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXId, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXId, 0, 0},  {&_swigt__p_FXDialogBox, _p_FXDialogBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXId, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXId, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXId, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXId, 0, 0},  {&_swigt__p_FXWizard, _p_FXWizardTo_p_FXId, 0, 0},  {&_swigt__p_FXChoiceBox, _p_FXChoiceBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXId, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXId, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXId, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXId, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXId, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXId, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXId, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXId, 0, 0},  {&_swigt__p_FXFileDialog, _p_FXFileDialogTo_p_FXId, 0, 0},  {&_swigt__p_FXReplaceDialog, _p_FXReplaceDialogTo_p_FXId, 0, 0},  {&_swigt__p_FXProgressDialog, _p_FXProgressDialogTo_p_FXId, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXId, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXId, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXId, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXId, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXId, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXId, 0, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXId, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXId, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXId, 0, 0},  {&_swigt__p_FXMessageBox, _p_FXMessageBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXId, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXId, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXId, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXId, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXId, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXId, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXId, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXId, 0, 0},  {&_swigt__p_FXFontDialog, _p_FXFontDialogTo_p_FXId, 0, 0},  {&_swigt__p_FXColorDialog, _p_FXColorDialogTo_p_FXId, 0, 0},  {&_swigt__p_FXDirDialog, _p_FXDirDialogTo_p_FXId, 0, 0},  {&_swigt__p_FXSearchDialog, _p_FXSearchDialogTo_p_FXId, 0, 0},  {&_swigt__p_FXInputDialog, _p_FXInputDialogTo_p_FXId, 0, 0},  {&_swigt__p_FXPrintDialog, _p_FXPrintDialogTo_p_FXId, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXId, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXId, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXId, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXId, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXId, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXId, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImage[] = {  {&_swigt__p_FXImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXInputDialog[] = {  {&_swigt__p_FXInputDialog, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMessageBox[] = {  {&_swigt__p_FXMessageBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDocument[] = {{&_swigt__p_FXDocument, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegistry[] = {{&_swigt__p_FXRegistry, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeaderItem[] = {{&_swigt__p_FXHeaderItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIconDict[] = {{&_swigt__p_FXIconDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileDict[] = {{&_swigt__p_FXFileDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRecentFiles[] = {{&_swigt__p_FXRecentFiles, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTranslator[] = {{&_swigt__p_FXTranslator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDict[] = {{&_swigt__p_FXDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSettings[] = {{&_swigt__p_FXSettings, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDataTarget[] = {{&_swigt__p_FXDataTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDebugTarget[] = {{&_swigt__p_FXDebugTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStringDict[] = {{&_swigt__p_FXStringDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDelegator[] = {{&_swigt__p_FXDelegator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXAccelTable[] = {{&_swigt__p_FXAccelTable, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXObject[] = {  {&_swigt__p_FXDocument, _p_FXDocumentTo_p_FXObject, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXRegistry, _p_FXRegistryTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeaderItem, _p_FXHeaderItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXObject, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXObject, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXIconDict, _p_FXIconDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileDict, _p_FXFileDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXDialogBox, _p_FXDialogBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXRecentFiles, _p_FXRecentFilesTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXObject, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXObject, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXObject, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXObject, 0, 0},  {&_swigt__p_FXWizard, _p_FXWizardTo_p_FXObject, 0, 0},  {&_swigt__p_FXChoiceBox, _p_FXChoiceBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXObject, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FXTranslator, _p_FXTranslatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXObject, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXObject, 0, 0},  {&_swigt__p_FXApp, _p_FXAppTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXObject, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileDialog, _p_FXFileDialogTo_p_FXObject, 0, 0},  {&_swigt__p_FXReplaceDialog, _p_FXReplaceDialogTo_p_FXObject, 0, 0},  {&_swigt__p_FXProgressDialog, _p_FXProgressDialogTo_p_FXObject, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXObject, 0, 0},  {&_swigt__p_FXDict, _p_FXDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXSettings, _p_FXSettingsTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXObject, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXObject, 0, 0},  {&_swigt__p_FXDataTarget, _p_FXDataTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDebugTarget, _p_FXDebugTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXObject, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXObject, 0, 0},  {&_swigt__p_FXId, _p_FXIdTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXObject, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXObject, 0, 0},  {&_swigt__p_FXMessageBox, _p_FXMessageBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXObject, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXStringDict, _p_FXStringDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXDelegator, _p_FXDelegatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXAccelTable, _p_FXAccelTableTo_p_FXObject, 0, 0},  {&_swigt__p_FXObject, 0, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXObject, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirDialog, _p_FXDirDialogTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorDialog, _p_FXColorDialogTo_p_FXObject, 0, 0},  {&_swigt__p_FXFontDialog, _p_FXFontDialogTo_p_FXObject, 0, 0},  {&_swigt__p_FXSearchDialog, _p_FXSearchDialogTo_p_FXObject, 0, 0},  {&_swigt__p_FXInputDialog, _p_FXInputDialogTo_p_FXObject, 0, 0},  {&_swigt__p_FXPrintDialog, _p_FXPrintDialogTo_p_FXObject, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXObject, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXObject, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXObject, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPrintDialog[] = {  {&_swigt__p_FXPrintDialog, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPrinter[] = {  {&_swigt__p_FXPrinter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXProgressDialog[] = {  {&_swigt__p_FXProgressDialog, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegion[] = {  {&_swigt__p_FXRegion, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXReplaceDialog[] = {  {&_swigt__p_FXSearchDialog, _p_FXSearchDialogTo_p_FXReplaceDialog, 0, 0},  {&_swigt__p_FXReplaceDialog, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSearchDialog[] = {  {&_swigt__p_FXSearchDialog, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShell[] = {  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXShell, 0, 0},  {&_swigt__p_FXInputDialog, _p_FXInputDialogTo_p_FXShell, 0, 0},  {&_swigt__p_FXSearchDialog, _p_FXSearchDialogTo_p_FXShell, 0, 0},  {&_swigt__p_FXFontDialog, _p_FXFontDialogTo_p_FXShell, 0, 0},  {&_swigt__p_FXColorDialog, _p_FXColorDialogTo_p_FXShell, 0, 0},  {&_swigt__p_FXDirDialog, _p_FXDirDialogTo_p_FXShell, 0, 0},  {&_swigt__p_FXPrintDialog, _p_FXPrintDialogTo_p_FXShell, 0, 0},  {&_swigt__p_FXMessageBox, _p_FXMessageBoxTo_p_FXShell, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXShell, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXShell, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXShell, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXShell, 0, 0},  {&_swigt__p_FXChoiceBox, _p_FXChoiceBoxTo_p_FXShell, 0, 0},  {&_swigt__p_FXShell, 0, 0, 0},  {&_swigt__p_FXWizard, _p_FXWizardTo_p_FXShell, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXShell, 0, 0},  {&_swigt__p_FXProgressDialog, _p_FXProgressDialogTo_p_FXShell, 0, 0},  {&_swigt__p_FXReplaceDialog, _p_FXReplaceDialogTo_p_FXShell, 0, 0},  {&_swigt__p_FXFileDialog, _p_FXFileDialogTo_p_FXShell, 0, 0},  {&_swigt__p_FXDialogBox, _p_FXDialogBoxTo_p_FXShell, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileStream[] = {{&_swigt__p_FXFileStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMemoryStream[] = {{&_swigt__p_FXMemoryStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStream[] = {  {&_swigt__p_FXFileStream, _p_FXFileStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXMemoryStream, _p_FXMemoryStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSwitcher[] = {  {&_swigt__p_FXSwitcher, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTopWindow[] = {  {&_swigt__p_FXMessageBox, _p_FXMessageBoxTo_p_FXTopWindow, 0, 0},  {&_swigt__p_FXPrintDialog, _p_FXPrintDialogTo_p_FXTopWindow, 0, 0},  {&_swigt__p_FXInputDialog, _p_FXInputDialogTo_p_FXTopWindow, 0, 0},  {&_swigt__p_FXSearchDialog, _p_FXSearchDialogTo_p_FXTopWindow, 0, 0},  {&_swigt__p_FXFontDialog, _p_FXFontDialogTo_p_FXTopWindow, 0, 0},  {&_swigt__p_FXColorDialog, _p_FXColorDialogTo_p_FXTopWindow, 0, 0},  {&_swigt__p_FXDirDialog, _p_FXDirDialogTo_p_FXTopWindow, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXTopWindow, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXTopWindow, 0, 0},  {&_swigt__p_FXTopWindow, 0, 0, 0},  {&_swigt__p_FXChoiceBox, _p_FXChoiceBoxTo_p_FXTopWindow, 0, 0},  {&_swigt__p_FXWizard, _p_FXWizardTo_p_FXTopWindow, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXTopWindow, 0, 0},  {&_swigt__p_FXProgressDialog, _p_FXProgressDialogTo_p_FXTopWindow, 0, 0},  {&_swigt__p_FXReplaceDialog, _p_FXReplaceDialogTo_p_FXTopWindow, 0, 0},  {&_swigt__p_FXFileDialog, _p_FXFileDialogTo_p_FXTopWindow, 0, 0},  {&_swigt__p_FXDialogBox, _p_FXDialogBoxTo_p_FXTopWindow, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXWindow[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDialogBox, _p_FXDialogBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXWindow, 0, 0},  {&_swigt__p_FXWizard, _p_FXWizardTo_p_FXWindow, 0, 0},  {&_swigt__p_FXChoiceBox, _p_FXChoiceBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXWindow, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXWindow, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFileDialog, _p_FXFileDialogTo_p_FXWindow, 0, 0},  {&_swigt__p_FXReplaceDialog, _p_FXReplaceDialogTo_p_FXWindow, 0, 0},  {&_swigt__p_FXProgressDialog, _p_FXProgressDialogTo_p_FXWindow, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXWindow, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXWindow, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMessageBox, _p_FXMessageBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXWindow, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXWindow, 0, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFontDialog, _p_FXFontDialogTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorDialog, _p_FXColorDialogTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDirDialog, _p_FXDirDialogTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSearchDialog, _p_FXSearchDialogTo_p_FXWindow, 0, 0},  {&_swigt__p_FXInputDialog, _p_FXInputDialogTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPrintDialog, _p_FXPrintDialogTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXWindow, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXWizard[] = {  {&_swigt__p_FXWizard, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
+
+static swig_cast_info *swig_cast_initial[] = {
+  _swigc__p_FX4Splitter,
+  _swigc__p_FX7Segment,
+  _swigc__p_FXAccelTable,
+  _swigc__p_FXApp,
+  _swigc__p_FXArrowButton,
+  _swigc__p_FXBitmap,
+  _swigc__p_FXBitmapFrame,
+  _swigc__p_FXButton,
+  _swigc__p_FXCURCursor,
+  _swigc__p_FXCanvas,
+  _swigc__p_FXChoiceBox,
+  _swigc__p_FXColorBar,
+  _swigc__p_FXColorDialog,
+  _swigc__p_FXColorRing,
+  _swigc__p_FXColorSelector,
+  _swigc__p_FXColorWell,
+  _swigc__p_FXColorWheel,
+  _swigc__p_FXComboBox,
+  _swigc__p_FXComposite,
+  _swigc__p_FXCursor,
+  _swigc__p_FXDataTarget,
+  _swigc__p_FXDebugTarget,
+  _swigc__p_FXDelegator,
+  _swigc__p_FXDial,
+  _swigc__p_FXDialogBox,
+  _swigc__p_FXDict,
+  _swigc__p_FXDirBox,
+  _swigc__p_FXDirDialog,
+  _swigc__p_FXDirSelector,
+  _swigc__p_FXDockBar,
+  _swigc__p_FXDockHandler,
+  _swigc__p_FXDockSite,
+  _swigc__p_FXDockTitle,
+  _swigc__p_FXDocument,
+  _swigc__p_FXDragCorner,
+  _swigc__p_FXDrawable,
+  _swigc__p_FXDriveBox,
+  _swigc__p_FXFileDialog,
+  _swigc__p_FXFileDict,
+  _swigc__p_FXFileSelector,
+  _swigc__p_FXFileStream,
+  _swigc__p_FXFont,
+  _swigc__p_FXFontDesc,
+  _swigc__p_FXFontDialog,
+  _swigc__p_FXFontSelector,
+  _swigc__p_FXFrame,
+  _swigc__p_FXGIFCursor,
+  _swigc__p_FXGradientBar,
+  _swigc__p_FXGroupBox,
+  _swigc__p_FXHeader,
+  _swigc__p_FXHeaderItem,
+  _swigc__p_FXHorizontalFrame,
+  _swigc__p_FXHorizontalSeparator,
+  _swigc__p_FXIcon,
+  _swigc__p_FXIconDict,
+  _swigc__p_FXId,
+  _swigc__p_FXImage,
+  _swigc__p_FXImageFrame,
+  _swigc__p_FXImageView,
+  _swigc__p_FXInputDialog,
+  _swigc__p_FXKnob,
+  _swigc__p_FXListBox,
+  _swigc__p_FXMainWindow,
+  _swigc__p_FXMatrix,
+  _swigc__p_FXMemoryStream,
+  _swigc__p_FXMessageBox,
+  _swigc__p_FXObject,
+  _swigc__p_FXPacker,
+  _swigc__p_FXPopup,
+  _swigc__p_FXPrintDialog,
+  _swigc__p_FXPrinter,
+  _swigc__p_FXProgressBar,
+  _swigc__p_FXProgressDialog,
+  _swigc__p_FXRealSlider,
+  _swigc__p_FXRealSpinner,
+  _swigc__p_FXRecentFiles,
+  _swigc__p_FXRegion,
+  _swigc__p_FXRegistry,
+  _swigc__p_FXReplaceDialog,
+  _swigc__p_FXRootWindow,
+  _swigc__p_FXRuler,
+  _swigc__p_FXRulerView,
+  _swigc__p_FXScrollArea,
+  _swigc__p_FXScrollBar,
+  _swigc__p_FXScrollCorner,
+  _swigc__p_FXScrollWindow,
+  _swigc__p_FXSearchDialog,
+  _swigc__p_FXSeparator,
+  _swigc__p_FXSettings,
+  _swigc__p_FXShell,
+  _swigc__p_FXShutter,
+  _swigc__p_FXShutterItem,
+  _swigc__p_FXSlider,
+  _swigc__p_FXSpinner,
+  _swigc__p_FXSplashWindow,
+  _swigc__p_FXSplitter,
+  _swigc__p_FXSpring,
+  _swigc__p_FXStatusBar,
+  _swigc__p_FXStatusLine,
+  _swigc__p_FXStream,
+  _swigc__p_FXStringDict,
+  _swigc__p_FXSwitcher,
+  _swigc__p_FXTabBar,
+  _swigc__p_FXTabBook,
+  _swigc__p_FXTextField,
+  _swigc__p_FXToolBar,
+  _swigc__p_FXToolBarGrip,
+  _swigc__p_FXToolBarShell,
+  _swigc__p_FXToolBarTab,
+  _swigc__p_FXToolTip,
+  _swigc__p_FXTopWindow,
+  _swigc__p_FXTranslator,
+  _swigc__p_FXTreeListBox,
+  _swigc__p_FXVerticalFrame,
+  _swigc__p_FXVerticalSeparator,
+  _swigc__p_FXVisual,
+  _swigc__p_FXWindow,
+  _swigc__p_FXWizard,
+  _swigc__p_char,
+  _swigc__p_double,
+  _swigc__p_float,
+  _swigc__p_int,
+  _swigc__p_long,
+  _swigc__p_short,
+  _swigc__p_unsigned_char,
+  _swigc__p_unsigned_int,
+  _swigc__p_unsigned_long,
+  _swigc__p_unsigned_short,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned statically to an initial
+ * array. We just loop through that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded.
+ * There are three cases to handle:
+ *  1) If the cast->type has already been loaded AND the type we are adding
+ *     casting info to has not been loaded (it is in this module), THEN we
+ *     replace the cast->type pointer with the type pointer that has already
+ *     been loaded.
+ *  2) If BOTH types (the one we are adding casting info to, and the
+ *     cast->type) are loaded, THEN the cast info has already been loaded by
+ *     the previous module so we just ignore it.
+ *  3) Finally, if cast->type has not already been loaded, then we add that
+ *     swig_cast_info to the linked list (because the cast->type) pointer will
+ *     be correct.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* c-mode */
+#endif
+#endif
+
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+  size_t i;
+  swig_module_info *module_head, *iter;
+  int init;
+
+  /* check to see if the circular list has been setup, if not, set it up */
+  if (swig_module.next==0) {
+    /* Initialize the swig_module */
+    swig_module.type_initial = swig_type_initial;
+    swig_module.cast_initial = swig_cast_initial;
+    swig_module.next = &swig_module;
+    init = 1;
+  } else {
+    init = 0;
+  }
+
+  /* Try and load any already created modules */
+  module_head = SWIG_GetModule(clientdata);
+  if (!module_head) {
+    /* This is the first module loaded for this interpreter */
+    /* so set the swig module into the interpreter */
+    SWIG_SetModule(clientdata, &swig_module);
+  } else {
+    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+    iter=module_head;
+    do {
+      if (iter==&swig_module) {
+        /* Our module is already in the list, so there's nothing more to do. */
+        return;
+      }
+      iter=iter->next;
+    } while (iter!= module_head);
+
+    /* otherwise we must add our module into the list */
+    swig_module.next = module_head->next;
+    module_head->next = &swig_module;
+  }
+
+  /* When multiple interpreters are used, a module could have already been initialized in
+     a different interpreter, but not yet have a pointer in this interpreter.
+     In this case, we do not want to continue adding types... everything should be
+     set up already */
+  if (init == 0) return;
+
+  /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+  for (i = 0; i < swig_module.size; ++i) {
+    swig_type_info *type = 0;
+    swig_type_info *ret;
+    swig_cast_info *cast;
+
+#ifdef SWIGRUNTIME_DEBUG
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+
+    /* if there is another module already loaded */
+    if (swig_module.next != &swig_module) {
+      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
+    }
+    if (type) {
+      /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+      if (swig_module.type_initial[i]->clientdata) {
+	type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+      }
+    } else {
+      type = swig_module.type_initial[i];
+    }
+
+    /* Insert casting types */
+    cast = swig_module.cast_initial[i];
+    while (cast->type) {
+
+      /* Don't need to add information already in the list */
+      ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+      if (swig_module.next != &swig_module) {
+        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+      }
+      if (ret) {
+	if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+	  cast->type = ret;
+	  ret = 0;
+	} else {
+	  /* Check for casting already in the list */
+	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+	  if (!ocast) ret = 0;
+	}
+      }
+
+      if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+        if (type->cast) {
+          type->cast->prev = cast;
+          cast->next = type->cast;
+        }
+        type->cast = cast;
+      }
+      cast++;
+    }
+    /* Set entry in modules->types array equal to the type */
+    swig_module.types[i] = type;
+  }
+  swig_module.types[i] = 0;
+
+#ifdef SWIGRUNTIME_DEBUG
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+  for (i = 0; i < swig_module.size; ++i) {
+    int j = 0;
+    swig_cast_info *cast = swig_module.cast_initial[i];
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    while (cast->type) {
+      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+      cast++;
+      ++j;
+    }
+  printf("---- Total casts: %d\n",j);
+  }
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types.  It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+  size_t i;
+  swig_cast_info *equiv;
+  static int init_run = 0;
+
+  if (init_run) return;
+  init_run = 1;
+
+  for (i = 0; i < swig_module.size; i++) {
+    if (swig_module.types[i]->clientdata) {
+      equiv = swig_module.types[i]->cast;
+      while (equiv) {
+        if (!equiv->converter) {
+          if (equiv->type && !equiv->type->clientdata)
+            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+        }
+        equiv = equiv->next;
+      }
+    }
+  }
+}
+
+#ifdef __cplusplus
+#if 0
+{ /* c-mode */
+#endif
+}
+#endif
+
+/*
+
+*/
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void Init_dialogs(void) {
+  size_t i;
+  
+  SWIG_InitRuntime();
+  
+  
+  SWIG_InitializeModule(0);
+  for (i = 0; i < swig_module.size; i++) {
+    SWIG_define_class(swig_module.types[i]);
+  }
+  
+  SWIG_RubyInitializeTrackings();
+  
+  
+  
+  
+  
+  SwigClassFXDialogBox.klass = rb_define_class_under(mFox, "FXDialogBox", ((swig_class *) SWIGTYPE_p_FXTopWindow->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXDialogBox, (void *) &SwigClassFXDialogBox);
+  rb_define_alloc_func(SwigClassFXDialogBox.klass, _wrap_FXDialogBox_allocate);
+  rb_define_method(SwigClassFXDialogBox.klass, "initialize", VALUEFUNC(_wrap_new_FXDialogBox), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "onKeyPress", VALUEFUNC(_wrap_FXDialogBox_onKeyPress), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "onKeyRelease", VALUEFUNC(_wrap_FXDialogBox_onKeyRelease), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "onCmdAccept", VALUEFUNC(_wrap_FXDialogBox_onCmdAccept), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "onCmdCancel", VALUEFUNC(_wrap_FXDialogBox_onCmdCancel), -1);
+  rb_define_const(SwigClassFXDialogBox.klass, "ID_CANCEL", SWIG_From_int(static_cast< int >(FXDialogBox::ID_CANCEL)));
+  rb_define_const(SwigClassFXDialogBox.klass, "ID_ACCEPT", SWIG_From_int(static_cast< int >(FXDialogBox::ID_ACCEPT)));
+  rb_define_const(SwigClassFXDialogBox.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXDialogBox::ID_LAST)));
+  rb_define_method(SwigClassFXDialogBox.klass, "save", VALUEFUNC(_wrap_FXDialogBox_save), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "load", VALUEFUNC(_wrap_FXDialogBox_load), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "create", VALUEFUNC(_wrap_FXDialogBox_create), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "detach", VALUEFUNC(_wrap_FXDialogBox_detach), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "destroy", VALUEFUNC(_wrap_FXDialogBox_destroy), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "resize", VALUEFUNC(_wrap_FXDialogBox_resize), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXDialogBox_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXDialogBox_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXDialogBox_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXDialogBox_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "canFocus", VALUEFUNC(_wrap_FXDialogBox_canFocus), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "setFocus", VALUEFUNC(_wrap_FXDialogBox_setFocus), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "killFocus", VALUEFUNC(_wrap_FXDialogBox_killFocus), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "changeFocus", VALUEFUNC(_wrap_FXDialogBox_changeFocus), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "setDefault", VALUEFUNC(_wrap_FXDialogBox_setDefault), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "enable", VALUEFUNC(_wrap_FXDialogBox_enable), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "disable", VALUEFUNC(_wrap_FXDialogBox_disable), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "raiseWindow", VALUEFUNC(_wrap_FXDialogBox_raiseWindow), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "lower", VALUEFUNC(_wrap_FXDialogBox_lower), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "move", VALUEFUNC(_wrap_FXDialogBox_move), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "position", VALUEFUNC(_wrap_FXDialogBox_position), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "layout", VALUEFUNC(_wrap_FXDialogBox_layout), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "recalc", VALUEFUNC(_wrap_FXDialogBox_recalc), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "reparent", VALUEFUNC(_wrap_FXDialogBox_reparent), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "hide", VALUEFUNC(_wrap_FXDialogBox_hide), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "isComposite", VALUEFUNC(_wrap_FXDialogBox_isComposite), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "contains", VALUEFUNC(_wrap_FXDialogBox_contains), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXDialogBox_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "setBackColor", VALUEFUNC(_wrap_FXDialogBox_setBackColor), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "tr", VALUEFUNC(_wrap_FXDialogBox_tr), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "dropEnable", VALUEFUNC(_wrap_FXDialogBox_dropEnable), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "dropDisable", VALUEFUNC(_wrap_FXDialogBox_dropDisable), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "setShape", VALUEFUNC(_wrap_FXDialogBox_setShape), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "clearShape", VALUEFUNC(_wrap_FXDialogBox_clearShape), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "show", VALUEFUNC(_wrap_FXDialogBox_show), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "maximize", VALUEFUNC(_wrap_FXDialogBox_maximize), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "minimize", VALUEFUNC(_wrap_FXDialogBox_minimize), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "restore", VALUEFUNC(_wrap_FXDialogBox_restore), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "close", VALUEFUNC(_wrap_FXDialogBox_close), -1);
+  rb_define_method(SwigClassFXDialogBox.klass, "execute", VALUEFUNC(_wrap_FXDialogBox_execute), -1);
+  SwigClassFXDialogBox.mark = (void (*)(void *)) FXRbDialogBox::markfunc;
+  SwigClassFXDialogBox.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXDialogBox.trackObjects = 0;
+  
+  SWIGTYPE_p_FXDialogBox->dcast = (swig_dycast_func) FXDialogBox_dynamic_cast;
+  
+  
+  SwigClassFXDirDialog.klass = rb_define_class_under(mFox, "FXDirDialog", ((swig_class *) SWIGTYPE_p_FXDialogBox->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXDirDialog, (void *) &SwigClassFXDirDialog);
+  rb_define_alloc_func(SwigClassFXDirDialog.klass, _wrap_FXDirDialog_allocate);
+  rb_define_method(SwigClassFXDirDialog.klass, "initialize", VALUEFUNC(_wrap_new_FXDirDialog), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "setDirectory", VALUEFUNC(_wrap_FXDirDialog_setDirectory), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "getDirectory", VALUEFUNC(_wrap_FXDirDialog_getDirectory), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "getShowFiles", VALUEFUNC(_wrap_FXDirDialog_getShowFiles), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "setShowFiles", VALUEFUNC(_wrap_FXDirDialog_setShowFiles), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "getShowHiddenFiles", VALUEFUNC(_wrap_FXDirDialog_getShowHiddenFiles), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "setShowHiddenFiles", VALUEFUNC(_wrap_FXDirDialog_setShowHiddenFiles), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "getMatchMode", VALUEFUNC(_wrap_FXDirDialog_getMatchMode), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "setMatchMode", VALUEFUNC(_wrap_FXDirDialog_setMatchMode), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "setDirBoxStyle", VALUEFUNC(_wrap_FXDirDialog_setDirBoxStyle), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "getDirBoxStyle", VALUEFUNC(_wrap_FXDirDialog_getDirBoxStyle), -1);
+  rb_define_singleton_method(SwigClassFXDirDialog.klass, "getOpenDirectory", VALUEFUNC(_wrap_FXDirDialog_getOpenDirectory), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "save", VALUEFUNC(_wrap_FXDirDialog_save), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "load", VALUEFUNC(_wrap_FXDirDialog_load), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "create", VALUEFUNC(_wrap_FXDirDialog_create), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "detach", VALUEFUNC(_wrap_FXDirDialog_detach), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "destroy", VALUEFUNC(_wrap_FXDirDialog_destroy), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "resize", VALUEFUNC(_wrap_FXDirDialog_resize), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXDirDialog_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXDirDialog_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXDirDialog_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXDirDialog_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "canFocus", VALUEFUNC(_wrap_FXDirDialog_canFocus), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "setFocus", VALUEFUNC(_wrap_FXDirDialog_setFocus), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "killFocus", VALUEFUNC(_wrap_FXDirDialog_killFocus), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "changeFocus", VALUEFUNC(_wrap_FXDirDialog_changeFocus), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "setDefault", VALUEFUNC(_wrap_FXDirDialog_setDefault), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "enable", VALUEFUNC(_wrap_FXDirDialog_enable), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "disable", VALUEFUNC(_wrap_FXDirDialog_disable), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "raiseWindow", VALUEFUNC(_wrap_FXDirDialog_raiseWindow), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "lower", VALUEFUNC(_wrap_FXDirDialog_lower), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "move", VALUEFUNC(_wrap_FXDirDialog_move), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "position", VALUEFUNC(_wrap_FXDirDialog_position), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "layout", VALUEFUNC(_wrap_FXDirDialog_layout), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "recalc", VALUEFUNC(_wrap_FXDirDialog_recalc), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "reparent", VALUEFUNC(_wrap_FXDirDialog_reparent), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "hide", VALUEFUNC(_wrap_FXDirDialog_hide), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "isComposite", VALUEFUNC(_wrap_FXDirDialog_isComposite), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "contains", VALUEFUNC(_wrap_FXDirDialog_contains), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXDirDialog_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "setBackColor", VALUEFUNC(_wrap_FXDirDialog_setBackColor), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "tr", VALUEFUNC(_wrap_FXDirDialog_tr), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "dropEnable", VALUEFUNC(_wrap_FXDirDialog_dropEnable), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "dropDisable", VALUEFUNC(_wrap_FXDirDialog_dropDisable), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "setShape", VALUEFUNC(_wrap_FXDirDialog_setShape), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "clearShape", VALUEFUNC(_wrap_FXDirDialog_clearShape), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "show", VALUEFUNC(_wrap_FXDirDialog_show), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "maximize", VALUEFUNC(_wrap_FXDirDialog_maximize), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "minimize", VALUEFUNC(_wrap_FXDirDialog_minimize), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "restore", VALUEFUNC(_wrap_FXDirDialog_restore), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "close", VALUEFUNC(_wrap_FXDirDialog_close), -1);
+  rb_define_method(SwigClassFXDirDialog.klass, "execute", VALUEFUNC(_wrap_FXDirDialog_execute), -1);
+  SwigClassFXDirDialog.mark = (void (*)(void *)) FXRbDirDialog::markfunc;
+  SwigClassFXDirDialog.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXDirDialog.trackObjects = 0;
+  
+  SwigClassFXFileDialog.klass = rb_define_class_under(mFox, "FXFileDialog", ((swig_class *) SWIGTYPE_p_FXDialogBox->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXFileDialog, (void *) &SwigClassFXFileDialog);
+  rb_define_alloc_func(SwigClassFXFileDialog.klass, _wrap_FXFileDialog_allocate);
+  rb_define_method(SwigClassFXFileDialog.klass, "initialize", VALUEFUNC(_wrap_new_FXFileDialog), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "setFilename", VALUEFUNC(_wrap_FXFileDialog_setFilename), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "getFilename", VALUEFUNC(_wrap_FXFileDialog_getFilename), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "getFilenames", VALUEFUNC(_wrap_FXFileDialog_getFilenames), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "setPattern", VALUEFUNC(_wrap_FXFileDialog_setPattern), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "getPattern", VALUEFUNC(_wrap_FXFileDialog_getPattern), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "setPatternList", VALUEFUNC(_wrap_FXFileDialog_setPatternList), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "getPatternList", VALUEFUNC(_wrap_FXFileDialog_getPatternList), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "setCurrentPattern", VALUEFUNC(_wrap_FXFileDialog_setCurrentPattern), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "getCurrentPattern", VALUEFUNC(_wrap_FXFileDialog_getCurrentPattern), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "getPatternText", VALUEFUNC(_wrap_FXFileDialog_getPatternText), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "setPatternText", VALUEFUNC(_wrap_FXFileDialog_setPatternText), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "numPatterns", VALUEFUNC(_wrap_FXFileDialog_numPatterns), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "setAllowPatternEntry", VALUEFUNC(_wrap_FXFileDialog_setAllowPatternEntry), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "getAllowPatternEntry", VALUEFUNC(_wrap_FXFileDialog_getAllowPatternEntry), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "setDirectory", VALUEFUNC(_wrap_FXFileDialog_setDirectory), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "getDirectory", VALUEFUNC(_wrap_FXFileDialog_getDirectory), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "setItemSpace", VALUEFUNC(_wrap_FXFileDialog_setItemSpace), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "getItemSpace", VALUEFUNC(_wrap_FXFileDialog_getItemSpace), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "setSelectMode", VALUEFUNC(_wrap_FXFileDialog_setSelectMode), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "getSelectMode", VALUEFUNC(_wrap_FXFileDialog_getSelectMode), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "setMatchMode", VALUEFUNC(_wrap_FXFileDialog_setMatchMode), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "getMatchMode", VALUEFUNC(_wrap_FXFileDialog_getMatchMode), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "getShowHiddenFiles", VALUEFUNC(_wrap_FXFileDialog_getShowHiddenFiles), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "setShowHiddenFiles", VALUEFUNC(_wrap_FXFileDialog_setShowHiddenFiles), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "getShowImages", VALUEFUNC(_wrap_FXFileDialog_getShowImages), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "setShowImages", VALUEFUNC(_wrap_FXFileDialog_setShowImages), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "getImageSize", VALUEFUNC(_wrap_FXFileDialog_getImageSize), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "setImageSize", VALUEFUNC(_wrap_FXFileDialog_setImageSize), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "showReadOnly", VALUEFUNC(_wrap_FXFileDialog_showReadOnly), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "shownReadOnly", VALUEFUNC(_wrap_FXFileDialog_shownReadOnly), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "setReadOnly", VALUEFUNC(_wrap_FXFileDialog_setReadOnly), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "getReadOnly", VALUEFUNC(_wrap_FXFileDialog_getReadOnly), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "setFileBoxStyle", VALUEFUNC(_wrap_FXFileDialog_setFileBoxStyle), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "getFileBoxStyle", VALUEFUNC(_wrap_FXFileDialog_getFileBoxStyle), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "navigationAllowed=", VALUEFUNC(_wrap_FXFileDialog_navigationAllowede___), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "navigationAllowed?", VALUEFUNC(_wrap_FXFileDialog_navigationAllowedq___), -1);
+  rb_define_singleton_method(SwigClassFXFileDialog.klass, "getOpenFilename", VALUEFUNC(_wrap_FXFileDialog_getOpenFilename), -1);
+  rb_define_singleton_method(SwigClassFXFileDialog.klass, "getOpenFilenames", VALUEFUNC(_wrap_FXFileDialog_getOpenFilenames), -1);
+  rb_define_singleton_method(SwigClassFXFileDialog.klass, "getSaveFilename", VALUEFUNC(_wrap_FXFileDialog_getSaveFilename), -1);
+  rb_define_singleton_method(SwigClassFXFileDialog.klass, "getOpenDirectory", VALUEFUNC(_wrap_FXFileDialog_getOpenDirectory), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "save", VALUEFUNC(_wrap_FXFileDialog_save), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "load", VALUEFUNC(_wrap_FXFileDialog_load), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "create", VALUEFUNC(_wrap_FXFileDialog_create), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "detach", VALUEFUNC(_wrap_FXFileDialog_detach), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "destroy", VALUEFUNC(_wrap_FXFileDialog_destroy), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "resize", VALUEFUNC(_wrap_FXFileDialog_resize), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXFileDialog_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXFileDialog_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXFileDialog_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXFileDialog_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "canFocus", VALUEFUNC(_wrap_FXFileDialog_canFocus), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "setFocus", VALUEFUNC(_wrap_FXFileDialog_setFocus), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "killFocus", VALUEFUNC(_wrap_FXFileDialog_killFocus), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "changeFocus", VALUEFUNC(_wrap_FXFileDialog_changeFocus), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "setDefault", VALUEFUNC(_wrap_FXFileDialog_setDefault), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "enable", VALUEFUNC(_wrap_FXFileDialog_enable), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "disable", VALUEFUNC(_wrap_FXFileDialog_disable), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "raiseWindow", VALUEFUNC(_wrap_FXFileDialog_raiseWindow), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "lower", VALUEFUNC(_wrap_FXFileDialog_lower), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "move", VALUEFUNC(_wrap_FXFileDialog_move), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "position", VALUEFUNC(_wrap_FXFileDialog_position), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "layout", VALUEFUNC(_wrap_FXFileDialog_layout), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "recalc", VALUEFUNC(_wrap_FXFileDialog_recalc), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "reparent", VALUEFUNC(_wrap_FXFileDialog_reparent), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "hide", VALUEFUNC(_wrap_FXFileDialog_hide), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "isComposite", VALUEFUNC(_wrap_FXFileDialog_isComposite), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "contains", VALUEFUNC(_wrap_FXFileDialog_contains), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXFileDialog_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "setBackColor", VALUEFUNC(_wrap_FXFileDialog_setBackColor), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "tr", VALUEFUNC(_wrap_FXFileDialog_tr), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "dropEnable", VALUEFUNC(_wrap_FXFileDialog_dropEnable), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "dropDisable", VALUEFUNC(_wrap_FXFileDialog_dropDisable), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "setShape", VALUEFUNC(_wrap_FXFileDialog_setShape), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "clearShape", VALUEFUNC(_wrap_FXFileDialog_clearShape), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "show", VALUEFUNC(_wrap_FXFileDialog_show), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "maximize", VALUEFUNC(_wrap_FXFileDialog_maximize), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "minimize", VALUEFUNC(_wrap_FXFileDialog_minimize), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "restore", VALUEFUNC(_wrap_FXFileDialog_restore), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "close", VALUEFUNC(_wrap_FXFileDialog_close), -1);
+  rb_define_method(SwigClassFXFileDialog.klass, "execute", VALUEFUNC(_wrap_FXFileDialog_execute), -1);
+  SwigClassFXFileDialog.mark = (void (*)(void *)) FXRbFileDialog::markfunc;
+  SwigClassFXFileDialog.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXFileDialog.trackObjects = 0;
+  
+  SwigClassFXColorDialog.klass = rb_define_class_under(mFox, "FXColorDialog", ((swig_class *) SWIGTYPE_p_FXDialogBox->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXColorDialog, (void *) &SwigClassFXColorDialog);
+  rb_define_alloc_func(SwigClassFXColorDialog.klass, _wrap_FXColorDialog_allocate);
+  rb_define_method(SwigClassFXColorDialog.klass, "initialize", VALUEFUNC(_wrap_new_FXColorDialog), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "onChgColor", VALUEFUNC(_wrap_FXColorDialog_onChgColor), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "onCmdColor", VALUEFUNC(_wrap_FXColorDialog_onCmdColor), -1);
+  rb_define_const(SwigClassFXColorDialog.klass, "ID_COLORSELECTOR", SWIG_From_int(static_cast< int >(FXColorDialog::ID_COLORSELECTOR)));
+  rb_define_const(SwigClassFXColorDialog.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXColorDialog::ID_LAST)));
+  rb_define_method(SwigClassFXColorDialog.klass, "setRGBA", VALUEFUNC(_wrap_FXColorDialog_setRGBA), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "getRGBA", VALUEFUNC(_wrap_FXColorDialog_getRGBA), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "isOpaqueOnly", VALUEFUNC(_wrap_FXColorDialog_isOpaqueOnly), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "setOpaqueOnly", VALUEFUNC(_wrap_FXColorDialog_setOpaqueOnly), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "save", VALUEFUNC(_wrap_FXColorDialog_save), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "load", VALUEFUNC(_wrap_FXColorDialog_load), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "create", VALUEFUNC(_wrap_FXColorDialog_create), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "detach", VALUEFUNC(_wrap_FXColorDialog_detach), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "destroy", VALUEFUNC(_wrap_FXColorDialog_destroy), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "resize", VALUEFUNC(_wrap_FXColorDialog_resize), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXColorDialog_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXColorDialog_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXColorDialog_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXColorDialog_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "canFocus", VALUEFUNC(_wrap_FXColorDialog_canFocus), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "setFocus", VALUEFUNC(_wrap_FXColorDialog_setFocus), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "killFocus", VALUEFUNC(_wrap_FXColorDialog_killFocus), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "changeFocus", VALUEFUNC(_wrap_FXColorDialog_changeFocus), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "setDefault", VALUEFUNC(_wrap_FXColorDialog_setDefault), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "enable", VALUEFUNC(_wrap_FXColorDialog_enable), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "disable", VALUEFUNC(_wrap_FXColorDialog_disable), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "raiseWindow", VALUEFUNC(_wrap_FXColorDialog_raiseWindow), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "lower", VALUEFUNC(_wrap_FXColorDialog_lower), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "move", VALUEFUNC(_wrap_FXColorDialog_move), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "position", VALUEFUNC(_wrap_FXColorDialog_position), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "layout", VALUEFUNC(_wrap_FXColorDialog_layout), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "recalc", VALUEFUNC(_wrap_FXColorDialog_recalc), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "reparent", VALUEFUNC(_wrap_FXColorDialog_reparent), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "hide", VALUEFUNC(_wrap_FXColorDialog_hide), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "isComposite", VALUEFUNC(_wrap_FXColorDialog_isComposite), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "contains", VALUEFUNC(_wrap_FXColorDialog_contains), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXColorDialog_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "setBackColor", VALUEFUNC(_wrap_FXColorDialog_setBackColor), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "tr", VALUEFUNC(_wrap_FXColorDialog_tr), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "dropEnable", VALUEFUNC(_wrap_FXColorDialog_dropEnable), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "dropDisable", VALUEFUNC(_wrap_FXColorDialog_dropDisable), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "setShape", VALUEFUNC(_wrap_FXColorDialog_setShape), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "clearShape", VALUEFUNC(_wrap_FXColorDialog_clearShape), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "show", VALUEFUNC(_wrap_FXColorDialog_show), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "maximize", VALUEFUNC(_wrap_FXColorDialog_maximize), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "minimize", VALUEFUNC(_wrap_FXColorDialog_minimize), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "restore", VALUEFUNC(_wrap_FXColorDialog_restore), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "close", VALUEFUNC(_wrap_FXColorDialog_close), -1);
+  rb_define_method(SwigClassFXColorDialog.klass, "execute", VALUEFUNC(_wrap_FXColorDialog_execute), -1);
+  SwigClassFXColorDialog.mark = (void (*)(void *)) FXRbColorDialog::markfunc;
+  SwigClassFXColorDialog.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXColorDialog.trackObjects = 0;
+  
+  SwigClassFXFontDialog.klass = rb_define_class_under(mFox, "FXFontDialog", ((swig_class *) SWIGTYPE_p_FXDialogBox->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXFontDialog, (void *) &SwigClassFXFontDialog);
+  rb_define_alloc_func(SwigClassFXFontDialog.klass, _wrap_FXFontDialog_allocate);
+  rb_define_method(SwigClassFXFontDialog.klass, "initialize", VALUEFUNC(_wrap_new_FXFontDialog), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "setFontSelection", VALUEFUNC(_wrap_FXFontDialog_setFontSelection), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "getFontSelection", VALUEFUNC(_wrap_FXFontDialog_getFontSelection), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "save", VALUEFUNC(_wrap_FXFontDialog_save), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "load", VALUEFUNC(_wrap_FXFontDialog_load), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "create", VALUEFUNC(_wrap_FXFontDialog_create), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "detach", VALUEFUNC(_wrap_FXFontDialog_detach), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "destroy", VALUEFUNC(_wrap_FXFontDialog_destroy), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "resize", VALUEFUNC(_wrap_FXFontDialog_resize), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXFontDialog_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXFontDialog_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXFontDialog_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXFontDialog_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "canFocus", VALUEFUNC(_wrap_FXFontDialog_canFocus), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "setFocus", VALUEFUNC(_wrap_FXFontDialog_setFocus), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "killFocus", VALUEFUNC(_wrap_FXFontDialog_killFocus), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "changeFocus", VALUEFUNC(_wrap_FXFontDialog_changeFocus), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "setDefault", VALUEFUNC(_wrap_FXFontDialog_setDefault), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "enable", VALUEFUNC(_wrap_FXFontDialog_enable), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "disable", VALUEFUNC(_wrap_FXFontDialog_disable), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "raiseWindow", VALUEFUNC(_wrap_FXFontDialog_raiseWindow), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "lower", VALUEFUNC(_wrap_FXFontDialog_lower), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "move", VALUEFUNC(_wrap_FXFontDialog_move), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "position", VALUEFUNC(_wrap_FXFontDialog_position), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "layout", VALUEFUNC(_wrap_FXFontDialog_layout), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "recalc", VALUEFUNC(_wrap_FXFontDialog_recalc), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "reparent", VALUEFUNC(_wrap_FXFontDialog_reparent), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "hide", VALUEFUNC(_wrap_FXFontDialog_hide), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "isComposite", VALUEFUNC(_wrap_FXFontDialog_isComposite), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "contains", VALUEFUNC(_wrap_FXFontDialog_contains), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXFontDialog_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "setBackColor", VALUEFUNC(_wrap_FXFontDialog_setBackColor), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "tr", VALUEFUNC(_wrap_FXFontDialog_tr), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "dropEnable", VALUEFUNC(_wrap_FXFontDialog_dropEnable), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "dropDisable", VALUEFUNC(_wrap_FXFontDialog_dropDisable), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "setShape", VALUEFUNC(_wrap_FXFontDialog_setShape), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "clearShape", VALUEFUNC(_wrap_FXFontDialog_clearShape), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "show", VALUEFUNC(_wrap_FXFontDialog_show), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "maximize", VALUEFUNC(_wrap_FXFontDialog_maximize), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "minimize", VALUEFUNC(_wrap_FXFontDialog_minimize), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "restore", VALUEFUNC(_wrap_FXFontDialog_restore), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "close", VALUEFUNC(_wrap_FXFontDialog_close), -1);
+  rb_define_method(SwigClassFXFontDialog.klass, "execute", VALUEFUNC(_wrap_FXFontDialog_execute), -1);
+  SwigClassFXFontDialog.mark = (void (*)(void *)) FXRbFontDialog::markfunc;
+  SwigClassFXFontDialog.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXFontDialog.trackObjects = 0;
+  
+  SwigClassFXReplaceDialog.klass = rb_define_class_under(mFox, "FXReplaceDialog", ((swig_class *) SWIGTYPE_p_FXDialogBox->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXReplaceDialog, (void *) &SwigClassFXReplaceDialog);
+  rb_define_alloc_func(SwigClassFXReplaceDialog.klass, _wrap_FXReplaceDialog_allocate);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "initialize", VALUEFUNC(_wrap_new_FXReplaceDialog), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "onCmdAll", VALUEFUNC(_wrap_FXReplaceDialog_onCmdAll), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "onCmdNext", VALUEFUNC(_wrap_FXReplaceDialog_onCmdNext), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "onUpdDir", VALUEFUNC(_wrap_FXReplaceDialog_onUpdDir), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "onCmdDir", VALUEFUNC(_wrap_FXReplaceDialog_onCmdDir), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "onUpdMode", VALUEFUNC(_wrap_FXReplaceDialog_onUpdMode), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "onCmdMode", VALUEFUNC(_wrap_FXReplaceDialog_onCmdMode), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "onSearchKey", VALUEFUNC(_wrap_FXReplaceDialog_onSearchKey), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "onReplaceKey", VALUEFUNC(_wrap_FXReplaceDialog_onReplaceKey), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "onCmdSearchHist", VALUEFUNC(_wrap_FXReplaceDialog_onCmdSearchHist), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "onCmdReplaceHist", VALUEFUNC(_wrap_FXReplaceDialog_onCmdReplaceHist), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "onCmdAccept", VALUEFUNC(_wrap_FXReplaceDialog_onCmdAccept), -1);
+  rb_define_const(SwigClassFXReplaceDialog.klass, "ID_NEXT", SWIG_From_int(static_cast< int >(FXReplaceDialog::ID_NEXT)));
+  rb_define_const(SwigClassFXReplaceDialog.klass, "ID_PREV", SWIG_From_int(static_cast< int >(FXReplaceDialog::ID_PREV)));
+  rb_define_const(SwigClassFXReplaceDialog.klass, "ID_SEARCH_UP", SWIG_From_int(static_cast< int >(FXReplaceDialog::ID_SEARCH_UP)));
+  rb_define_const(SwigClassFXReplaceDialog.klass, "ID_SEARCH_DN", SWIG_From_int(static_cast< int >(FXReplaceDialog::ID_SEARCH_DN)));
+  rb_define_const(SwigClassFXReplaceDialog.klass, "ID_REPLACE_UP", SWIG_From_int(static_cast< int >(FXReplaceDialog::ID_REPLACE_UP)));
+  rb_define_const(SwigClassFXReplaceDialog.klass, "ID_REPLACE_DN", SWIG_From_int(static_cast< int >(FXReplaceDialog::ID_REPLACE_DN)));
+  rb_define_const(SwigClassFXReplaceDialog.klass, "ID_ALL", SWIG_From_int(static_cast< int >(FXReplaceDialog::ID_ALL)));
+  rb_define_const(SwigClassFXReplaceDialog.klass, "ID_DIR", SWIG_From_int(static_cast< int >(FXReplaceDialog::ID_DIR)));
+  rb_define_const(SwigClassFXReplaceDialog.klass, "ID_SEARCH_TEXT", SWIG_From_int(static_cast< int >(FXReplaceDialog::ID_SEARCH_TEXT)));
+  rb_define_const(SwigClassFXReplaceDialog.klass, "ID_REPLACE_TEXT", SWIG_From_int(static_cast< int >(FXReplaceDialog::ID_REPLACE_TEXT)));
+  rb_define_const(SwigClassFXReplaceDialog.klass, "ID_MODE", SWIG_From_int(static_cast< int >(FXReplaceDialog::ID_MODE)));
+  rb_define_const(SwigClassFXReplaceDialog.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXReplaceDialog::ID_LAST)));
+  rb_define_const(SwigClassFXReplaceDialog.klass, "DONE", SWIG_From_int(static_cast< int >(FXReplaceDialog::DONE)));
+  rb_define_const(SwigClassFXReplaceDialog.klass, "SEARCH", SWIG_From_int(static_cast< int >(FXReplaceDialog::SEARCH)));
+  rb_define_const(SwigClassFXReplaceDialog.klass, "REPLACE", SWIG_From_int(static_cast< int >(FXReplaceDialog::REPLACE)));
+  rb_define_const(SwigClassFXReplaceDialog.klass, "SEARCH_NEXT", SWIG_From_int(static_cast< int >(FXReplaceDialog::SEARCH_NEXT)));
+  rb_define_const(SwigClassFXReplaceDialog.klass, "REPLACE_NEXT", SWIG_From_int(static_cast< int >(FXReplaceDialog::REPLACE_NEXT)));
+  rb_define_const(SwigClassFXReplaceDialog.klass, "REPLACE_ALL", SWIG_From_int(static_cast< int >(FXReplaceDialog::REPLACE_ALL)));
+  rb_define_method(SwigClassFXReplaceDialog.klass, "setSearchText", VALUEFUNC(_wrap_FXReplaceDialog_setSearchText), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "getSearchText", VALUEFUNC(_wrap_FXReplaceDialog_getSearchText), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "setReplaceText", VALUEFUNC(_wrap_FXReplaceDialog_setReplaceText), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "getReplaceText", VALUEFUNC(_wrap_FXReplaceDialog_getReplaceText), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "setSearchMode", VALUEFUNC(_wrap_FXReplaceDialog_setSearchMode), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "getSearchMode", VALUEFUNC(_wrap_FXReplaceDialog_getSearchMode), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "save", VALUEFUNC(_wrap_FXReplaceDialog_save), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "load", VALUEFUNC(_wrap_FXReplaceDialog_load), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "create", VALUEFUNC(_wrap_FXReplaceDialog_create), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "detach", VALUEFUNC(_wrap_FXReplaceDialog_detach), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "destroy", VALUEFUNC(_wrap_FXReplaceDialog_destroy), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "resize", VALUEFUNC(_wrap_FXReplaceDialog_resize), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXReplaceDialog_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXReplaceDialog_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXReplaceDialog_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXReplaceDialog_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "canFocus", VALUEFUNC(_wrap_FXReplaceDialog_canFocus), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "setFocus", VALUEFUNC(_wrap_FXReplaceDialog_setFocus), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "killFocus", VALUEFUNC(_wrap_FXReplaceDialog_killFocus), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "changeFocus", VALUEFUNC(_wrap_FXReplaceDialog_changeFocus), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "setDefault", VALUEFUNC(_wrap_FXReplaceDialog_setDefault), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "enable", VALUEFUNC(_wrap_FXReplaceDialog_enable), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "disable", VALUEFUNC(_wrap_FXReplaceDialog_disable), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "raiseWindow", VALUEFUNC(_wrap_FXReplaceDialog_raiseWindow), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "lower", VALUEFUNC(_wrap_FXReplaceDialog_lower), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "move", VALUEFUNC(_wrap_FXReplaceDialog_move), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "position", VALUEFUNC(_wrap_FXReplaceDialog_position), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "layout", VALUEFUNC(_wrap_FXReplaceDialog_layout), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "recalc", VALUEFUNC(_wrap_FXReplaceDialog_recalc), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "reparent", VALUEFUNC(_wrap_FXReplaceDialog_reparent), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "hide", VALUEFUNC(_wrap_FXReplaceDialog_hide), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "isComposite", VALUEFUNC(_wrap_FXReplaceDialog_isComposite), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "contains", VALUEFUNC(_wrap_FXReplaceDialog_contains), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXReplaceDialog_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "setBackColor", VALUEFUNC(_wrap_FXReplaceDialog_setBackColor), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "tr", VALUEFUNC(_wrap_FXReplaceDialog_tr), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "dropEnable", VALUEFUNC(_wrap_FXReplaceDialog_dropEnable), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "dropDisable", VALUEFUNC(_wrap_FXReplaceDialog_dropDisable), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "setShape", VALUEFUNC(_wrap_FXReplaceDialog_setShape), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "clearShape", VALUEFUNC(_wrap_FXReplaceDialog_clearShape), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "show", VALUEFUNC(_wrap_FXReplaceDialog_show), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "maximize", VALUEFUNC(_wrap_FXReplaceDialog_maximize), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "minimize", VALUEFUNC(_wrap_FXReplaceDialog_minimize), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "restore", VALUEFUNC(_wrap_FXReplaceDialog_restore), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "close", VALUEFUNC(_wrap_FXReplaceDialog_close), -1);
+  rb_define_method(SwigClassFXReplaceDialog.klass, "execute", VALUEFUNC(_wrap_FXReplaceDialog_execute), -1);
+  SwigClassFXReplaceDialog.mark = (void (*)(void *)) FXRbReplaceDialog::markfunc;
+  SwigClassFXReplaceDialog.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXReplaceDialog.trackObjects = 0;
+  
+  SWIGTYPE_p_FXReplaceDialog->dcast = (swig_dycast_func) FXReplaceDialog_dynamic_cast;
+  
+  
+  SwigClassFXSearchDialog.klass = rb_define_class_under(mFox, "FXSearchDialog", ((swig_class *) SWIGTYPE_p_FXReplaceDialog->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXSearchDialog, (void *) &SwigClassFXSearchDialog);
+  rb_define_alloc_func(SwigClassFXSearchDialog.klass, _wrap_FXSearchDialog_allocate);
+  rb_define_method(SwigClassFXSearchDialog.klass, "initialize", VALUEFUNC(_wrap_new_FXSearchDialog), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "save", VALUEFUNC(_wrap_FXSearchDialog_save), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "load", VALUEFUNC(_wrap_FXSearchDialog_load), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "create", VALUEFUNC(_wrap_FXSearchDialog_create), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "detach", VALUEFUNC(_wrap_FXSearchDialog_detach), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "destroy", VALUEFUNC(_wrap_FXSearchDialog_destroy), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "resize", VALUEFUNC(_wrap_FXSearchDialog_resize), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXSearchDialog_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXSearchDialog_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXSearchDialog_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXSearchDialog_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "canFocus", VALUEFUNC(_wrap_FXSearchDialog_canFocus), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "setFocus", VALUEFUNC(_wrap_FXSearchDialog_setFocus), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "killFocus", VALUEFUNC(_wrap_FXSearchDialog_killFocus), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "changeFocus", VALUEFUNC(_wrap_FXSearchDialog_changeFocus), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "setDefault", VALUEFUNC(_wrap_FXSearchDialog_setDefault), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "enable", VALUEFUNC(_wrap_FXSearchDialog_enable), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "disable", VALUEFUNC(_wrap_FXSearchDialog_disable), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "raiseWindow", VALUEFUNC(_wrap_FXSearchDialog_raiseWindow), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "lower", VALUEFUNC(_wrap_FXSearchDialog_lower), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "move", VALUEFUNC(_wrap_FXSearchDialog_move), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "position", VALUEFUNC(_wrap_FXSearchDialog_position), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "layout", VALUEFUNC(_wrap_FXSearchDialog_layout), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "recalc", VALUEFUNC(_wrap_FXSearchDialog_recalc), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "reparent", VALUEFUNC(_wrap_FXSearchDialog_reparent), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "hide", VALUEFUNC(_wrap_FXSearchDialog_hide), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "isComposite", VALUEFUNC(_wrap_FXSearchDialog_isComposite), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "contains", VALUEFUNC(_wrap_FXSearchDialog_contains), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXSearchDialog_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "setBackColor", VALUEFUNC(_wrap_FXSearchDialog_setBackColor), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "tr", VALUEFUNC(_wrap_FXSearchDialog_tr), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "dropEnable", VALUEFUNC(_wrap_FXSearchDialog_dropEnable), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "dropDisable", VALUEFUNC(_wrap_FXSearchDialog_dropDisable), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "setShape", VALUEFUNC(_wrap_FXSearchDialog_setShape), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "clearShape", VALUEFUNC(_wrap_FXSearchDialog_clearShape), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "show", VALUEFUNC(_wrap_FXSearchDialog_show), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "maximize", VALUEFUNC(_wrap_FXSearchDialog_maximize), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "minimize", VALUEFUNC(_wrap_FXSearchDialog_minimize), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "restore", VALUEFUNC(_wrap_FXSearchDialog_restore), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "close", VALUEFUNC(_wrap_FXSearchDialog_close), -1);
+  rb_define_method(SwigClassFXSearchDialog.klass, "execute", VALUEFUNC(_wrap_FXSearchDialog_execute), -1);
+  SwigClassFXSearchDialog.mark = (void (*)(void *)) FXRbSearchDialog::markfunc;
+  SwigClassFXSearchDialog.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXSearchDialog.trackObjects = 0;
+  rb_define_const(mFox, "INPUTDIALOG_STRING", SWIG_From_int(static_cast< int >(INPUTDIALOG_STRING)));
+  rb_define_const(mFox, "INPUTDIALOG_INTEGER", SWIG_From_int(static_cast< int >(INPUTDIALOG_INTEGER)));
+  rb_define_const(mFox, "INPUTDIALOG_REAL", SWIG_From_int(static_cast< int >(INPUTDIALOG_REAL)));
+  rb_define_const(mFox, "INPUTDIALOG_PASSWORD", SWIG_From_int(static_cast< int >(INPUTDIALOG_PASSWORD)));
+  
+  SwigClassFXInputDialog.klass = rb_define_class_under(mFox, "FXInputDialog", ((swig_class *) SWIGTYPE_p_FXDialogBox->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXInputDialog, (void *) &SwigClassFXInputDialog);
+  rb_define_alloc_func(SwigClassFXInputDialog.klass, _wrap_FXInputDialog_allocate);
+  rb_define_method(SwigClassFXInputDialog.klass, "initialize", VALUEFUNC(_wrap_new_FXInputDialog), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "onCmdAccept", VALUEFUNC(_wrap_FXInputDialog_onCmdAccept), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "getText", VALUEFUNC(_wrap_FXInputDialog_getText), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "setText", VALUEFUNC(_wrap_FXInputDialog_setText), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "setNumColumns", VALUEFUNC(_wrap_FXInputDialog_setNumColumns), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "getNumColumns", VALUEFUNC(_wrap_FXInputDialog_getNumColumns), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "setLimits", VALUEFUNC(_wrap_FXInputDialog_setLimits), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "getLimits", VALUEFUNC(_wrap_FXInputDialog_getLimits), -1);
+  rb_define_singleton_method(SwigClassFXInputDialog.klass, "getString", VALUEFUNC(_wrap_FXInputDialog_getString), -1);
+  rb_define_singleton_method(SwigClassFXInputDialog.klass, "getInteger", VALUEFUNC(_wrap_FXInputDialog_getInteger), -1);
+  rb_define_singleton_method(SwigClassFXInputDialog.klass, "getReal", VALUEFUNC(_wrap_FXInputDialog_getReal), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "save", VALUEFUNC(_wrap_FXInputDialog_save), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "load", VALUEFUNC(_wrap_FXInputDialog_load), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "create", VALUEFUNC(_wrap_FXInputDialog_create), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "detach", VALUEFUNC(_wrap_FXInputDialog_detach), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "destroy", VALUEFUNC(_wrap_FXInputDialog_destroy), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "resize", VALUEFUNC(_wrap_FXInputDialog_resize), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXInputDialog_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXInputDialog_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXInputDialog_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXInputDialog_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "canFocus", VALUEFUNC(_wrap_FXInputDialog_canFocus), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "setFocus", VALUEFUNC(_wrap_FXInputDialog_setFocus), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "killFocus", VALUEFUNC(_wrap_FXInputDialog_killFocus), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "changeFocus", VALUEFUNC(_wrap_FXInputDialog_changeFocus), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "setDefault", VALUEFUNC(_wrap_FXInputDialog_setDefault), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "enable", VALUEFUNC(_wrap_FXInputDialog_enable), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "disable", VALUEFUNC(_wrap_FXInputDialog_disable), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "raiseWindow", VALUEFUNC(_wrap_FXInputDialog_raiseWindow), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "lower", VALUEFUNC(_wrap_FXInputDialog_lower), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "move", VALUEFUNC(_wrap_FXInputDialog_move), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "position", VALUEFUNC(_wrap_FXInputDialog_position), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "layout", VALUEFUNC(_wrap_FXInputDialog_layout), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "recalc", VALUEFUNC(_wrap_FXInputDialog_recalc), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "reparent", VALUEFUNC(_wrap_FXInputDialog_reparent), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "hide", VALUEFUNC(_wrap_FXInputDialog_hide), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "isComposite", VALUEFUNC(_wrap_FXInputDialog_isComposite), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "contains", VALUEFUNC(_wrap_FXInputDialog_contains), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXInputDialog_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "setBackColor", VALUEFUNC(_wrap_FXInputDialog_setBackColor), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "tr", VALUEFUNC(_wrap_FXInputDialog_tr), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "dropEnable", VALUEFUNC(_wrap_FXInputDialog_dropEnable), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "dropDisable", VALUEFUNC(_wrap_FXInputDialog_dropDisable), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "setShape", VALUEFUNC(_wrap_FXInputDialog_setShape), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "clearShape", VALUEFUNC(_wrap_FXInputDialog_clearShape), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "show", VALUEFUNC(_wrap_FXInputDialog_show), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "maximize", VALUEFUNC(_wrap_FXInputDialog_maximize), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "minimize", VALUEFUNC(_wrap_FXInputDialog_minimize), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "restore", VALUEFUNC(_wrap_FXInputDialog_restore), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "close", VALUEFUNC(_wrap_FXInputDialog_close), -1);
+  rb_define_method(SwigClassFXInputDialog.klass, "execute", VALUEFUNC(_wrap_FXInputDialog_execute), -1);
+  SwigClassFXInputDialog.mark = (void (*)(void *)) FXRbInputDialog::markfunc;
+  SwigClassFXInputDialog.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXInputDialog.trackObjects = 0;
+  
+  SwigClassFXPrintDialog.klass = rb_define_class_under(mFox, "FXPrintDialog", ((swig_class *) SWIGTYPE_p_FXDialogBox->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXPrintDialog, (void *) &SwigClassFXPrintDialog);
+  rb_define_alloc_func(SwigClassFXPrintDialog.klass, _wrap_FXPrintDialog_allocate);
+  rb_define_method(SwigClassFXPrintDialog.klass, "initialize", VALUEFUNC(_wrap_new_FXPrintDialog), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onCmdToPrinter", VALUEFUNC(_wrap_FXPrintDialog_onCmdToPrinter), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onUpdToPrinter", VALUEFUNC(_wrap_FXPrintDialog_onUpdToPrinter), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onCmdToFile", VALUEFUNC(_wrap_FXPrintDialog_onCmdToFile), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onUpdToFile", VALUEFUNC(_wrap_FXPrintDialog_onUpdToFile), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onCmdBrowse", VALUEFUNC(_wrap_FXPrintDialog_onCmdBrowse), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onUpdBrowse", VALUEFUNC(_wrap_FXPrintDialog_onUpdBrowse), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onCmdProps", VALUEFUNC(_wrap_FXPrintDialog_onCmdProps), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onUpdProps", VALUEFUNC(_wrap_FXPrintDialog_onUpdProps), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onCmdPortrait", VALUEFUNC(_wrap_FXPrintDialog_onCmdPortrait), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onUpdPortrait", VALUEFUNC(_wrap_FXPrintDialog_onUpdPortrait), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onCmdLandscape", VALUEFUNC(_wrap_FXPrintDialog_onCmdLandscape), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onUpdLandscape", VALUEFUNC(_wrap_FXPrintDialog_onUpdLandscape), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onCmdPages", VALUEFUNC(_wrap_FXPrintDialog_onCmdPages), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onUpdPages", VALUEFUNC(_wrap_FXPrintDialog_onUpdPages), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onCmdColor", VALUEFUNC(_wrap_FXPrintDialog_onCmdColor), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onUpdColor", VALUEFUNC(_wrap_FXPrintDialog_onUpdColor), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onCmdGray", VALUEFUNC(_wrap_FXPrintDialog_onCmdGray), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onUpdGray", VALUEFUNC(_wrap_FXPrintDialog_onUpdGray), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onCmdNumCopies", VALUEFUNC(_wrap_FXPrintDialog_onCmdNumCopies), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onUpdNumCopies", VALUEFUNC(_wrap_FXPrintDialog_onUpdNumCopies), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onCmdFirstPage", VALUEFUNC(_wrap_FXPrintDialog_onCmdFirstPage), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onUpdFirstPage", VALUEFUNC(_wrap_FXPrintDialog_onUpdFirstPage), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onCmdLastPage", VALUEFUNC(_wrap_FXPrintDialog_onCmdLastPage), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onUpdLastPage", VALUEFUNC(_wrap_FXPrintDialog_onUpdLastPage), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onCmdCollateNormal", VALUEFUNC(_wrap_FXPrintDialog_onCmdCollateNormal), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onUpdCollateNormal", VALUEFUNC(_wrap_FXPrintDialog_onUpdCollateNormal), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onCmdCollateReversed", VALUEFUNC(_wrap_FXPrintDialog_onCmdCollateReversed), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onUpdCollateReversed", VALUEFUNC(_wrap_FXPrintDialog_onUpdCollateReversed), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onCmdFileName", VALUEFUNC(_wrap_FXPrintDialog_onCmdFileName), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onUpdFileName", VALUEFUNC(_wrap_FXPrintDialog_onUpdFileName), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onCmdPrinterName", VALUEFUNC(_wrap_FXPrintDialog_onCmdPrinterName), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onUpdPrinterName", VALUEFUNC(_wrap_FXPrintDialog_onUpdPrinterName), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onCmdAccept", VALUEFUNC(_wrap_FXPrintDialog_onCmdAccept), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onCmdMedia", VALUEFUNC(_wrap_FXPrintDialog_onCmdMedia), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "onUpdMedia", VALUEFUNC(_wrap_FXPrintDialog_onUpdMedia), -1);
+  rb_define_const(SwigClassFXPrintDialog.klass, "ID_TO_PRINTER", SWIG_From_int(static_cast< int >(FXPrintDialog::ID_TO_PRINTER)));
+  rb_define_const(SwigClassFXPrintDialog.klass, "ID_TO_FILE", SWIG_From_int(static_cast< int >(FXPrintDialog::ID_TO_FILE)));
+  rb_define_const(SwigClassFXPrintDialog.klass, "ID_PRINTER_NAME", SWIG_From_int(static_cast< int >(FXPrintDialog::ID_PRINTER_NAME)));
+  rb_define_const(SwigClassFXPrintDialog.klass, "ID_FILE_NAME", SWIG_From_int(static_cast< int >(FXPrintDialog::ID_FILE_NAME)));
+  rb_define_const(SwigClassFXPrintDialog.klass, "ID_LANDSCAPE", SWIG_From_int(static_cast< int >(FXPrintDialog::ID_LANDSCAPE)));
+  rb_define_const(SwigClassFXPrintDialog.klass, "ID_PORTRAIT", SWIG_From_int(static_cast< int >(FXPrintDialog::ID_PORTRAIT)));
+  rb_define_const(SwigClassFXPrintDialog.klass, "ID_MEDIA", SWIG_From_int(static_cast< int >(FXPrintDialog::ID_MEDIA)));
+  rb_define_const(SwigClassFXPrintDialog.klass, "ID_COLLATE_NORMAL", SWIG_From_int(static_cast< int >(FXPrintDialog::ID_COLLATE_NORMAL)));
+  rb_define_const(SwigClassFXPrintDialog.klass, "ID_COLLATE_REVERSED", SWIG_From_int(static_cast< int >(FXPrintDialog::ID_COLLATE_REVERSED)));
+  rb_define_const(SwigClassFXPrintDialog.klass, "ID_PAGES_ALL", SWIG_From_int(static_cast< int >(FXPrintDialog::ID_PAGES_ALL)));
+  rb_define_const(SwigClassFXPrintDialog.klass, "ID_PAGES_EVEN", SWIG_From_int(static_cast< int >(FXPrintDialog::ID_PAGES_EVEN)));
+  rb_define_const(SwigClassFXPrintDialog.klass, "ID_PAGES_ODD", SWIG_From_int(static_cast< int >(FXPrintDialog::ID_PAGES_ODD)));
+  rb_define_const(SwigClassFXPrintDialog.klass, "ID_PAGES_RANGE", SWIG_From_int(static_cast< int >(FXPrintDialog::ID_PAGES_RANGE)));
+  rb_define_const(SwigClassFXPrintDialog.klass, "ID_PAGES_FIRST", SWIG_From_int(static_cast< int >(FXPrintDialog::ID_PAGES_FIRST)));
+  rb_define_const(SwigClassFXPrintDialog.klass, "ID_PAGES_LAST", SWIG_From_int(static_cast< int >(FXPrintDialog::ID_PAGES_LAST)));
+  rb_define_const(SwigClassFXPrintDialog.klass, "ID_BROWSE_FILE", SWIG_From_int(static_cast< int >(FXPrintDialog::ID_BROWSE_FILE)));
+  rb_define_const(SwigClassFXPrintDialog.klass, "ID_PROPERTIES", SWIG_From_int(static_cast< int >(FXPrintDialog::ID_PROPERTIES)));
+  rb_define_const(SwigClassFXPrintDialog.klass, "ID_COLOR_PRINTER", SWIG_From_int(static_cast< int >(FXPrintDialog::ID_COLOR_PRINTER)));
+  rb_define_const(SwigClassFXPrintDialog.klass, "ID_GRAY_PRINTER", SWIG_From_int(static_cast< int >(FXPrintDialog::ID_GRAY_PRINTER)));
+  rb_define_const(SwigClassFXPrintDialog.klass, "ID_NUM_COPIES", SWIG_From_int(static_cast< int >(FXPrintDialog::ID_NUM_COPIES)));
+  rb_define_method(SwigClassFXPrintDialog.klass, "setPrinter", VALUEFUNC(_wrap_FXPrintDialog_setPrinter), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "getPrinter", VALUEFUNC(_wrap_FXPrintDialog_getPrinter), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "save", VALUEFUNC(_wrap_FXPrintDialog_save), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "load", VALUEFUNC(_wrap_FXPrintDialog_load), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "create", VALUEFUNC(_wrap_FXPrintDialog_create), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "detach", VALUEFUNC(_wrap_FXPrintDialog_detach), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "destroy", VALUEFUNC(_wrap_FXPrintDialog_destroy), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "resize", VALUEFUNC(_wrap_FXPrintDialog_resize), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXPrintDialog_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXPrintDialog_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXPrintDialog_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXPrintDialog_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "canFocus", VALUEFUNC(_wrap_FXPrintDialog_canFocus), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "setFocus", VALUEFUNC(_wrap_FXPrintDialog_setFocus), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "killFocus", VALUEFUNC(_wrap_FXPrintDialog_killFocus), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "changeFocus", VALUEFUNC(_wrap_FXPrintDialog_changeFocus), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "setDefault", VALUEFUNC(_wrap_FXPrintDialog_setDefault), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "enable", VALUEFUNC(_wrap_FXPrintDialog_enable), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "disable", VALUEFUNC(_wrap_FXPrintDialog_disable), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "raiseWindow", VALUEFUNC(_wrap_FXPrintDialog_raiseWindow), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "lower", VALUEFUNC(_wrap_FXPrintDialog_lower), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "move", VALUEFUNC(_wrap_FXPrintDialog_move), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "position", VALUEFUNC(_wrap_FXPrintDialog_position), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "layout", VALUEFUNC(_wrap_FXPrintDialog_layout), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "recalc", VALUEFUNC(_wrap_FXPrintDialog_recalc), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "reparent", VALUEFUNC(_wrap_FXPrintDialog_reparent), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "hide", VALUEFUNC(_wrap_FXPrintDialog_hide), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "isComposite", VALUEFUNC(_wrap_FXPrintDialog_isComposite), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "contains", VALUEFUNC(_wrap_FXPrintDialog_contains), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXPrintDialog_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "setBackColor", VALUEFUNC(_wrap_FXPrintDialog_setBackColor), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "tr", VALUEFUNC(_wrap_FXPrintDialog_tr), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "dropEnable", VALUEFUNC(_wrap_FXPrintDialog_dropEnable), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "dropDisable", VALUEFUNC(_wrap_FXPrintDialog_dropDisable), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "setShape", VALUEFUNC(_wrap_FXPrintDialog_setShape), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "clearShape", VALUEFUNC(_wrap_FXPrintDialog_clearShape), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "show", VALUEFUNC(_wrap_FXPrintDialog_show), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "maximize", VALUEFUNC(_wrap_FXPrintDialog_maximize), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "minimize", VALUEFUNC(_wrap_FXPrintDialog_minimize), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "restore", VALUEFUNC(_wrap_FXPrintDialog_restore), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "close", VALUEFUNC(_wrap_FXPrintDialog_close), -1);
+  rb_define_method(SwigClassFXPrintDialog.klass, "execute", VALUEFUNC(_wrap_FXPrintDialog_execute), -1);
+  SwigClassFXPrintDialog.mark = (void (*)(void *)) FXRbPrintDialog::markfunc;
+  SwigClassFXPrintDialog.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXPrintDialog.trackObjects = 0;
+  rb_define_const(mFox, "PROGRESSDIALOG_NOCANCEL", SWIG_From_int(static_cast< int >(PROGRESSDIALOG_NOCANCEL)));
+  rb_define_const(mFox, "PROGRESSDIALOG_CANCEL", SWIG_From_int(static_cast< int >(PROGRESSDIALOG_CANCEL)));
+  rb_define_const(mFox, "PROGRESSDIALOG_NORMAL", SWIG_From_int(static_cast< int >(PROGRESSDIALOG_NORMAL)));
+  
+  SwigClassFXProgressDialog.klass = rb_define_class_under(mFox, "FXProgressDialog", ((swig_class *) SWIGTYPE_p_FXDialogBox->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXProgressDialog, (void *) &SwigClassFXProgressDialog);
+  rb_define_alloc_func(SwigClassFXProgressDialog.klass, _wrap_FXProgressDialog_allocate);
+  rb_define_method(SwigClassFXProgressDialog.klass, "initialize", VALUEFUNC(_wrap_new_FXProgressDialog), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXProgressDialog_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXProgressDialog_onCmdSetIntValue), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXProgressDialog_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "onCmdSetStringValue", VALUEFUNC(_wrap_FXProgressDialog_onCmdSetStringValue), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "onCmdGetStringValue", VALUEFUNC(_wrap_FXProgressDialog_onCmdGetStringValue), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "onCmdCancel", VALUEFUNC(_wrap_FXProgressDialog_onCmdCancel), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "setMessage", VALUEFUNC(_wrap_FXProgressDialog_setMessage), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "getMessage", VALUEFUNC(_wrap_FXProgressDialog_getMessage), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "setBarStyle", VALUEFUNC(_wrap_FXProgressDialog_setBarStyle), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "getBarStyle", VALUEFUNC(_wrap_FXProgressDialog_getBarStyle), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "setProgress", VALUEFUNC(_wrap_FXProgressDialog_setProgress), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "getProgress", VALUEFUNC(_wrap_FXProgressDialog_getProgress), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "setTotal", VALUEFUNC(_wrap_FXProgressDialog_setTotal), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "getTotal", VALUEFUNC(_wrap_FXProgressDialog_getTotal), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "increment", VALUEFUNC(_wrap_FXProgressDialog_increment), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "isCancelled", VALUEFUNC(_wrap_FXProgressDialog_isCancelled), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "setCancelled", VALUEFUNC(_wrap_FXProgressDialog_setCancelled), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "save", VALUEFUNC(_wrap_FXProgressDialog_save), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "load", VALUEFUNC(_wrap_FXProgressDialog_load), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "create", VALUEFUNC(_wrap_FXProgressDialog_create), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "detach", VALUEFUNC(_wrap_FXProgressDialog_detach), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "destroy", VALUEFUNC(_wrap_FXProgressDialog_destroy), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "resize", VALUEFUNC(_wrap_FXProgressDialog_resize), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXProgressDialog_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXProgressDialog_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXProgressDialog_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXProgressDialog_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "canFocus", VALUEFUNC(_wrap_FXProgressDialog_canFocus), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "setFocus", VALUEFUNC(_wrap_FXProgressDialog_setFocus), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "killFocus", VALUEFUNC(_wrap_FXProgressDialog_killFocus), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "changeFocus", VALUEFUNC(_wrap_FXProgressDialog_changeFocus), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "setDefault", VALUEFUNC(_wrap_FXProgressDialog_setDefault), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "enable", VALUEFUNC(_wrap_FXProgressDialog_enable), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "disable", VALUEFUNC(_wrap_FXProgressDialog_disable), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "raiseWindow", VALUEFUNC(_wrap_FXProgressDialog_raiseWindow), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "lower", VALUEFUNC(_wrap_FXProgressDialog_lower), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "move", VALUEFUNC(_wrap_FXProgressDialog_move), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "position", VALUEFUNC(_wrap_FXProgressDialog_position), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "layout", VALUEFUNC(_wrap_FXProgressDialog_layout), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "recalc", VALUEFUNC(_wrap_FXProgressDialog_recalc), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "reparent", VALUEFUNC(_wrap_FXProgressDialog_reparent), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "hide", VALUEFUNC(_wrap_FXProgressDialog_hide), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "isComposite", VALUEFUNC(_wrap_FXProgressDialog_isComposite), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "contains", VALUEFUNC(_wrap_FXProgressDialog_contains), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXProgressDialog_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "setBackColor", VALUEFUNC(_wrap_FXProgressDialog_setBackColor), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "tr", VALUEFUNC(_wrap_FXProgressDialog_tr), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "dropEnable", VALUEFUNC(_wrap_FXProgressDialog_dropEnable), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "dropDisable", VALUEFUNC(_wrap_FXProgressDialog_dropDisable), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "setShape", VALUEFUNC(_wrap_FXProgressDialog_setShape), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "clearShape", VALUEFUNC(_wrap_FXProgressDialog_clearShape), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "show", VALUEFUNC(_wrap_FXProgressDialog_show), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "maximize", VALUEFUNC(_wrap_FXProgressDialog_maximize), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "minimize", VALUEFUNC(_wrap_FXProgressDialog_minimize), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "restore", VALUEFUNC(_wrap_FXProgressDialog_restore), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "close", VALUEFUNC(_wrap_FXProgressDialog_close), -1);
+  rb_define_method(SwigClassFXProgressDialog.klass, "execute", VALUEFUNC(_wrap_FXProgressDialog_execute), -1);
+  SwigClassFXProgressDialog.mark = (void (*)(void *)) FXRbProgressDialog::markfunc;
+  SwigClassFXProgressDialog.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXProgressDialog.trackObjects = 0;
+  rb_define_const(mFox, "MBOX_OK", SWIG_From_int(static_cast< int >(MBOX_OK)));
+  rb_define_const(mFox, "MBOX_OK_CANCEL", SWIG_From_int(static_cast< int >(MBOX_OK_CANCEL)));
+  rb_define_const(mFox, "MBOX_YES_NO", SWIG_From_int(static_cast< int >(MBOX_YES_NO)));
+  rb_define_const(mFox, "MBOX_YES_NO_CANCEL", SWIG_From_int(static_cast< int >(MBOX_YES_NO_CANCEL)));
+  rb_define_const(mFox, "MBOX_QUIT_CANCEL", SWIG_From_int(static_cast< int >(MBOX_QUIT_CANCEL)));
+  rb_define_const(mFox, "MBOX_QUIT_SAVE_CANCEL", SWIG_From_int(static_cast< int >(MBOX_QUIT_SAVE_CANCEL)));
+  rb_define_const(mFox, "MBOX_SKIP_SKIPALL_CANCEL", SWIG_From_int(static_cast< int >(MBOX_SKIP_SKIPALL_CANCEL)));
+  rb_define_const(mFox, "MBOX_SAVE_CANCEL_DONTSAVE", SWIG_From_unsigned_SS_int(static_cast< unsigned int >(0x80000000)));
+  rb_define_const(mFox, "MBOX_CLICKED_YES", SWIG_From_int(static_cast< int >(MBOX_CLICKED_YES)));
+  rb_define_const(mFox, "MBOX_CLICKED_NO", SWIG_From_int(static_cast< int >(MBOX_CLICKED_NO)));
+  rb_define_const(mFox, "MBOX_CLICKED_OK", SWIG_From_int(static_cast< int >(MBOX_CLICKED_OK)));
+  rb_define_const(mFox, "MBOX_CLICKED_CANCEL", SWIG_From_int(static_cast< int >(MBOX_CLICKED_CANCEL)));
+  rb_define_const(mFox, "MBOX_CLICKED_QUIT", SWIG_From_int(static_cast< int >(MBOX_CLICKED_QUIT)));
+  rb_define_const(mFox, "MBOX_CLICKED_SAVE", SWIG_From_int(static_cast< int >(MBOX_CLICKED_SAVE)));
+  rb_define_const(mFox, "MBOX_CLICKED_SKIP", SWIG_From_int(static_cast< int >(MBOX_CLICKED_SKIP)));
+  rb_define_const(mFox, "MBOX_CLICKED_SKIPALL", SWIG_From_int(static_cast< int >(MBOX_CLICKED_SKIPALL)));
+  rb_define_const(mFox, "MBOX_CLICKED_DONTSAVE", SWIG_From_int(static_cast< int >(MBOX_CLICKED_NO)));
+  
+  SwigClassFXMessageBox.klass = rb_define_class_under(mFox, "FXMessageBox", ((swig_class *) SWIGTYPE_p_FXDialogBox->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMessageBox, (void *) &SwigClassFXMessageBox);
+  rb_define_alloc_func(SwigClassFXMessageBox.klass, _wrap_FXMessageBox_allocate);
+  rb_define_method(SwigClassFXMessageBox.klass, "initialize", VALUEFUNC(_wrap_new_FXMessageBox), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "onCmdClicked", VALUEFUNC(_wrap_FXMessageBox_onCmdClicked), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "onCmdCancel", VALUEFUNC(_wrap_FXMessageBox_onCmdCancel), -1);
+  rb_define_const(SwigClassFXMessageBox.klass, "ID_CLICKED_YES", SWIG_From_int(static_cast< int >(FXMessageBox::ID_CLICKED_YES)));
+  rb_define_const(SwigClassFXMessageBox.klass, "ID_CLICKED_NO", SWIG_From_int(static_cast< int >(FXMessageBox::ID_CLICKED_NO)));
+  rb_define_const(SwigClassFXMessageBox.klass, "ID_CLICKED_OK", SWIG_From_int(static_cast< int >(FXMessageBox::ID_CLICKED_OK)));
+  rb_define_const(SwigClassFXMessageBox.klass, "ID_CLICKED_CANCEL", SWIG_From_int(static_cast< int >(FXMessageBox::ID_CLICKED_CANCEL)));
+  rb_define_const(SwigClassFXMessageBox.klass, "ID_CLICKED_QUIT", SWIG_From_int(static_cast< int >(FXMessageBox::ID_CLICKED_QUIT)));
+  rb_define_const(SwigClassFXMessageBox.klass, "ID_CLICKED_SAVE", SWIG_From_int(static_cast< int >(FXMessageBox::ID_CLICKED_SAVE)));
+  rb_define_const(SwigClassFXMessageBox.klass, "ID_CLICKED_SKIP", SWIG_From_int(static_cast< int >(FXMessageBox::ID_CLICKED_SKIP)));
+  rb_define_const(SwigClassFXMessageBox.klass, "ID_CLICKED_SKIPALL", SWIG_From_int(static_cast< int >(FXMessageBox::ID_CLICKED_SKIPALL)));
+  rb_define_const(SwigClassFXMessageBox.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXMessageBox::ID_LAST)));
+  rb_define_singleton_method(SwigClassFXMessageBox.klass, "error", VALUEFUNC(_wrap_FXMessageBox_error), -1);
+  rb_define_singleton_method(SwigClassFXMessageBox.klass, "warning", VALUEFUNC(_wrap_FXMessageBox_warning), -1);
+  rb_define_singleton_method(SwigClassFXMessageBox.klass, "question", VALUEFUNC(_wrap_FXMessageBox_question), -1);
+  rb_define_singleton_method(SwigClassFXMessageBox.klass, "information", VALUEFUNC(_wrap_FXMessageBox_information), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "save", VALUEFUNC(_wrap_FXMessageBox_save), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "load", VALUEFUNC(_wrap_FXMessageBox_load), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "create", VALUEFUNC(_wrap_FXMessageBox_create), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "detach", VALUEFUNC(_wrap_FXMessageBox_detach), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "destroy", VALUEFUNC(_wrap_FXMessageBox_destroy), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "resize", VALUEFUNC(_wrap_FXMessageBox_resize), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXMessageBox_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXMessageBox_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXMessageBox_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXMessageBox_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "canFocus", VALUEFUNC(_wrap_FXMessageBox_canFocus), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "setFocus", VALUEFUNC(_wrap_FXMessageBox_setFocus), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "killFocus", VALUEFUNC(_wrap_FXMessageBox_killFocus), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "changeFocus", VALUEFUNC(_wrap_FXMessageBox_changeFocus), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "setDefault", VALUEFUNC(_wrap_FXMessageBox_setDefault), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "enable", VALUEFUNC(_wrap_FXMessageBox_enable), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "disable", VALUEFUNC(_wrap_FXMessageBox_disable), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "raiseWindow", VALUEFUNC(_wrap_FXMessageBox_raiseWindow), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "lower", VALUEFUNC(_wrap_FXMessageBox_lower), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "move", VALUEFUNC(_wrap_FXMessageBox_move), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "position", VALUEFUNC(_wrap_FXMessageBox_position), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "layout", VALUEFUNC(_wrap_FXMessageBox_layout), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "recalc", VALUEFUNC(_wrap_FXMessageBox_recalc), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "reparent", VALUEFUNC(_wrap_FXMessageBox_reparent), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "hide", VALUEFUNC(_wrap_FXMessageBox_hide), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "isComposite", VALUEFUNC(_wrap_FXMessageBox_isComposite), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "contains", VALUEFUNC(_wrap_FXMessageBox_contains), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXMessageBox_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "setBackColor", VALUEFUNC(_wrap_FXMessageBox_setBackColor), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "tr", VALUEFUNC(_wrap_FXMessageBox_tr), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "dropEnable", VALUEFUNC(_wrap_FXMessageBox_dropEnable), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "dropDisable", VALUEFUNC(_wrap_FXMessageBox_dropDisable), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "setShape", VALUEFUNC(_wrap_FXMessageBox_setShape), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "clearShape", VALUEFUNC(_wrap_FXMessageBox_clearShape), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "show", VALUEFUNC(_wrap_FXMessageBox_show), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "maximize", VALUEFUNC(_wrap_FXMessageBox_maximize), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "minimize", VALUEFUNC(_wrap_FXMessageBox_minimize), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "restore", VALUEFUNC(_wrap_FXMessageBox_restore), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "close", VALUEFUNC(_wrap_FXMessageBox_close), -1);
+  rb_define_method(SwigClassFXMessageBox.klass, "execute", VALUEFUNC(_wrap_FXMessageBox_execute), -1);
+  SwigClassFXMessageBox.mark = (void (*)(void *)) FXRbMessageBox::markfunc;
+  SwigClassFXMessageBox.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXMessageBox.trackObjects = 0;
+  
+  SwigClassFXWizard.klass = rb_define_class_under(mFox, "FXWizard", ((swig_class *) SWIGTYPE_p_FXDialogBox->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXWizard, (void *) &SwigClassFXWizard);
+  rb_define_alloc_func(SwigClassFXWizard.klass, _wrap_FXWizard_allocate);
+  rb_define_method(SwigClassFXWizard.klass, "initialize", VALUEFUNC(_wrap_new_FXWizard), -1);
+  rb_define_method(SwigClassFXWizard.klass, "onUpdFinish", VALUEFUNC(_wrap_FXWizard_onUpdFinish), -1);
+  rb_define_method(SwigClassFXWizard.klass, "onCmdNext", VALUEFUNC(_wrap_FXWizard_onCmdNext), -1);
+  rb_define_method(SwigClassFXWizard.klass, "onUpdNext", VALUEFUNC(_wrap_FXWizard_onUpdNext), -1);
+  rb_define_method(SwigClassFXWizard.klass, "onCmdBack", VALUEFUNC(_wrap_FXWizard_onCmdBack), -1);
+  rb_define_method(SwigClassFXWizard.klass, "onUpdBack", VALUEFUNC(_wrap_FXWizard_onUpdBack), -1);
+  rb_define_const(SwigClassFXWizard.klass, "ID_NEXT", SWIG_From_int(static_cast< int >(FXWizard::ID_NEXT)));
+  rb_define_const(SwigClassFXWizard.klass, "ID_BACK", SWIG_From_int(static_cast< int >(FXWizard::ID_BACK)));
+  rb_define_const(SwigClassFXWizard.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXWizard::ID_LAST)));
+  rb_define_method(SwigClassFXWizard.klass, "buttonFrame", VALUEFUNC(_wrap_FXWizard_buttonFrame), -1);
+  rb_define_method(SwigClassFXWizard.klass, "advanceButton", VALUEFUNC(_wrap_FXWizard_advanceButton), -1);
+  rb_define_method(SwigClassFXWizard.klass, "retreatButton", VALUEFUNC(_wrap_FXWizard_retreatButton), -1);
+  rb_define_method(SwigClassFXWizard.klass, "finishButton", VALUEFUNC(_wrap_FXWizard_finishButton), -1);
+  rb_define_method(SwigClassFXWizard.klass, "cancelButton", VALUEFUNC(_wrap_FXWizard_cancelButton), -1);
+  rb_define_method(SwigClassFXWizard.klass, "getContainer", VALUEFUNC(_wrap_FXWizard_getContainer), -1);
+  rb_define_method(SwigClassFXWizard.klass, "setImage", VALUEFUNC(_wrap_FXWizard_setImage), -1);
+  rb_define_method(SwigClassFXWizard.klass, "getImage", VALUEFUNC(_wrap_FXWizard_getImage), -1);
+  rb_define_method(SwigClassFXWizard.klass, "getNumPanels", VALUEFUNC(_wrap_FXWizard_getNumPanels), -1);
+  rb_define_method(SwigClassFXWizard.klass, "setCurrentPanel", VALUEFUNC(_wrap_FXWizard_setCurrentPanel), -1);
+  rb_define_method(SwigClassFXWizard.klass, "getCurrentPanel", VALUEFUNC(_wrap_FXWizard_getCurrentPanel), -1);
+  rb_define_method(SwigClassFXWizard.klass, "save", VALUEFUNC(_wrap_FXWizard_save), -1);
+  rb_define_method(SwigClassFXWizard.klass, "load", VALUEFUNC(_wrap_FXWizard_load), -1);
+  rb_define_method(SwigClassFXWizard.klass, "create", VALUEFUNC(_wrap_FXWizard_create), -1);
+  rb_define_method(SwigClassFXWizard.klass, "detach", VALUEFUNC(_wrap_FXWizard_detach), -1);
+  rb_define_method(SwigClassFXWizard.klass, "destroy", VALUEFUNC(_wrap_FXWizard_destroy), -1);
+  rb_define_method(SwigClassFXWizard.klass, "resize", VALUEFUNC(_wrap_FXWizard_resize), -1);
+  rb_define_method(SwigClassFXWizard.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXWizard_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXWizard.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXWizard_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXWizard.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXWizard_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXWizard.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXWizard_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXWizard.klass, "canFocus", VALUEFUNC(_wrap_FXWizard_canFocus), -1);
+  rb_define_method(SwigClassFXWizard.klass, "setFocus", VALUEFUNC(_wrap_FXWizard_setFocus), -1);
+  rb_define_method(SwigClassFXWizard.klass, "killFocus", VALUEFUNC(_wrap_FXWizard_killFocus), -1);
+  rb_define_method(SwigClassFXWizard.klass, "changeFocus", VALUEFUNC(_wrap_FXWizard_changeFocus), -1);
+  rb_define_method(SwigClassFXWizard.klass, "setDefault", VALUEFUNC(_wrap_FXWizard_setDefault), -1);
+  rb_define_method(SwigClassFXWizard.klass, "enable", VALUEFUNC(_wrap_FXWizard_enable), -1);
+  rb_define_method(SwigClassFXWizard.klass, "disable", VALUEFUNC(_wrap_FXWizard_disable), -1);
+  rb_define_method(SwigClassFXWizard.klass, "raiseWindow", VALUEFUNC(_wrap_FXWizard_raiseWindow), -1);
+  rb_define_method(SwigClassFXWizard.klass, "lower", VALUEFUNC(_wrap_FXWizard_lower), -1);
+  rb_define_method(SwigClassFXWizard.klass, "move", VALUEFUNC(_wrap_FXWizard_move), -1);
+  rb_define_method(SwigClassFXWizard.klass, "position", VALUEFUNC(_wrap_FXWizard_position), -1);
+  rb_define_method(SwigClassFXWizard.klass, "layout", VALUEFUNC(_wrap_FXWizard_layout), -1);
+  rb_define_method(SwigClassFXWizard.klass, "recalc", VALUEFUNC(_wrap_FXWizard_recalc), -1);
+  rb_define_method(SwigClassFXWizard.klass, "reparent", VALUEFUNC(_wrap_FXWizard_reparent), -1);
+  rb_define_method(SwigClassFXWizard.klass, "hide", VALUEFUNC(_wrap_FXWizard_hide), -1);
+  rb_define_method(SwigClassFXWizard.klass, "isComposite", VALUEFUNC(_wrap_FXWizard_isComposite), -1);
+  rb_define_method(SwigClassFXWizard.klass, "contains", VALUEFUNC(_wrap_FXWizard_contains), -1);
+  rb_define_method(SwigClassFXWizard.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXWizard_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXWizard.klass, "setBackColor", VALUEFUNC(_wrap_FXWizard_setBackColor), -1);
+  rb_define_method(SwigClassFXWizard.klass, "tr", VALUEFUNC(_wrap_FXWizard_tr), -1);
+  rb_define_method(SwigClassFXWizard.klass, "dropEnable", VALUEFUNC(_wrap_FXWizard_dropEnable), -1);
+  rb_define_method(SwigClassFXWizard.klass, "dropDisable", VALUEFUNC(_wrap_FXWizard_dropDisable), -1);
+  rb_define_method(SwigClassFXWizard.klass, "setShape", VALUEFUNC(_wrap_FXWizard_setShape), -1);
+  rb_define_method(SwigClassFXWizard.klass, "clearShape", VALUEFUNC(_wrap_FXWizard_clearShape), -1);
+  rb_define_method(SwigClassFXWizard.klass, "show", VALUEFUNC(_wrap_FXWizard_show), -1);
+  rb_define_method(SwigClassFXWizard.klass, "maximize", VALUEFUNC(_wrap_FXWizard_maximize), -1);
+  rb_define_method(SwigClassFXWizard.klass, "minimize", VALUEFUNC(_wrap_FXWizard_minimize), -1);
+  rb_define_method(SwigClassFXWizard.klass, "restore", VALUEFUNC(_wrap_FXWizard_restore), -1);
+  rb_define_method(SwigClassFXWizard.klass, "close", VALUEFUNC(_wrap_FXWizard_close), -1);
+  rb_define_method(SwigClassFXWizard.klass, "execute", VALUEFUNC(_wrap_FXWizard_execute), -1);
+  SwigClassFXWizard.mark = (void (*)(void *)) FXRbWizard::markfunc;
+  SwigClassFXWizard.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXWizard.trackObjects = 0;
+  
+  SwigClassFXChoiceBox.klass = rb_define_class_under(mFox, "FXChoiceBox", ((swig_class *) SWIGTYPE_p_FXDialogBox->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXChoiceBox, (void *) &SwigClassFXChoiceBox);
+  rb_define_alloc_func(SwigClassFXChoiceBox.klass, _wrap_FXChoiceBox_allocate);
+  rb_define_method(SwigClassFXChoiceBox.klass, "initialize", VALUEFUNC(_wrap_new_FXChoiceBox), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "onCmdClicked", VALUEFUNC(_wrap_FXChoiceBox_onCmdClicked), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "onCmdCancel", VALUEFUNC(_wrap_FXChoiceBox_onCmdCancel), -1);
+  rb_define_const(SwigClassFXChoiceBox.klass, "ID_CLICKED", SWIG_From_int(static_cast< int >(FXChoiceBox::ID_CLICKED)));
+  rb_define_const(SwigClassFXChoiceBox.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXChoiceBox::ID_LAST)));
+  rb_define_singleton_method(SwigClassFXChoiceBox.klass, "ask", VALUEFUNC(_wrap_FXChoiceBox_ask), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "save", VALUEFUNC(_wrap_FXChoiceBox_save), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "load", VALUEFUNC(_wrap_FXChoiceBox_load), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "create", VALUEFUNC(_wrap_FXChoiceBox_create), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "detach", VALUEFUNC(_wrap_FXChoiceBox_detach), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "destroy", VALUEFUNC(_wrap_FXChoiceBox_destroy), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "resize", VALUEFUNC(_wrap_FXChoiceBox_resize), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXChoiceBox_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXChoiceBox_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXChoiceBox_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXChoiceBox_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "canFocus", VALUEFUNC(_wrap_FXChoiceBox_canFocus), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "setFocus", VALUEFUNC(_wrap_FXChoiceBox_setFocus), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "killFocus", VALUEFUNC(_wrap_FXChoiceBox_killFocus), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "changeFocus", VALUEFUNC(_wrap_FXChoiceBox_changeFocus), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "setDefault", VALUEFUNC(_wrap_FXChoiceBox_setDefault), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "enable", VALUEFUNC(_wrap_FXChoiceBox_enable), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "disable", VALUEFUNC(_wrap_FXChoiceBox_disable), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "raiseWindow", VALUEFUNC(_wrap_FXChoiceBox_raiseWindow), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "lower", VALUEFUNC(_wrap_FXChoiceBox_lower), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "move", VALUEFUNC(_wrap_FXChoiceBox_move), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "position", VALUEFUNC(_wrap_FXChoiceBox_position), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "layout", VALUEFUNC(_wrap_FXChoiceBox_layout), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "recalc", VALUEFUNC(_wrap_FXChoiceBox_recalc), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "reparent", VALUEFUNC(_wrap_FXChoiceBox_reparent), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "hide", VALUEFUNC(_wrap_FXChoiceBox_hide), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "isComposite", VALUEFUNC(_wrap_FXChoiceBox_isComposite), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "contains", VALUEFUNC(_wrap_FXChoiceBox_contains), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXChoiceBox_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "setBackColor", VALUEFUNC(_wrap_FXChoiceBox_setBackColor), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "tr", VALUEFUNC(_wrap_FXChoiceBox_tr), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "dropEnable", VALUEFUNC(_wrap_FXChoiceBox_dropEnable), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "dropDisable", VALUEFUNC(_wrap_FXChoiceBox_dropDisable), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "setShape", VALUEFUNC(_wrap_FXChoiceBox_setShape), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "clearShape", VALUEFUNC(_wrap_FXChoiceBox_clearShape), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "show", VALUEFUNC(_wrap_FXChoiceBox_show), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "maximize", VALUEFUNC(_wrap_FXChoiceBox_maximize), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "minimize", VALUEFUNC(_wrap_FXChoiceBox_minimize), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "restore", VALUEFUNC(_wrap_FXChoiceBox_restore), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "close", VALUEFUNC(_wrap_FXChoiceBox_close), -1);
+  rb_define_method(SwigClassFXChoiceBox.klass, "execute", VALUEFUNC(_wrap_FXChoiceBox_execute), -1);
+  SwigClassFXChoiceBox.mark = (void (*)(void *)) FXRbChoiceBox::markfunc;
+  SwigClassFXChoiceBox.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXChoiceBox.trackObjects = 0;
+}
+
diff --git a/ext/fox16_c/extconf.rb b/ext/fox16_c/extconf.rb
index 4ce01e0f..c49a9d70 100755
--- a/ext/fox16_c/extconf.rb
+++ b/ext/fox16_c/extconf.rb
@@ -3,118 +3,127 @@
 require 'fileutils'
 require 'mkmf'
 
-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"]
-  usrdirs = []
-  ARGV.each do |arg|
-    if arg =~ /--with-fox-include/
-      option, value = arg.split('=')
-      usrdirs = [ value ] + usrdirs
-    end
-  end
-  incdirs = usrdirs + stddirs
-  incdirs.uniq! # remove duplicates
-
-  incdirs.each do |incdir|
-    filename = File.join(incdir, "fxver.h")
-    if FileTest.exist?(filename)
-      idircflag = "-I" + incdir
-      $CPPFLAGS += " " + idircflag unless $CPPFLAGS.split.include?(idircflag)
-      return
-    end
-  end
-
-  # Couldn't find it; this should have been caught by the pre-config script
-  raise RuntimeError, "couldn't find FOX header files"
-end
+gem 'mini_portile2', '~>2.1'
+require 'mini_portile2'
 
 $autodetected_fxscintilla = false
 
-def find_installed_fxscintilla_version
-  stddirs = ["/usr/include/fxscintilla",
-             "/usr/local/include/fxscintilla",
-             "/sw/include/fxscintilla",
-	     "/opt/local/include/fxscintilla"]
-  usrdirs = []
-  ARGV.each do |arg|
-    if arg =~ /--with-fxscintilla-include/
-      option, value = arg.split('=')
-      usrdirs = [ value ] + usrdirs
-    end
-  end
-  incdirs = usrdirs + stddirs
-  incdirs.uniq! # remove duplicates
-
-  incdirs.each do |incdir|
-    filename = File.join(incdir, "FXScintilla.h")
-    if FileTest.exist?(filename)
-      $autodetected_fxscintilla = true
-      idircflag = "-I" + incdir
-      $CPPFLAGS += " " + idircflag unless $CPPFLAGS.split.include?(idircflag)
-      return
-    end
-  end
-end
-
 def is_fxscintilla_build?
   # No means no
   return false if fxscintilla_support_suppressed?
 
   # Check arguments
-  args = ARGV.delete_if { |e| !(e =~ /--with-fxscintilla/) }
-  (args.length > 0) || $autodetected_fxscintilla
+  with_config("fxscintilla", false) || $autodetected_fxscintilla
 end
 
 def fxscintilla_support_suppressed?
-  ARGV.include? "--without-fxscintilla"
+  !with_config("fxscintilla", true)
 end
 
-def with_env(hash)
-  hash.each do |k, v|
-    ENV[k] = v
-  end
-  begin
-    yield
-  ensure
-    hash.each do |k, v|
-      ENV.delete(k)
-    end
-  end
-end
-
-LIBZ_VERSION = ENV['LIBZ_VERSION'] || '1.2.7'
-LIBZ_SOURCE_URI = "http://downloads.sourceforge.net/project/libpng/zlib/#{LIBZ_VERSION}/zlib-#{LIBZ_VERSION}.tar.bz2"
+# Stick at zlib-1.2.7 for compatibility to MSYS1 based RubyInstaller.
+LIBZ_VERSION = ENV['LIBZ_VERSION'] || '1.2.7.3'
+LIBZ_SOURCE_URI = "http://zlib.net/fossils/zlib-#{LIBZ_VERSION}.tar.gz"
 
-LIBPNG_VERSION = ENV['LIBPNG_VERSION'] || '1.5.13'
+LIBPNG_VERSION = ENV['LIBPNG_VERSION'] || '1.6.37'
 LIBPNG_SOURCE_URI = "http://prdownloads.sourceforge.net/libpng/libpng-#{LIBPNG_VERSION}.tar.gz"
 
-LIBJPEG_VERSION = ENV['LIBJPEG_VERSION'] || '8d'
-LIBJPEG_SOURCE_URI = "http://www.ijg.org/files/jpegsrc.v#{LIBJPEG_VERSION}.tar.gz"
+# LIBJPEG_VERSION = ENV['LIBJPEG_VERSION'] || '9b'
+# LIBJPEG_SOURCE_URI = "http://www.ijg.org/files/jpegsrc.v#{LIBJPEG_VERSION}.tar.gz"
 
-LIBTIFF_VERSION = ENV['LIBTIFF_VERSION'] || '4.0.3'
+LIBJPEG_VERSION = ENV['LIBJPEG_VERSION'] || '2.0.4'
+LIBJPEG_SOURCE_URI = "https://downloads.sourceforge.net/libjpeg-turbo/libjpeg-turbo-#{LIBJPEG_VERSION}.tar.gz"
+
+LIBTIFF_VERSION = ENV['LIBTIFF_VERSION'] || '4.1.0'
 LIBTIFF_SOURCE_URI = "http://download.osgeo.org/libtiff/tiff-#{LIBTIFF_VERSION}.tar.gz"
 
-LIBFOX_VERSION            = ENV['LIBFOX_VERSION'] || '1.6.49'
-LIBFOX_SOURCE_URI         = "http://ftp.fox-toolkit.org/pub/fox-#{LIBFOX_VERSION}.tar.gz"
+LIBFOX_VERSION            = ENV['LIBFOX_VERSION'] || '1.6.57'
+LIBFOX_SOURCE_URI         = "http://fox-toolkit.org/ftp/fox-#{LIBFOX_VERSION}.tar.gz"
 
 LIBFXSCINTILLA_VERSION            = ENV['LIBFXSCINTILLA_VERSION'] || '2.28.0'
 LIBFXSCINTILLA_SOURCE_URI         = "http://download.savannah.gnu.org/releases/fxscintilla/fxscintilla-#{LIBFXSCINTILLA_VERSION}.tar.gz"
+# LIBFXSCINTILLA_VERSION            = ENV['LIBFXSCINTILLA_VERSION'] || '3.5.2'
+# LIBFXSCINTILLA_SOURCE_URI         = "https://github.com/yetanothergeek/fxscintilla/archive/FXSCINTILLA-#{LIBFXSCINTILLA_VERSION.gsub(".","_")}.tar.gz"
+
+module BuildRecipeCommons
+  def initialize(name, version, files)
+    super(name, version)
+    self.files = files
+    rootdir = File.expand_path('../../..', __FILE__)
+    self.target = File.join(rootdir, "ports")
+    self.host = RbConfig::CONFIG["host"]
+    self.patch_files = Dir[File.join(rootdir, "patches", self.name, self.version, "*.diff")].sort
+  end
+
+  def port_path
+    "#{target}/#{host}"
+  end
+
+  # When using rake-compiler-dock on Windows, the underlying Virtualbox shared
+  # folders don't support symlinks, but libiconv expects it for a build on
+  # Linux. We work around this limitation by using the temp dir for cooking.
+  def chdir_for_build
+    build_dir = ENV['RCD_HOST_RUBY_PLATFORM'].to_s =~ /mingw|mswin|cygwin/ ? '/tmp' : '.'
+    Dir.chdir(build_dir) do
+      yield
+    end
+  end
+
+  def cook_and_activate
+    checkpoint = File.join(self.target, "#{self.name}-#{self.version}-#{self.host}.installed")
+    unless File.exist?(checkpoint)
+      chdir_for_build do
+        self.cook
+      end
+      FileUtils.touch checkpoint
+    end
+    self.activate
+    self
+  end
+end
+
+class BuildRecipe < MiniPortile
+  include BuildRecipeCommons
+
+  def configure_defaults
+    [
+      "--host=#{host}",    # build for specific target (host)
+      "--disable-static",
+      "--enable-shared",
+    ]
+  end
+end
+class BuildRecipeCMake < MiniPortileCMake
+  include BuildRecipeCommons
+
+  def system_processor
+    case host
+    when /x86_64/ then "amd64"
+    when /i686/ then "x86"
+    else raise "unknown host #{host}"
+    end
+  end
+
+  def configure_defaults
+    [
+      "-DENABLE_STATIC=0",
+      "-DENABLE_SHARED=1",
+      "-DCMAKE_SYSTEM_NAME=Windows",
+      "-DCMAKE_C_COMPILER=#{host}-gcc",
+      "-DCMAKE_CXX_COMPILER=#{host}-g++",
+      "-DCMAKE_SYSTEM_PROCESSOR=#{system_processor}",
+    ]
+  end
+
+  def make_cmd
+    ENV["MAKE"] || "make"
+  end
+end
 
 def do_rake_compiler_setup
   if enable_config("win32-cross")
-    require 'mini_portile'
-
     dir_config("installed")
 
-    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"]
+    libz_recipe = BuildRecipe.new("libz", LIBZ_VERSION, [LIBZ_SOURCE_URI]).tap do |recipe|
       class << recipe
         def configure
           Dir.chdir work_path do
@@ -144,129 +153,50 @@ def do_rake_compiler_setup
         end
       end
 
-      checkpoint = File.join(portsdir, "#{recipe.name}-#{recipe.version}-#{recipe.host}.installed")
-      unless File.exist?(checkpoint)
-        recipe.cook
-        FileUtils.touch checkpoint
-      end
-      recipe.activate
+      recipe.cook_and_activate
     end
 
-    libpng_recipe = MiniPortile.new("libpng", LIBPNG_VERSION).tap do |recipe|
-      recipe.files = [LIBPNG_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.configure_options = [
-        "--host=#{recipe.host}",
-        "--enable-shared",
-        "--disable-static",
-        ]
-
-      checkpoint = File.join(portsdir, "#{recipe.name}-#{recipe.version}-#{recipe.host}.installed")
-      unless File.exist?(checkpoint)
-        with_env(
-          'CPPFLAGS' => "-I#{libz_recipe.path}/include",
-          'LDFLAGS' => "-L#{libz_recipe.path}/lib"
-        ) do
-          recipe.cook
-          FileUtils.touch checkpoint
-        end
-      end
-      recipe.activate
+    libpng_recipe = BuildRecipe.new("libpng", LIBPNG_VERSION, [LIBPNG_SOURCE_URI]).tap do |recipe|
+      recipe.configure_options += [
+        "CPPFLAGS=-I#{libz_recipe.path}/include",
+        "LDFLAGS=-L#{libz_recipe.path}/lib",
+      ]
+      recipe.cook_and_activate
     end
 
-    libjpeg_recipe = MiniPortile.new("libjpeg", LIBJPEG_VERSION).tap do |recipe|
-      recipe.files = [LIBJPEG_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.configure_options = [
-        "--host=#{recipe.host}",
-        "--enable-shared",
-        "--disable-static",
-        ]
-
-      checkpoint = File.join(portsdir, "#{recipe.name}-#{recipe.version}-#{recipe.host}.installed")
-      unless File.exist?(checkpoint)
-        recipe.cook
-        FileUtils.touch checkpoint
-      end
-      recipe.activate
+    libjpeg_recipe = BuildRecipeCMake.new("libjpeg", LIBJPEG_VERSION, [LIBJPEG_SOURCE_URI]).tap do |recipe|
+      recipe.cook_and_activate
     end
 
-    libtiff_recipe = MiniPortile.new("libtiff", LIBTIFF_VERSION).tap do |recipe|
-      recipe.files = [LIBTIFF_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.configure_options = [
-        "--host=#{recipe.host}",
-        "--enable-shared",
-        "--disable-static",
-        ]
-
-      checkpoint = File.join(portsdir, "#{recipe.name}-#{recipe.version}-#{recipe.host}.installed")
-      unless File.exist?(checkpoint)
-        recipe.cook
-        FileUtils.touch checkpoint
-      end
-      recipe.activate
+    libtiff_recipe = BuildRecipe.new("libtiff", LIBTIFF_VERSION, [LIBTIFF_SOURCE_URI]).tap do |recipe|
+      recipe.cook_and_activate
     end
 
-    libfox_recipe = MiniPortile.new("libfox", LIBFOX_VERSION).tap do |recipe|
-      recipe.files = [LIBFOX_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.configure_options = [
-        "--host=#{recipe.host}",
+    libfox_recipe = BuildRecipe.new("libfox", LIBFOX_VERSION, [LIBFOX_SOURCE_URI]).tap do |recipe|
+      debug = enable_config("debug")
+      recipe.configure_options += [
         "--without-xft",
         "--without-x",
-        "--enable-shared",
-        "--disable-static",
-        ]
-      class << recipe
-        def compile
-          # Add param -no-undefined to libtool to build a win32 shared lib
-          execute "compile", "#{ENV['MAKE'] || "make"} libFOX_1_6_la_LDFLAGS='-version-info 0:49:0 -export-dynamic -no-undefined'"
-        end
-      end
-
-      checkpoint = File.join(portsdir, "#{recipe.name}-#{recipe.version}-#{recipe.host}.installed")
-      unless File.exist?(checkpoint)
-        with_env(
-          "CPPFLAGS" => "-I#{libjpeg_recipe.path}/include -I#{libpng_recipe.path}/include -I#{libtiff_recipe.path}/include -I#{libz_recipe.path}/include",
-          "LDFLAGS" => "-L#{libjpeg_recipe.path}/lib -L#{libpng_recipe.path}/lib -L#{libtiff_recipe.path}/lib -L#{libz_recipe.path}/lib"
-        ) do
-          recipe.cook
-          FileUtils.touch checkpoint
-        end
-      end
-      recipe.activate
+        debug ? "--enable-debug" : "--enable-release",
+        "CPPFLAGS=-I#{libjpeg_recipe.path}/include -I#{libpng_recipe.path}/include -I#{libtiff_recipe.path}/include -I#{libz_recipe.path}/include -DUNICODE=1 #{debug ? "-ggdb" : ""}",
+        "LDFLAGS=-L#{libjpeg_recipe.path}/lib -L#{libpng_recipe.path}/lib -L#{libtiff_recipe.path}/lib -L#{libz_recipe.path}/lib #{debug ? "-ggdb" : ""}",
+      ]
+      recipe.cook_and_activate
     end
 
-    libfxscintills_recipe = MiniPortile.new("libfxscintilla", LIBFXSCINTILLA_VERSION).tap do |recipe|
-      recipe.files = [LIBFXSCINTILLA_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.configure_options = [
-        "--host=#{recipe.host}",
-        "--enable-shared",
-        "--disable-static",
-        ]
+    libfxscintills_recipe = BuildRecipe.new("libfxscintilla", LIBFXSCINTILLA_VERSION, [LIBFXSCINTILLA_SOURCE_URI]).tap do |recipe|
       class << recipe
         attr_accessor :libfox_path
         def mk
           "#{ENV['MAKE'] || "make"}"
         end
 
+#         # This can be uncommented when fxscintilla is used from the source repository.
+#         def configure
+#           execute "bootstrap", "./bootstrap.sh"
+#           super
+#         end
+
         def compile
           execute "compile_lexers", "cd lexers && #{mk}"
           execute "compile_lexlib", "cd lexlib && #{mk}"
@@ -280,50 +210,29 @@ def do_rake_compiler_setup
       end
       recipe.libfox_path = libfox_recipe.path
 
-      checkpoint = File.join(portsdir, "#{recipe.name}-#{recipe.version}-#{recipe.host}.installed")
-      unless File.exist?(checkpoint)
-        recipe.cook
-        FileUtils.touch checkpoint
-      end
-      recipe.activate
-    end
-
-#     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")
-
-    shared_dlls = [
-        "#{libfxscintills_recipe.path}/bin/libfxscintilla-20.dll",
-        "#{libfox_recipe.path}/bin/libFOX-1.6-0.dll",
-        "#{libjpeg_recipe.path}/bin/libjpeg-8.dll",
-        "#{libpng_recipe.path}/bin/libpng15-15.dll",
-        "#{libtiff_recipe.path}/bin/libtiff-5.dll",
-        "#{libz_recipe.path}/bin/zlib1.dll",
+      recipe.configure_options += [
+        "PKG_CONFIG_PATH=#{libfox_recipe.path}/lib/pkgconfig",
       ]
-    shared_dlls.each do |dll|
-      FileUtils.cp dll, '.', verbose: true
+      recipe.cook_and_activate
     end
 
+    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")
+
     gcc_shared_dlls = %w[libwinpthread-1.dll libgcc_s_dw2-1.dll libgcc_s_sjlj-1.dll libgcc_s_seh-1.dll libstdc++-6.dll]
     gcc_shared_dlls.each do |dll|
-      cmd = "#{CONFIG['CC']} -print-file-name=#{dll}"
+      cmd = "#{CONFIG['CC']} -print-file-name=\"#{dll}\""
       res = `#{cmd}`.chomp
       next if dll == res
       puts "#{cmd} => #{res}"
-      FileUtils.cp `#{cmd}`.chomp, '.', verbose: true
+      FileUtils.cp `#{cmd}`.chomp, "#{libfox_recipe.path}/bin/", verbose: true
     end
 
-    CONFIG['CXX'] = "#{RbConfig::CONFIG["host"]}-g++" # CXX setting must be prefixed for cross build
+    CONFIG['CXX'] = "#{libfox_recipe.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
+    $libs = append_library($libs, "fxscintilla")
 
   elsif RUBY_PLATFORM =~ /mingw/
     $CFLAGS = $CFLAGS + " -I/usr/local/include"
@@ -350,15 +259,27 @@ 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"
-    $libs = append_library($libs, "fxscintilla")
-  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 <<-EOT
+      __thread int x=1;
+      #if defined(__MINGW32__)
+        #include <windows.h>
+        #if !defined(__MINGW64_VERSION_MAJOR)
+          #error "Old mingw32 compiler doesn't implement thread local variables properly."
+        #endif
+      #endif
+    EOT
+  end &&
+      have_func('rb_thread_call_without_gvl') &&
+      have_func('rb_thread_call_with_gvl')
+
+  have_func('rb_during_gc')
 end
 
 # This directive processes the "--with-fox-include" and "--with-fox-lib"
@@ -372,23 +293,50 @@ 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")
+  checking_for "fox per pkg-config" do
+    pkg_config("fox")
+  end
+
+  #
+  # 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?
+    checking_for "fxscintilla per pkg-config" do
+      $autodetected_fxscintilla = pkg_config("fxscintilla")
+    end
 
-unless fxscintilla_support_suppressed?
-  find_installed_fxscintilla_version
+    unless $autodetected_fxscintilla
+      checking_for "fxscintilla on Ubuntu with missing libfxscintilla.so link" do
+        if find_library(":libfxscintilla.so.19", nil) && (cflags = RUBY_VERSION>="2.1" ? pkg_config("fxscintilla", "cflags") : `pkg-config --cflags fxscintilla`)
+          $CXXFLAGS += " " + cflags
+          $autodetected_fxscintilla = true
+        end
+      end
+    end
+  end
+  checking_for "fxscintilla build" do
+    is_fxscintilla_build?
+  end
+end
+
+if enable_config("debug")
+  $CPPFLAGS += " -ggdb"
+  $LDFLAGS += " -ggdb"
+else
+  $CPPFLAGS += " -DNDEBUG"
 end
 
 # Platform-specific modifications
 do_rake_compiler_setup
 
-$CFLAGS += " -DRUBY_1_8" if RUBY_VERSION =~ /1\.8\./
-$CFLAGS += " -DRUBY_1_9" if RUBY_VERSION =~ /1\.9\./
-$CFLAGS += " -DRUBY_2_0" if RUBY_VERSION =~ /2\.0\./
+if RbConfig::MAKEFILE_CONFIG['CC'] =~ /gcc/
+  $CXXFLAGS += " -Wno-unused-function"
+  $CXXFLAGS += " -Wno-maybe-uninitialized"
+end
 
 # Last step: build the makefile
+create_header
 create_makefile("fox16_c")
diff --git a/ext/fox16_c/frames_wrap.cpp b/ext/fox16_c/frames_wrap.cpp
new file mode 100644
index 00000000..5a3382ae
--- /dev/null
+++ b/ext/fox16_c/frames_wrap.cpp
@@ -0,0 +1,49420 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 3.0.12
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+
+#ifndef SWIGRUBY
+#define SWIGRUBY
+#endif
+
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
+};
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic C API SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "4"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/*  Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN           0x1
+
+
+/*
+   Flags/methods for returning states.
+
+   The SWIG conversion methods, as ConvertPtr, return an integer
+   that tells if the conversion was successful or not. And if not,
+   an error code can be returned (see swigerrors.swg for the codes).
+
+   Use the following macros/flags to set or process the returning
+   states.
+
+   In old versions of SWIG, code such as the following was usually written:
+
+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+       // success code
+     } else {
+       //fail code
+     }
+
+   Now you can be more explicit:
+
+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+    } else {
+      // fail code
+    }
+
+   which is the same really, but now you can also do
+
+    Type *ptr;
+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+      if (SWIG_IsNewObj(res) {
+        ...
+	delete *ptr;
+      } else {
+        ...
+      }
+    } else {
+      // fail code
+    }
+
+   I.e., now SWIG_ConvertPtr can return new objects and you can
+   identify the case and take care of the deallocation. Of course that
+   also requires SWIG_ConvertPtr to return new result values, such as
+
+      int SWIG_ConvertPtr(obj, ptr,...) {
+        if (<obj is ok>) {
+          if (<need new object>) {
+            *ptr = <ptr to new allocated object>;
+            return SWIG_NEWOBJ;
+          } else {
+            *ptr = <ptr to old object>;
+            return SWIG_OLDOBJ;
+          }
+        } else {
+          return SWIG_BADOBJ;
+        }
+      }
+
+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+   SWIG errors code.
+
+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+   allows to return the 'cast rank', for example, if you have this
+
+       int food(double)
+       int fooi(int);
+
+   and you call
+
+      food(1)   // cast rank '1'  (1 -> 1.0)
+      fooi(1)   // cast rank '0'
+
+   just use the SWIG_AddCast()/SWIG_CheckState()
+*/
+
+#define SWIG_OK                    (0)
+#define SWIG_ERROR                 (-1)
+#define SWIG_IsOK(r)               (r >= 0)
+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT         (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ                (SWIG_ERROR)
+#define SWIG_OLDOBJ                (SWIG_OK)
+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+#  ifndef SWIG_TypeRank
+#    define SWIG_TypeRank             unsigned long
+#  endif
+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
+#    define SWIG_MAXCASTRANK          (2)
+#  endif
+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+#  define SWIG_AddCast(r) (r)
+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *, int *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store information on one type */
+typedef struct swig_type_info {
+  const char             *name;			/* mangled name of this type */
+  const char             *str;			/* human readable name of this type */
+  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
+  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
+  void                   *clientdata;		/* language specific type data */
+  int                    owndata;		/* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
+  swig_converter_func     converter;		/* function to cast the void pointers */
+  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
+  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
+  size_t                 size;		        /* Number of types in this module */
+  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
+  swig_type_info         **type_initial;	/* Array of initially generated type structures */
+  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
+  void                    *clientdata;		/* Language specific module data */
+} swig_module_info;
+
+/*
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+  }
+  return (int)((l1 - f1) - (l2 - f2));
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCmp(const char *nb, const char *tb) {
+  int equiv = 1;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (equiv != 0 && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
+}
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
+}
+
+/*
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+  swig_type_info *lastty = ty;
+  if (!ty || !ty->dcast) return ty;
+  while (ty && (ty->dcast)) {
+    ty = (*ty->dcast)(ptr);
+    if (ty) lastty = ty;
+  }
+  return lastty;
+}
+
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+  return ty->name;
+}
+
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (!type) return NULL;
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
+  }
+  else
+    return type->name;
+}
+
+/*
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+  swig_cast_info *cast = ti->cast;
+  /* if (ti->clientdata == clientdata) return; */
+  ti->clientdata = clientdata;
+
+  while (cast) {
+    if (!cast->converter) {
+      swig_type_info *tc = cast->type;
+      if (!tc->clientdata) {
+	SWIG_TypeClientData(tc, clientdata);
+      }
+    }
+    cast = cast->next;
+  }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientData(ti, clientdata);
+  ti->owndata = 1;
+}
+
+/*
+  Search for a swig_type_info structure only by mangled name
+  Search is a O(log #types)
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+                            swig_module_info *end,
+		            const char *name) {
+  swig_module_info *iter = start;
+  do {
+    if (iter->size) {
+      size_t l = 0;
+      size_t r = iter->size - 1;
+      do {
+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
+	size_t i = (l + r) >> 1;
+	const char *iname = iter->types[i]->name;
+	if (iname) {
+	  int compare = strcmp(name, iname);
+	  if (compare == 0) {
+	    return iter->types[i];
+	  } else if (compare < 0) {
+	    if (i) {
+	      r = i - 1;
+	    } else {
+	      break;
+	    }
+	  } else if (compare > 0) {
+	    l = i + 1;
+	  }
+	} else {
+	  break; /* should never happen */
+	}
+      } while (l <= r);
+    }
+    iter = iter->next;
+  } while (iter != end);
+  return 0;
+}
+
+/*
+  Search for a swig_type_info structure for either a mangled name or a human readable name.
+  It first searches the mangled names of the types, which is a O(log #types)
+  If a type is not found it then searches the human readable names, which is O(#types).
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+                     swig_module_info *end,
+		     const char *name) {
+  /* STEP 1: Search the name field using binary search */
+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+  if (ret) {
+    return ret;
+  } else {
+    /* STEP 2: If the type hasn't been found, do a complete search
+       of the str field (the human readable name) */
+    swig_module_info *iter = start;
+    do {
+      size_t i = 0;
+      for (; i < iter->size; ++i) {
+	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+	  return iter->types[i];
+      }
+      iter = iter->next;
+    } while (iter != end);
+  }
+
+  /* neither found a match */
+  return 0;
+}
+
+/*
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+
+/*
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = (unsigned char)((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = (unsigned char)((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (unsigned char)(d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (unsigned char)(d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/*
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/*  Errors in SWIG */
+#define  SWIG_UnknownError    	   -1
+#define  SWIG_IOError        	   -2
+#define  SWIG_RuntimeError   	   -3
+#define  SWIG_IndexError     	   -4
+#define  SWIG_TypeError      	   -5
+#define  SWIG_DivisionByZero 	   -6
+#define  SWIG_OverflowError  	   -7
+#define  SWIG_SyntaxError    	   -8
+#define  SWIG_ValueError     	   -9
+#define  SWIG_SystemError    	   -10
+#define  SWIG_AttributeError 	   -11
+#define  SWIG_MemoryError    	   -12
+#define  SWIG_NullReferenceError   -13
+
+
+
+      #include <ruby.h>
+
+      #if defined(RB_METHOD_DEFINITION_DECL)
+      # define RUBY_VALUE_METHOD_FUNC(func) (func)
+      # define RUBY_INT_METHOD_FUNC(func) (func)
+      # define RUBY_VOID_METHOD_FUNC(func) (func)
+      # define RUBY_VOIDP_METHOD_FUNC(func) (func)
+      #else
+      # define RUBY_VALUE_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
+      # define RUBY_INT_METHOD_FUNC(func) ((int (*)(ANYARGS))(func))
+      # define RUBY_VOID_METHOD_FUNC(func) ((void (*)(ANYARGS))(func))
+      # define RUBY_VOIDP_METHOD_FUNC(func) ((void *(*)(ANYARGS))(func))
+      #endif
+
+
+/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
+ * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
+ * issue for now by disabling this.
+ * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
+ */
+#ifdef rb_intern
+# undef rb_intern
+#endif
+
+/* Remove global macros defined in Ruby's win32.h */
+#ifdef write
+# undef write
+#endif
+#ifdef read
+# undef read
+#endif
+#ifdef bind
+# undef bind
+#endif
+#ifdef close
+# undef close
+#endif
+#ifdef connect
+# undef connect
+#endif
+
+
+/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
+#ifndef NUM2LL
+#define NUM2LL(x) NUM2LONG((x))
+#endif
+#ifndef LL2NUM
+#define LL2NUM(x) INT2NUM((long) (x))
+#endif
+#ifndef ULL2NUM
+#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
+#endif
+
+/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
+#ifndef NUM2ULL
+#ifdef HAVE_LONG_LONG
+#define NUM2ULL(x) rb_num2ull((x))
+#else
+#define NUM2ULL(x) NUM2ULONG(x)
+#endif
+#endif
+
+/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
+/* Define these for older versions so we can just write code the new way */
+#ifndef RSTRING_LEN
+# define RSTRING_LEN(x) RSTRING(x)->len
+#endif
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(x) RSTRING(x)->ptr
+#endif
+#ifndef RSTRING_END
+# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
+#endif
+#ifndef RARRAY_LEN
+# define RARRAY_LEN(x) RARRAY(x)->len
+#endif
+#ifndef RARRAY_PTR
+# define RARRAY_PTR(x) RARRAY(x)->ptr
+#endif
+#ifndef RFLOAT_VALUE
+# define RFLOAT_VALUE(x) RFLOAT(x)->value
+#endif
+#ifndef DOUBLE2NUM
+# define DOUBLE2NUM(x) rb_float_new(x)
+#endif
+#ifndef RHASH_TBL
+# define RHASH_TBL(x) (RHASH(x)->tbl)
+#endif
+#ifndef RHASH_ITER_LEV
+# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
+#endif
+#ifndef RHASH_IFNONE
+# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
+#endif
+#ifndef RHASH_SIZE
+# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
+#endif
+#ifndef RHASH_EMPTY_P
+# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
+#endif
+#ifndef RSTRUCT_LEN
+# define RSTRUCT_LEN(x) RSTRUCT(x)->len
+#endif
+#ifndef RSTRUCT_PTR
+# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
+#endif
+
+
+
+/*
+ * Need to be very careful about how these macros are defined, especially
+ * when compiling C++ code or C code with an ANSI C compiler.
+ *
+ * VALUEFUNC(f) is a macro used to typecast a C function that implements
+ * a Ruby method so that it can be passed as an argument to API functions
+ * like rb_define_method() and rb_define_singleton_method().
+ *
+ * VOIDFUNC(f) is a macro used to typecast a C function that implements
+ * either the "mark" or "free" stuff for a Ruby Data object, so that it
+ * can be passed as an argument to API functions like Data_Wrap_Struct()
+ * and Data_Make_Struct().
+ */
+ 
+#ifdef __cplusplus
+#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
+#    define PROTECTFUNC(f) ((VALUE (*)()) f)
+#    define VALUEFUNC(f) ((VALUE (*)()) f)
+#    define VOIDFUNC(f)  ((void (*)()) f)
+#  else
+#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
+#      define PROTECTFUNC(f) ((VALUE (*)()) f)
+#      define VALUEFUNC(f) ((VALUE (*)()) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    else /* These definitions should work for Ruby 1.7+ */
+#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
+#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    endif
+#  endif
+#else
+#  define VALUEFUNC(f) (f)
+#  define VOIDFUNC(f) (f)
+#endif
+
+/* Don't use for expressions have side effect */
+#ifndef RB_STRING_VALUE
+#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
+#endif
+#ifndef StringValue
+#define StringValue(s) RB_STRING_VALUE(s)
+#endif
+#ifndef StringValuePtr
+#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
+#endif
+#ifndef StringValueLen
+#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
+#endif
+#ifndef SafeStringValue
+#define SafeStringValue(v) do {\
+    StringValue(v);\
+    rb_check_safe_str(v);\
+} while (0)
+#endif
+
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
+#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
+#endif
+
+static VALUE _mSWIG = Qnil;
+
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+
+/* Define some additional error types */
+#define SWIG_ObjectPreviouslyDeletedError  -100
+
+
+/* Define custom exceptions for errors that do not map to existing Ruby
+   exceptions.  Note this only works for C++ since a global cannot be
+   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/
+
+SWIGINTERN VALUE 
+getNullReferenceError(void) {
+  static int init = 0;
+  static VALUE rb_eNullReferenceError ;
+  if (!init) {
+    init = 1;
+    rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
+  }
+  return rb_eNullReferenceError;
+} 
+
+SWIGINTERN VALUE 
+getObjectPreviouslyDeletedError(void) {
+  static int init = 0;
+  static VALUE rb_eObjectPreviouslyDeleted ;
+  if (!init) {
+    init = 1;
+    rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
+  }
+  return rb_eObjectPreviouslyDeleted;
+} 
+
+
+SWIGINTERN VALUE
+SWIG_Ruby_ErrorType(int SWIG_code) {
+  VALUE type;
+  switch (SWIG_code) {
+  case SWIG_MemoryError:
+    type = rb_eNoMemError;
+    break;
+  case SWIG_IOError:
+    type = rb_eIOError;
+    break;
+  case SWIG_RuntimeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_IndexError:
+    type = rb_eIndexError;
+    break;
+  case SWIG_TypeError:
+    type = rb_eTypeError;
+    break;
+  case SWIG_DivisionByZero:
+    type = rb_eZeroDivError;
+    break;
+  case SWIG_OverflowError:
+    type = rb_eRangeError;
+    break;
+  case SWIG_SyntaxError:
+    type = rb_eSyntaxError;
+    break;
+  case SWIG_ValueError:
+    type = rb_eArgError;
+    break;
+  case SWIG_SystemError:
+    type = rb_eFatal;
+    break;
+  case SWIG_AttributeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_NullReferenceError:
+    type = getNullReferenceError();
+    break;
+  case SWIG_ObjectPreviouslyDeletedError:
+    type = getObjectPreviouslyDeletedError();
+    break;
+  case SWIG_UnknownError:
+    type = rb_eRuntimeError;
+    break;
+  default:
+    type = rb_eRuntimeError;
+  }
+  return type;
+}
+
+
+/* This function is called when a user inputs a wrong argument to
+   a method.
+ */
+SWIGINTERN 
+const char* Ruby_Format_TypeError( const char* msg,
+				   const char* type, 
+				   const char* name, 
+				   const int argn,
+				   VALUE input )
+{
+  char buf[128];
+  VALUE str;
+  VALUE asStr;
+  if ( msg && *msg )
+    {
+      str = rb_str_new2(msg);
+    }
+  else
+    {
+      str = rb_str_new(NULL, 0);
+    }
+
+  str = rb_str_cat2( str, "Expected argument " );
+  sprintf( buf, "%d of type ", argn-1 );
+  str = rb_str_cat2( str, buf );
+  str = rb_str_cat2( str, type );
+  str = rb_str_cat2( str, ", but got " );
+  str = rb_str_cat2( str, rb_obj_classname(input) );
+  str = rb_str_cat2( str, " " );
+  asStr = rb_inspect(input);
+  if ( RSTRING_LEN(asStr) > 30 )
+    {
+      str = rb_str_cat( str, StringValuePtr(asStr), 30 );
+      str = rb_str_cat2( str, "..." );
+    }
+  else
+    {
+      str = rb_str_append( str, asStr );
+    }
+
+  if ( name )
+    {
+      str = rb_str_cat2( str, "\n\tin SWIG method '" );
+      str = rb_str_cat2( str, name );
+      str = rb_str_cat2( str, "'" );
+    }
+
+  return StringValuePtr( str );
+}
+
+/* This function is called when an overloaded method fails */
+SWIGINTERN 
+void Ruby_Format_OverloadedError(
+				 const int argc,
+				 const int maxargs,
+				 const char* method, 
+				 const char* prototypes 
+				 )
+{
+  const char* msg = "Wrong # of arguments";
+  if ( argc <= maxargs ) msg = "Wrong arguments";
+  rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
+	   "Possible C/C++ prototypes are:\n%s",
+	   msg, method, prototypes);
+}
+
+/* -----------------------------------------------------------------------------
+ * rubytracking.swg
+ *
+ * This file contains support for tracking mappings from 
+ * Ruby objects to C++ objects.  This functionality is needed
+ * to implement mark functions for Ruby's mark and sweep
+ * garbage collector.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(ST_DATA_T_DEFINED)
+/* Needs to be explicitly included for Ruby 1.8 and earlier */
+#include <st.h>
+#endif
+
+/* Ruby 1.8 actually assumes the first case. */
+#if SIZEOF_VOIDP == SIZEOF_LONG
+#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
+#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
+#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
+#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
+#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
+#else
+#  error sizeof(void*) is not the same as long or long long
+#endif
+
+/* Global hash table to store Trackings from C/C++
+   structs to Ruby Objects. 
+*/
+static st_table* swig_ruby_trackings = NULL;
+
+static VALUE swig_ruby_trackings_count(ID id, VALUE *var) {
+  return SWIG2NUM(swig_ruby_trackings->num_entries);
+}
+
+
+/* Setup a hash table to store Trackings */
+SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
+  /* Create a hash table to store Trackings from C++
+     objects to Ruby objects. */
+
+  /* Try to see if some other .so has already created a 
+     tracking hash table, which we keep hidden in an instance var
+     in the SWIG module.
+     This is done to allow multiple DSOs to share the same
+     tracking table.
+  */
+  VALUE trackings_value = Qnil;
+  /* change the variable name so that we can mix modules
+     compiled with older SWIG's - this used to be called "@__trackings__" */
+  ID trackings_id = rb_intern( "@__safetrackings__" );
+  VALUE verbose = rb_gv_get("VERBOSE");
+  rb_gv_set("VERBOSE", Qfalse);
+  trackings_value = rb_ivar_get( _mSWIG, trackings_id );
+  rb_gv_set("VERBOSE", verbose);
+
+  /* The trick here is that we have to store the hash table
+  pointer in a Ruby variable. We do not want Ruby's GC to
+  treat this pointer as a Ruby object, so we convert it to
+  a Ruby numeric value. */
+  if (trackings_value == Qnil) {
+    /* No, it hasn't.  Create one ourselves */
+    swig_ruby_trackings = st_init_numtable();
+    rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
+  } else {
+    swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
+  }
+
+        rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", RUBY_VALUE_METHOD_FUNC(swig_ruby_trackings_count), RUBY_VOID_METHOD_FUNC((rb_gvar_setter_t*)NULL))
+;
+}
+
+/* Add a Tracking from a C/C++ struct to a Ruby object */
+SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
+  /* Store the mapping to the global hash table. */
+  st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
+}
+
+/* Get the Ruby object that owns the specified C/C++ struct */
+SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
+  /* Now lookup the value stored in the global hash table */
+  VALUE value;
+
+  if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
+    return value;
+  } else {
+    return Qnil;
+  }
+}
+
+/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
+   is very important to remove objects once they are destroyed
+   since the same memory address may be reused later to create
+   a new object. */
+SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
+  /* Delete the object from the hash table */
+  st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
+}
+
+/* This is a helper method that unlinks a Ruby object from its
+   underlying C++ object.  This is needed if the lifetime of the
+   Ruby object is longer than the C++ object */
+SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
+  VALUE object = SWIG_RubyInstanceFor(ptr);
+
+  if (object != Qnil) {
+    if (TYPE(object) != T_DATA)
+      abort();
+    DATA_PTR(object) = 0;
+  }
+}
+
+/* This is a helper method that iterates over all the trackings
+   passing the C++ object pointer and its related Ruby object
+   to the passed callback function. */
+
+/* Proxy method to abstract the internal trackings datatype */
+      static int swig_ruby_internal_iterate_callback(st_data_t ptr, st_data_t obj, st_data_t meth) {
+        ((void(*)(void*, VALUE))meth)((void*)ptr, (VALUE)obj);
+
+  return ST_CONTINUE;
+}
+
+SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
+  st_foreach(swig_ruby_trackings, RUBY_INT_METHOD_FUNC(swig_ruby_internal_iterate_callback), (st_data_t)meth);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Ruby API portion that goes into the runtime
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGINTERN VALUE
+SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
+  if (NIL_P(target)) {
+    target = o;
+  } else {
+    if (TYPE(target) != T_ARRAY) {
+      VALUE o2 = target;
+      target = rb_ary_new();
+      rb_ary_push(target, o2);
+    }
+    rb_ary_push(target, o);
+  }
+  return target;
+}
+
+/* For ruby1.8.4 and earlier. */
+#ifndef RUBY_INIT_STACK
+   RUBY_EXTERN void Init_stack(VALUE* addr);
+#  define RUBY_INIT_STACK \
+   VALUE variable_in_this_stack_frame; \
+   Init_stack(&variable_in_this_stack_frame);
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* -----------------------------------------------------------------------------
+ * rubyrun.swg
+ *
+ * This file contains the runtime support for Ruby modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
+#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
+#define swig_owntype                                    swig_ruby_owntype
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) 		SWIG_Ruby_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
+#define SWIG_Error(code, msg)            		rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
+#define SWIG_fail                        		goto fail				 
+
+
+/* Ruby-specific SWIG API */
+
+#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
+#define SWIG_define_class(ty)                        	SWIG_Ruby_define_class(ty)
+#define SWIG_NewClassInstance(value, ty)             	SWIG_Ruby_NewClassInstance(value, ty)
+#define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
+#define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  
+
+#include "assert.h"
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  VALUE klass;
+  VALUE mImpl;
+  void  (*mark)(void *);
+  void  (*destroy)(void *);
+  int trackObjects;
+} swig_class;
+
+
+/* Global pointer used to keep some internal SWIG stuff */
+static VALUE _cSWIG_Pointer = Qnil;
+static VALUE swig_runtime_data_type_pointer = Qnil;
+
+/* Global IDs used to keep some internal SWIG stuff */
+static ID swig_arity_id = 0;
+static ID swig_call_id  = 0;
+
+/*
+  If your swig extension is to be run within an embedded ruby and has
+  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
+  This will reset ruby's stack frame on each entry point from the main 
+  program the first time a virtual director function is invoked (in a 
+  non-recursive way).
+  If this is not done, you run the risk of Ruby trashing the stack.
+*/
+
+#ifdef RUBY_EMBEDDED
+
+#  define SWIG_INIT_STACK                            \
+      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
+      ++swig_virtual_calls;
+#  define SWIG_RELEASE_STACK --swig_virtual_calls;
+#  define Ruby_DirectorTypeMismatchException(x) \
+          rb_raise( rb_eTypeError, "%s", x ); return c_result;
+
+      static unsigned int swig_virtual_calls = 0;
+
+#else  /* normal non-embedded extension */
+
+#  define SWIG_INIT_STACK
+#  define SWIG_RELEASE_STACK
+#  define Ruby_DirectorTypeMismatchException(x) \
+          throw Swig::DirectorTypeMismatchException( x );
+
+#endif  /* RUBY_EMBEDDED */
+
+
+SWIGRUNTIME VALUE 
+getExceptionClass(void) {
+  static int init = 0;
+  static VALUE rubyExceptionClass ;
+  if (!init) {
+    init = 1;
+    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
+  }
+  return rubyExceptionClass;
+} 
+
+/* This code checks to see if the Ruby object being raised as part
+   of an exception inherits from the Ruby class Exception.  If so,
+   the object is simply returned.  If not, then a new Ruby exception
+   object is created and that will be returned to Ruby.*/
+SWIGRUNTIME VALUE
+SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
+  VALUE exceptionClass = getExceptionClass();
+  if (rb_obj_is_kind_of(obj, exceptionClass)) {
+    return obj;
+  }  else {
+    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
+  }
+}
+
+/* Initialize Ruby runtime support */
+SWIGRUNTIME void
+SWIG_Ruby_InitRuntime(void)
+{
+  if (_mSWIG == Qnil) {
+    _mSWIG = rb_define_module("SWIG");
+    swig_call_id  = rb_intern("call");
+    swig_arity_id = rb_intern("arity");
+  }
+}
+
+/* Define Ruby class for C type */
+SWIGRUNTIME void
+SWIG_Ruby_define_class(swig_type_info *type)
+{
+  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+  sprintf(klass_name, "TYPE%s", type->name);
+  if (NIL_P(_cSWIG_Pointer)) {
+    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
+    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
+  }
+  rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
+  free((void *) klass_name);
+}
+
+/* Create a new pointer object */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
+{
+  int own =  flags & SWIG_POINTER_OWN; 
+  int track;
+  char *klass_name;
+  swig_class *sklass;
+  VALUE klass;
+  VALUE obj;
+  
+  if (!ptr)
+    return Qnil;
+  
+  if (type->clientdata) {
+    sklass = (swig_class *) type->clientdata;
+		
+    /* Are we tracking this class and have we already returned this Ruby object? */
+    track = sklass->trackObjects;
+    if (track) {
+      obj = SWIG_RubyInstanceFor(ptr);
+      
+      /* Check the object's type and make sure it has the correct type.
+        It might not in cases where methods do things like 
+        downcast methods. */
+      if (obj != Qnil) {
+        VALUE value = rb_iv_get(obj, "@__swigtype__");
+        const char* type_name = RSTRING_PTR(value);
+				
+        if (strcmp(type->name, type_name) == 0) {
+          return obj;
+        }
+      }
+    }
+
+    /* Create a new Ruby object */
+    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
+			   ( own ? VOIDFUNC(sklass->destroy) : 
+			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
+			     ), ptr);
+
+    /* If tracking is on for this class then track this object. */
+    if (track) {
+      SWIG_RubyAddTracking(ptr, obj);
+    }
+  } else {
+    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+    sprintf(klass_name, "TYPE%s", type->name);
+    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
+    free((void *) klass_name);
+    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
+  }
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  
+  return obj;
+}
+
+/* Create a new class instance (always owned) */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
+{
+  VALUE obj;
+  swig_class *sklass = (swig_class *) type->clientdata;
+  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  return obj;
+}
+
+/* Get type mangle from class name */
+SWIGRUNTIMEINLINE char *
+SWIG_Ruby_MangleStr(VALUE obj)
+{
+  VALUE stype = rb_iv_get(obj, "@__swigtype__");
+  return StringValuePtr(stype);
+}
+
+/* Acquire a pointer value */
+typedef struct {
+  void (*datafree)(void *);
+  int own;
+} swig_ruby_owntype;
+
+SWIGRUNTIME swig_ruby_owntype
+SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
+  swig_ruby_owntype oldown = {0, 0};
+  if (obj) {
+    oldown.datafree = RDATA(obj)->dfree;
+    RDATA(obj)->dfree = own.datafree;
+  }
+  return oldown;
+}
+
+/* Convert a pointer value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
+{
+  char *c;
+  swig_cast_info *tc;
+  void *vptr = 0;
+
+  /* Grab the pointer */
+  if (NIL_P(obj)) {
+    if (ptr)
+      *ptr = 0;
+    return SWIG_OK;
+  } else {
+    if (TYPE(obj) != T_DATA) {
+      return SWIG_ERROR;
+    }
+    Data_Get_Struct(obj, void, vptr);
+  }
+  
+  if (own) {
+    own->datafree = RDATA(obj)->dfree;
+    own->own = 0;
+  }
+    
+  /* Check to see if the input object is giving up ownership
+     of the underlying C struct or C++ object.  If so then we
+     need to reset the destructor since the Ruby object no 
+     longer owns the underlying C++ object.*/ 
+  if (flags & SWIG_POINTER_DISOWN) {
+    /* Is tracking on for this class? */
+    int track = 0;
+    if (ty && ty->clientdata) {
+      swig_class *sklass = (swig_class *) ty->clientdata;
+      track = sklass->trackObjects;
+    }
+		
+    if (track) {
+      /* We are tracking objects for this class.  Thus we change the destructor
+       * to SWIG_RubyRemoveTracking.  This allows us to
+       * remove the mapping from the C++ to Ruby object
+       * when the Ruby object is garbage collected.  If we don't
+       * do this, then it is possible we will return a reference 
+       * to a Ruby object that no longer exists thereby crashing Ruby. */
+      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
+    } else {    
+      RDATA(obj)->dfree = 0;
+    }
+  }
+
+  /* Do type-checking if type info was provided */
+  if (ty) {
+    if (ty->clientdata) {
+      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
+        if (vptr == 0) {
+          /* The object has already been deleted */
+          return SWIG_ObjectPreviouslyDeletedError;
+        }
+      }
+    }
+    if ((c = SWIG_MangleStr(obj)) == NULL) {
+      return SWIG_ERROR;
+    }
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) {
+      return SWIG_ERROR;
+    } else {
+      if (ptr) {
+        if (tc->type == ty) {
+          *ptr = vptr;
+        } else {
+          int newmemory = 0;
+          *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
+          if (newmemory == SWIG_CAST_NEW_MEMORY) {
+            assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+            if (own)
+              own->own = own->own | SWIG_CAST_NEW_MEMORY;
+          }
+        }
+      }
+    }
+  } else {
+    if (ptr)
+      *ptr = vptr;
+  }
+  
+  return SWIG_OK;
+}
+
+/* Check convert */
+SWIGRUNTIMEINLINE int
+SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
+{
+  char *c = SWIG_MangleStr(obj);
+  if (!c) return 0;
+  return SWIG_TypeCheck(c,ty) != 0;
+}
+
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r, ptr, sz);
+  strcpy(r, type->name);
+  return rb_str_new2(result);
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c;
+
+  if (TYPE(obj) != T_STRING) goto type_error;
+  c = StringValuePtr(obj);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') goto type_error;
+  c++;
+  c = SWIG_UnpackData(c, ptr, sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) goto type_error;
+  }
+  return SWIG_OK;
+
+ type_error:
+  return SWIG_ERROR;
+}
+
+SWIGRUNTIME swig_module_info *
+SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
+{
+  VALUE pointer;
+  swig_module_info *ret = 0;
+  VALUE verbose = rb_gv_get("VERBOSE");
+
+ /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
+  rb_gv_set("VERBOSE", Qfalse);
+  
+  /* first check if pointer already created */
+  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  if (pointer != Qnil) {
+    Data_Get_Struct(pointer, swig_module_info, ret);
+  }
+
+  /* reinstate warnings */
+  rb_gv_set("VERBOSE", verbose);
+  return ret;
+}
+
+SWIGRUNTIME void 
+SWIG_Ruby_SetModule(swig_module_info *pointer)
+{
+  /* register a new class */
+  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
+  /* create and store the structure pointer to a global variable */
+  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
+  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
+}
+
+/* This function can be used to check whether a proc or method or similarly
+   callable function has been passed.  Usually used in a %typecheck, like:
+
+   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
+        $result = SWIG_Ruby_isCallable( $input );
+   }
+ */
+SWIGINTERN
+int SWIG_Ruby_isCallable( VALUE proc )
+{
+  if ( rb_respond_to( proc, swig_call_id ) )
+    return 1;
+  return 0;
+}
+
+/* This function can be used to check the arity (number of arguments)
+   a proc or method can take.  Usually used in a %typecheck.
+   Valid arities will be that equal to minimal or those < 0
+   which indicate a variable number of parameters at the end.
+ */
+SWIGINTERN
+int SWIG_Ruby_arity( VALUE proc, int minimal )
+{
+  if ( rb_respond_to( proc, swig_arity_id ) )
+    {
+      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
+      int arity = NUM2INT(num);
+      if ( arity < 0 && (arity+1) < -minimal ) return 1;
+      if ( arity == minimal ) return 1;
+      return 1;
+    }
+  return 0;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
+
+
+
+  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) 
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_p_FXAccelTable swig_types[0]
+#define SWIGTYPE_p_FXApp swig_types[1]
+#define SWIGTYPE_p_FXArrowButton swig_types[2]
+#define SWIGTYPE_p_FXBitmap swig_types[3]
+#define SWIGTYPE_p_FXBitmapFrame swig_types[4]
+#define SWIGTYPE_p_FXCURCursor swig_types[5]
+#define SWIGTYPE_p_FXColorBar swig_types[6]
+#define SWIGTYPE_p_FXColorRing swig_types[7]
+#define SWIGTYPE_p_FXColorWell swig_types[8]
+#define SWIGTYPE_p_FXColorWheel swig_types[9]
+#define SWIGTYPE_p_FXComposite swig_types[10]
+#define SWIGTYPE_p_FXCursor swig_types[11]
+#define SWIGTYPE_p_FXDataTarget swig_types[12]
+#define SWIGTYPE_p_FXDebugTarget swig_types[13]
+#define SWIGTYPE_p_FXDelegator swig_types[14]
+#define SWIGTYPE_p_FXDial swig_types[15]
+#define SWIGTYPE_p_FXDict swig_types[16]
+#define SWIGTYPE_p_FXDocument swig_types[17]
+#define SWIGTYPE_p_FXDrawable swig_types[18]
+#define SWIGTYPE_p_FXFileDict swig_types[19]
+#define SWIGTYPE_p_FXFileStream swig_types[20]
+#define SWIGTYPE_p_FXFont swig_types[21]
+#define SWIGTYPE_p_FXFrame swig_types[22]
+#define SWIGTYPE_p_FXGIFCursor swig_types[23]
+#define SWIGTYPE_p_FXGradient swig_types[24]
+#define SWIGTYPE_p_FXGradientBar swig_types[25]
+#define SWIGTYPE_p_FXHeader swig_types[26]
+#define SWIGTYPE_p_FXHeaderItem swig_types[27]
+#define SWIGTYPE_p_FXHorizontalSeparator swig_types[28]
+#define SWIGTYPE_p_FXIcon swig_types[29]
+#define SWIGTYPE_p_FXIconDict swig_types[30]
+#define SWIGTYPE_p_FXId swig_types[31]
+#define SWIGTYPE_p_FXImage swig_types[32]
+#define SWIGTYPE_p_FXImageFrame swig_types[33]
+#define SWIGTYPE_p_FXKnob swig_types[34]
+#define SWIGTYPE_p_FXMainWindow swig_types[35]
+#define SWIGTYPE_p_FXMemoryStream swig_types[36]
+#define SWIGTYPE_p_FXObject swig_types[37]
+#define SWIGTYPE_p_FXPopup swig_types[38]
+#define SWIGTYPE_p_FXProgressBar swig_types[39]
+#define SWIGTYPE_p_FXRealSlider swig_types[40]
+#define SWIGTYPE_p_FXRecentFiles swig_types[41]
+#define SWIGTYPE_p_FXRegion swig_types[42]
+#define SWIGTYPE_p_FXRegistry swig_types[43]
+#define SWIGTYPE_p_FXRootWindow swig_types[44]
+#define SWIGTYPE_p_FXRuler swig_types[45]
+#define SWIGTYPE_p_FXSeparator swig_types[46]
+#define SWIGTYPE_p_FXSettings swig_types[47]
+#define SWIGTYPE_p_FXShell swig_types[48]
+#define SWIGTYPE_p_FXSlider swig_types[49]
+#define SWIGTYPE_p_FXSplashWindow swig_types[50]
+#define SWIGTYPE_p_FXStatusLine swig_types[51]
+#define SWIGTYPE_p_FXStream swig_types[52]
+#define SWIGTYPE_p_FXStringDict swig_types[53]
+#define SWIGTYPE_p_FXTextField swig_types[54]
+#define SWIGTYPE_p_FXToolBarTab swig_types[55]
+#define SWIGTYPE_p_FXTopWindow swig_types[56]
+#define SWIGTYPE_p_FXTranslator swig_types[57]
+#define SWIGTYPE_p_FXVerticalSeparator swig_types[58]
+#define SWIGTYPE_p_FXVisual swig_types[59]
+#define SWIGTYPE_p_FXWindow swig_types[60]
+#define SWIGTYPE_p_char swig_types[61]
+#define SWIGTYPE_p_double swig_types[62]
+#define SWIGTYPE_p_float swig_types[63]
+#define SWIGTYPE_p_int swig_types[64]
+#define SWIGTYPE_p_long swig_types[65]
+#define SWIGTYPE_p_p_FXGradient swig_types[66]
+#define SWIGTYPE_p_short swig_types[67]
+#define SWIGTYPE_p_unsigned_char swig_types[68]
+#define SWIGTYPE_p_unsigned_int swig_types[69]
+#define SWIGTYPE_p_unsigned_long swig_types[70]
+#define SWIGTYPE_p_unsigned_short swig_types[71]
+static swig_type_info *swig_types[73];
+static swig_module_info swig_module = {swig_types, 72, 0, 0, 0, 0};
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
+
+/* -------- TYPES TABLE (END) -------- */
+
+#define SWIG_init    Init_frames
+#define SWIG_name    "Frames"
+
+
+
+#define SWIG_RUBY_THREAD_BEGIN_BLOCK
+#define SWIG_RUBY_THREAD_END_BLOCK
+
+
+#define SWIGVERSION 0x030012 
+#define SWIG_VERSION SWIGVERSION
+
+
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
+
+
+#include <stdexcept>
+
+
+#include "FXRbCommon.h"
+
+
+inline FXColor to_FXColor(VALUE obj){
+  if(TYPE(obj)==T_STRING){
+    return fxcolorfromname(StringValuePtr(obj));
+    }
+  else if(TYPE(obj)==T_SYMBOL){
+    return fxcolorfromname(rb_id2name(SYM2ID(obj)));
+    }
+  else{
+    return NUM2ULONG(obj);
+    }
+  }
+
+
+inline FXString to_FXString(VALUE obj){
+  if(!NIL_P(obj)){
+    Check_Type(obj,T_STRING);
+    return FXString(StringValuePtr(obj));
+    }
+  else{
+    return FXString::null;
+    }
+  }
+
+
+inline FXbool to_FXbool(VALUE obj){
+  if (obj == Qtrue || obj == Qfalse){
+    return (obj == Qtrue) ? TRUE : FALSE;
+    }
+  else{
+    return static_cast<FXbool>(NUM2UINT(obj));
+    }
+  }
+
+
+static swig_type_info* FXEventTypeInfo=0;
+
+inline void* to_FXEvent(VALUE obj){
+  void* ptr;
+  if(!FXEventTypeInfo){
+    FXEventTypeInfo=SWIG_TypeQuery("FXEvent *");
+    FXASSERT(FXEventTypeInfo!=0);
+    }
+  SWIG_ConvertPtr(obj,&ptr,FXEventTypeInfo,1);
+  return ptr;
+  }
+
+
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
+
+
+  #define SWIG_From_long   LONG2NUM 
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_int  (int value)
+{    
+  return SWIG_From_long  (value);
+}
+
+SWIGINTERN FXArrowButton *new_FXArrowButton(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=ARROW_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbArrowButton(p,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_long  (unsigned long value)
+{
+  return ULONG2NUM(value); 
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_int  (unsigned int value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_bool  (bool value)
+{
+  return value ? Qtrue : Qfalse;
+}
+
+
+SWIGINTERN swig_type_info*
+SWIG_pchar_descriptor(void)
+{
+  static int init = 0;
+  static swig_type_info* info = 0;
+  if (!init) {
+    info = SWIG_TypeQuery("_p_char");
+    init = 1;
+  }
+  return info;
+}
+
+
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
+{
+  if (TYPE(obj) == T_STRING) {
+    char *cstr = StringValuePtr(obj); 
+    size_t size = RSTRING_LEN(obj) + 1;
+    if (cptr)  {
+      if (alloc) {
+	if (*alloc == SWIG_NEWOBJ) {
+	  *cptr = reinterpret_cast< char* >(memcpy(new char[size], cstr, sizeof(char)*(size)));
+	} else {
+	  *cptr = cstr;
+	  *alloc = SWIG_OLDOBJ;
+	}
+      }
+    }
+    if (psize) *psize = size;
+    return SWIG_OK;
+  } else {
+    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+    if (pchar_descriptor) {
+      void* vptr = 0;
+      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
+	if (cptr) *cptr = (char *)vptr;
+	if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
+	if (alloc) *alloc = SWIG_OLDOBJ;
+	return SWIG_OK;
+      }
+    }
+  }  
+  return SWIG_TypeError;
+}
+
+
+
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+  if (carray) {
+    if (size > LONG_MAX) {
+      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+      return pchar_descriptor ? 
+	SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : Qnil;
+    } else {
+      return rb_str_new(carray, static_cast< long >(size));
+    }
+  } else {
+    return Qnil;
+  }
+}
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtr(const char *cptr)
+{ 
+  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
+}
+
+SWIGINTERN FXColorBar *new_FXColorBar(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=FRAME_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbColorBar(p,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+
+#include <float.h>
+
+
+#include <math.h>
+
+
+/* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */
+#ifndef SWIG_isfinite
+/* isfinite() is a macro for C99 */
+# if defined(isfinite)
+#  define SWIG_isfinite(X) (isfinite(X))
+# elif defined __cplusplus && __cplusplus >= 201103L
+/* Use a template so that this works whether isfinite() is std::isfinite() or
+ * in the global namespace.  The reality seems to vary between compiler
+ * versions.
+ *
+ * Make sure namespace std exists to avoid compiler warnings.
+ *
+ * extern "C++" is required as this fragment can end up inside an extern "C" { } block
+ */
+namespace std { }
+extern "C++" template<typename T>
+inline int SWIG_isfinite_func(T x) {
+  using namespace std;
+  return isfinite(x);
+}
+#  define SWIG_isfinite(X) (SWIG_isfinite_func(X))
+# elif defined(_MSC_VER)
+#  define SWIG_isfinite(X) (_finite(X))
+# elif defined(__sun) && defined(__SVR4)
+#  include <ieeefp.h>
+#  define SWIG_isfinite(X) (finite(X))
+# endif
+#endif
+
+
+/* Accept infinite as a valid float value unless we are unable to check if a value is finite */
+#ifdef SWIG_isfinite
+# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX) && SWIG_isfinite(X))
+#else
+# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX))
+#endif
+
+
+SWIGINTERN VALUE
+SWIG_ruby_failed(VALUE, VALUE)
+{
+  return Qnil;
+} 
+
+
+/*@SWIG:/usr/share/swig3.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE pargs){VALUE *args=(VALUE *)pargs;
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  double *res = (double *)(args[1]);
+  *res = NUM2DBL(obj); (void)type;
+  return obj;
+}
+/*@SWIG@*/
+
+SWIGINTERN int
+SWIG_AsVal_double (VALUE obj, double *val)
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FLOAT) || (type == T_FIXNUM) || (type == T_BIGNUM)) {
+    double v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_VALUE_METHOD_FUNC(SWIG_AUX_NUM2DBL), (VALUE)a, RUBY_VALUE_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_float (VALUE obj, float *val)
+{
+  double v;
+  int res = SWIG_AsVal_double (obj, &v);
+  if (SWIG_IsOK(res)) {
+    if (SWIG_Float_Overflow_Check(v)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = static_cast< float >(v);
+    }
+  }  
+  return res;
+}
+
+
+  #define SWIG_From_double   rb_float_new 
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_float  (float value)
+{    
+  return SWIG_From_double  (value);
+}
+
+SWIGINTERN FXColorRing *new_FXColorRing(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=FRAME_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbColorRing(p,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN FXColorWell *new_FXColorWell(FXComposite *p,FXColor clr=0,FXObject *tgt=0,FXSelector sel=0,FXuint opts=COLORWELL_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbColorWell(p,clr,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN FXColorWheel *new_FXColorWheel(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=FRAME_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbColorWheel(p,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN FXDial *new_FXDial(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=DIAL_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbDial(p,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN void FXDial_setRange(FXDial *self,VALUE range,FXbool notify=0){
+      FXint lo,hi;
+      FXRbRange2LoHi(range,lo,hi);
+      self->setRange(lo,hi,notify);
+      }
+SWIGINTERN VALUE FXDial_getRange(FXDial const *self){
+      FXint lo,hi;
+      self->getRange(lo,hi);
+      return rb_range_new(INT2NUM(lo),INT2NUM(hi),0);
+      }
+SWIGINTERN FXHeaderItem *new_FXHeaderItem(FXString const &text,FXIcon *ic=0,FXint s=0,void *ITEMDATA=0){
+      return new FXRbHeaderItem(text,ic,s,ITEMDATA);
+      }
+SWIGINTERN void FXHeaderItem_setData(FXHeaderItem *self,VALUE ptr){
+      self->setData((void*) ptr);
+      }
+SWIGINTERN VALUE FXHeaderItem_getData(FXHeaderItem const *self){
+      return self->getData() ? (VALUE) self->getData() : Qnil;
+      }
+SWIGINTERN FXHeader *new_FXHeader(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=HEADER_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbHeader(p,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN FXint FXHeader_setItem__SWIG_0(FXHeader *self,FXint index,FXHeaderItem *item,FXbool notify=0){
+      // Save pointer to the soon-to-be-destroyed item
+      FXHeaderItem* oldItem=self->getItem(index);
+
+      // Do the deed
+      if(item->isMemberOf(FXMETACLASS(FXRbHeaderItem)))
+	dynamic_cast<FXRbHeaderItem*>(item)->owned=1;
+      FXint result=self->setItem(index,item,notify);
+
+      // Now zero-out pointers held by still-alive Ruby objects
+      FXRbUnregisterRubyObj(oldItem);
+
+      // Done
+      return result;
+    }
+SWIGINTERN FXint FXHeader_setItem__SWIG_1(FXHeader *self,FXint index,FXString const &text,FXIcon *icon=0,FXint size=0,void *ITEMDATA=0,FXbool notify=0){
+      // Save pointer to the soon-to-be-destroyed item
+      FXHeaderItem* oldItem=self->getItem(index);
+
+      // Do the deed
+      FXint result=self->setItem(index,text,icon,size,ITEMDATA,notify);
+
+      // Now zero-out pointers held by still-alive Ruby objects
+      FXRbUnregisterRubyObj(oldItem);
+
+      // Done
+      return result;
+    }
+SWIGINTERN FXint FXHeader_insertItem__SWIG_0(FXHeader *self,FXint index,FXHeaderItem *item,FXbool notify=0){
+      if(item->isMemberOf(FXMETACLASS(FXRbHeaderItem)))
+        dynamic_cast<FXRbHeaderItem*>(item)->owned=1;
+      return self->insertItem(index,item,notify);
+    }
+SWIGINTERN FXint FXHeader_appendItem__SWIG_0(FXHeader *self,FXHeaderItem *item,FXbool notify=0){
+      if(item->isMemberOf(FXMETACLASS(FXRbHeaderItem)))
+        dynamic_cast<FXRbHeaderItem*>(item)->owned=1;
+      return self->appendItem(item,notify);
+    }
+SWIGINTERN FXint FXHeader_prependItem__SWIG_0(FXHeader *self,FXHeaderItem *item,FXbool notify=0){
+      if(item->isMemberOf(FXMETACLASS(FXRbHeaderItem)))
+        dynamic_cast<FXRbHeaderItem*>(item)->owned=1;
+      return self->prependItem(item,notify);
+    }
+SWIGINTERN void FXHeader_removeItem(FXHeader *self,FXint index,FXbool notify=0){
+      // Save pointer to the soon-to-be-destroyed item
+      FXHeaderItem* item=self->getItem(index);
+
+      // Do the deed
+      self->removeItem(index,notify);
+
+      // Now zero-out pointers held by still-alive Ruby objects
+      FXRbUnregisterRubyObj(item);
+      }
+SWIGINTERN void FXHeader_clearItems(FXHeader *self,FXbool notify=0){
+      // Save pointers to the soon-to-be-destroyed items
+      FXObjectListOf<FXHeaderItem> items;
+      for (FXint i = 0; i < self->getNumItems(); i++) items.append(self->getItem(i));
+
+      // Do the deed
+      self->clearItems(notify);
+
+      // Now zero-out pointers held by still-alive Ruby objects
+      for (FXint j = 0; j < items.no(); j++) FXRbUnregisterRubyObj(items[j]);
+      }
+SWIGINTERN void FXHeader_setItemData(FXHeader *self,FXint index,VALUE ptr){
+      self->setItemData(index, (void*) ptr);
+      }
+SWIGINTERN VALUE FXHeader_getItemData(FXHeader const *self,FXint index){
+      return self->getItemData(index) ? (VALUE) self->getItemData(index) : Qnil;
+      }
+SWIGINTERN FXImageFrame *new_FXImageFrame(FXComposite *p,FXImage *img,FXuint opts=FRAME_SUNKEN|FRAME_THICK,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=0,FXint pr=0,FXint pt=0,FXint pb=0){
+      return new FXRbImageFrame(p,img,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN FXBitmapFrame *new_FXBitmapFrame(FXComposite *p,FXBitmap *bmp,FXuint opts=FRAME_SUNKEN|FRAME_THICK,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=0,FXint pr=0,FXint pt=0,FXint pb=0){
+      return new FXRbBitmapFrame(p,bmp,opts,x,y,w,h,pl,pr,pt,pb);
+    }
+SWIGINTERN FXKnob *new_FXKnob(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=KNOB_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbKnob(p,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN void FXKnob_setRange(FXKnob *self,VALUE range,FXbool notify=0){
+      FXint lo,hi;
+      FXRbRange2LoHi(range,lo,hi);
+      self->setRange(lo,hi,notify);
+      }
+SWIGINTERN VALUE FXKnob_getRange(FXKnob const *self){
+      FXint lo,hi;
+      self->getRange(lo,hi);
+      return rb_range_new(INT2NUM(lo),INT2NUM(hi),0);
+      }
+SWIGINTERN FXProgressBar *new_FXProgressBar(FXComposite *p,FXObject *target=0,FXSelector sel=0,FXuint opts=PROGRESSBAR_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbProgressBar(p,target,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN FXRuler *new_FXRuler(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=RULER_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbRuler(p,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN FXSeparator *new_FXSeparator(FXComposite *p,FXuint opts=SEPARATOR_GROOVE|LAYOUT_FILL_X,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=0,FXint pr=0,FXint pt=0,FXint pb=0){
+      return new FXRbSeparator(p,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+
+static swig_type_info *FXSeparator_dynamic_cast(void **ptr) {
+    FXSeparator **ppSeparator = reinterpret_cast<FXSeparator **>(ptr);
+    FXHorizontalSeparator *pHorizontalSeparator=dynamic_cast<FXHorizontalSeparator*>(*ppSeparator);
+    if(pHorizontalSeparator){
+      *ptr=reinterpret_cast<void*>(pHorizontalSeparator);
+      return SWIG_TypeQuery("FXHorizontalSeparator *");
+      }
+    FXVerticalSeparator *pVerticalSeparator=dynamic_cast<FXVerticalSeparator*>(*ppSeparator);
+    if(pVerticalSeparator){
+      *ptr=reinterpret_cast<void*>(pVerticalSeparator);
+      return SWIG_TypeQuery("FXVerticalSeparator *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXHorizontalSeparator *new_FXHorizontalSeparator(FXComposite *p,FXuint opts=SEPARATOR_GROOVE|LAYOUT_FILL_X,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=1,FXint pr=1,FXint pt=0,FXint pb=0){
+      return new FXRbHorizontalSeparator(p,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN FXVerticalSeparator *new_FXVerticalSeparator(FXComposite *p,FXuint opts=SEPARATOR_GROOVE|LAYOUT_FILL_Y,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=0,FXint pr=0,FXint pt=1,FXint pb=1){
+      return new FXRbVerticalSeparator(p,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN FXSlider *new_FXSlider(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=SLIDER_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=0,FXint pr=0,FXint pt=0,FXint pb=0){
+      return new FXRbSlider(p,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN void FXSlider_setRange(FXSlider *self,VALUE range,FXbool notify=0){
+      FXint lo,hi;
+      FXRbRange2LoHi(range,lo,hi);
+      self->setRange(lo,hi,notify);
+      }
+SWIGINTERN VALUE FXSlider_getRange(FXSlider const *self){
+      FXint lo,hi;
+      self->getRange(lo,hi);
+      return rb_range_new(INT2NUM(lo),INT2NUM(hi),0);
+      }
+SWIGINTERN FXRealSlider *new_FXRealSlider(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=REALSLIDER_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=0,FXint pr=0,FXint pt=0,FXint pb=0){
+      return new FXRbRealSlider(p,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN VALUE FXRealSlider_getRange(FXRealSlider const *self){
+      FXdouble lo,hi;
+      self->getRange(lo,hi);
+      return rb_ary_new3(2,rb_float_new(lo),rb_float_new(hi));
+      }
+SWIGINTERN FXStatusLine *new_FXStatusLine(FXComposite *p,FXObject *tgt=0,FXSelector sel=0){
+      return new FXRbStatusLine(p,tgt,sel);
+      }
+SWIGINTERN FXTextField *new_FXTextField(FXComposite *p,FXint ncols,FXObject *tgt=0,FXSelector sel=0,FXuint opts=TEXTFIELD_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbTextField(p,ncols,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN FXToolBarTab *new_FXToolBarTab(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=FRAME_RAISED,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+     return new FXRbToolBarTab(p,tgt,sel,opts,x,y,w,h);
+     }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_char  (unsigned char value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+SWIGINTERN FXGradientBar *new_FXGradientBar(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=FRAME_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbGradientBar(p,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN FXbool FXGradientBar_selectSegments(FXGradientBar *self,FXint fm,FXint to,FXbool notify=0){
+      if(fm>to){
+        rb_raise(rb_eArgError,"'from' index is greater than 'to' index");
+        }
+      if(fm<0 || to>=self->getNumSegments()){
+        rb_raise(rb_eIndexError,"segment index out of bounds");
+        }
+      return self->selectSegments(fm,to,notify);
+      }
+SWIGINTERN VALUE FXGradientBar_gradient(FXGradientBar *self,FXint nramp){
+      FXColor* ramp;
+      VALUE ary;
+      FXint i;
+      if(nramp>0){
+        if(FXMALLOC(&ramp,FXColor,nramp)){
+          self->gradient(ramp,nramp);
+          ary=rb_ary_new2(nramp);
+          for(i=0; i<nramp; i++){
+            rb_ary_store(ary,i,to_ruby(ramp[i]));
+          }
+          FXFREE(&ramp);
+          return ary;
+        }else{
+          rb_raise(rb_eNoMemError,"Out of memory");
+        }
+      }
+      else{
+        return rb_ary_new();
+      }
+    }
+static swig_class SwigClassFXArrowButton;
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_onUpdate(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","onUpdate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdate", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdate(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_onEnter(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","onEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_onLeave(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","onLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_onRepeat(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","onRepeat", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRepeat", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onRepeat(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_onAuto(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","onAuto", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onAuto", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onAuto(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_onHotKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","onHotKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_onHotKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","onHotKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_onCmdSetHelp(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","onCmdSetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_onCmdGetHelp(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","onCmdGetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_onCmdSetTip(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","onCmdSetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_onCmdGetTip(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","onCmdGetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXArrowButton_allocate(VALUE self)
+#else
+_wrap_FXArrowButton_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXArrowButton);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXArrowButton(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) ARROW_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) DEFAULT_PAD ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXArrowButton *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXArrowButton", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXArrowButton", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXArrowButton *)new_FXArrowButton(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_setState(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","setState", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->setState(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_getState(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton const *","getState", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  result = (FXbool)((FXArrowButton const *)arg1)->getState();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  result = (FXString *) &((FXArrowButton const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_setTipText(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_getTipText(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  result = (FXString *) &((FXArrowButton const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_setArrowStyle(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","setArrowStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setArrowStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_getArrowStyle(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton const *","getArrowStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  result = (FXuint)((FXArrowButton const *)arg1)->getArrowStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_setArrowSize(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","setArrowSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setArrowSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_getArrowSize(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton const *","getArrowSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  result = (FXint)((FXArrowButton const *)arg1)->getArrowSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_setJustify(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","setJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setJustify(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_getJustify(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton const *","getJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  result = (FXuint)((FXArrowButton const *)arg1)->getJustify();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_getArrowColor(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton const *","getArrowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  result = (FXColor)((FXArrowButton const *)arg1)->getArrowColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_setArrowColor(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","setArrowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setArrowColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_save(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXArrowButton_save((FXArrowButton const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_load(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXArrowButton_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_create(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  FXArrowButton_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_detach(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  FXArrowButton_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_destroy(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  FXArrowButton_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_resize(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXArrowButton_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  result = (FXint)FXArrowButton_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  result = (FXint)FXArrowButton_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXArrowButton_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXArrowButton_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  result = (bool)FXArrowButton_canFocus((FXArrowButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  FXArrowButton_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  FXArrowButton_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXArrowButton_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXArrowButton_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_enable(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  FXArrowButton_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_disable(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  FXArrowButton_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  FXArrowButton_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_lower(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  FXArrowButton_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_move(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXArrowButton_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_position(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXArrowButton_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_layout(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  FXArrowButton_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_recalc(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  FXArrowButton_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_reparent(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXArrowButton_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_show(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  FXArrowButton_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_hide(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  FXArrowButton_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  result = (bool)FXArrowButton_isComposite((FXArrowButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_contains(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXArrowButton_contains((FXArrowButton const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  result = (bool)FXArrowButton_doesSaveUnder((FXArrowButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXArrowButton_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_tr(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXArrowButton_tr((FXArrowButton const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  FXArrowButton_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  FXArrowButton_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXArrowButton_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXArrowButton_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXArrowButton_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXArrowButton_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXArrowButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXArrowButton_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXArrowButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXArrowButton_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXArrowButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXArrowButton_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXArrowButton_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXArrowButton *arg1 = (FXArrowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXArrowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXArrowButton *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXArrowButton * >(argp1);
+  FXArrowButton_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXColorBar;
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_onCmdSetHelp(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","onCmdSetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_onCmdGetHelp(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","onCmdGetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_onCmdSetTip(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","onCmdSetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_onCmdGetTip(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","onCmdGetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXColorBar_allocate(VALUE self)
+#else
+_wrap_FXColorBar_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXColorBar);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXColorBar(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) FRAME_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) DEFAULT_PAD ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXColorBar *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXColorBar", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXColorBar", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXColorBar *)new_FXColorBar(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_setHue(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","setHue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","setHue", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  (arg1)->setHue(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_getHue(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar const *","getHue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  result = (FXfloat)((FXColorBar const *)arg1)->getHue();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_setSat(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","setSat", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","setSat", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  (arg1)->setSat(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_getSat(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar const *","getSat", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  result = (FXfloat)((FXColorBar const *)arg1)->getSat();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_setVal(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","setVal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","setVal", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  (arg1)->setVal(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_getVal(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar const *","getVal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  result = (FXfloat)((FXColorBar const *)arg1)->getVal();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_getBarStyle(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar const *","getBarStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  result = (FXuint)((FXColorBar const *)arg1)->getBarStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_setBarStyle(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","setBarStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setBarStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  result = (FXString *) &((FXColorBar const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_setTipText(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_getTipText(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  result = (FXString *) &((FXColorBar const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_save(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXColorBar_save((FXColorBar const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_load(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXColorBar_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_create(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  FXColorBar_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_detach(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  FXColorBar_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_destroy(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  FXColorBar_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_resize(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXColorBar_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  result = (FXint)FXColorBar_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  result = (FXint)FXColorBar_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXColorBar_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXColorBar_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  result = (bool)FXColorBar_canFocus((FXColorBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  FXColorBar_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  FXColorBar_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXColorBar_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXColorBar_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_enable(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  FXColorBar_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_disable(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  FXColorBar_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  FXColorBar_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_lower(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  FXColorBar_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_move(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXColorBar_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_position(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXColorBar_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_layout(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  FXColorBar_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_recalc(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  FXColorBar_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_reparent(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXColorBar_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_show(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  FXColorBar_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_hide(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  FXColorBar_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  result = (bool)FXColorBar_isComposite((FXColorBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_contains(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXColorBar_contains((FXColorBar const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  result = (bool)FXColorBar_doesSaveUnder((FXColorBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXColorBar_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_tr(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXColorBar_tr((FXColorBar const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  FXColorBar_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  FXColorBar_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXColorBar_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXColorBar_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXColorBar_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXColorBar_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXColorBar_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXColorBar_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXColorBar_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorBar_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXColorBar *arg1 = (FXColorBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorBar *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorBar * >(argp1);
+  FXColorBar_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXColorRing;
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_onMouseWheel(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing *","onMouseWheel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMouseWheel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMouseWheel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_onCmdSetHelp(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing *","onCmdSetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_onCmdGetHelp(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing *","onCmdGetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_onCmdSetTip(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing *","onCmdSetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_onCmdGetTip(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing *","onCmdGetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXColorRing_allocate(VALUE self)
+#else
+_wrap_FXColorRing_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXColorRing);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXColorRing(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) FRAME_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) DEFAULT_PAD ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXColorRing *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXColorRing", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXColorRing", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXColorRing *)new_FXColorRing(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_huee___(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing *","setHue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","setHue", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  (arg1)->setHue(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_hue(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing const *","getHue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  result = (FXfloat)((FXColorRing const *)arg1)->getHue();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_sate___(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing *","setSat", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","setSat", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  (arg1)->setSat(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_sat(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing const *","getSat", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  result = (FXfloat)((FXColorRing const *)arg1)->getSat();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_vale___(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing *","setVal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","setVal", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  (arg1)->setVal(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_val(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing const *","getVal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  result = (FXfloat)((FXColorRing const *)arg1)->getVal();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_setHueSatVal(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  FXfloat arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing *","setHueSatVal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","setHueSatVal", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","setHueSatVal", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  ecode4 = SWIG_AsVal_float(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","setHueSatVal", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXfloat >(val4);
+  (arg1)->setHueSatVal(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_ringWidthe___(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing *","setRingWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setRingWidth(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_ringWidth(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing const *","getRingWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  result = (FXint)((FXColorRing const *)arg1)->getRingWidth();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_helpTexte___(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_helpText(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  result = (FXString *) &((FXColorRing const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_tipTexte___(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorRing_tipText(int argc, VALUE *argv, VALUE self) {
+  FXColorRing *arg1 = (FXColorRing *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorRing, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorRing const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorRing * >(argp1);
+  result = (FXString *) &((FXColorRing const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXColorWell;
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onMiddleBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onMiddleBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMiddleBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMiddleBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onMiddleBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onMiddleBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMiddleBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMiddleBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onBeginDrag(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onBeginDrag", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onBeginDrag", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onBeginDrag(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onEndDrag(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onEndDrag", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEndDrag", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEndDrag(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onDragged(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onDragged", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDragged", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDragged(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onFocusIn(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onFocusIn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusIn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusIn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onFocusOut(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onFocusOut", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusOut", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusOut(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onDNDEnter(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onDNDEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onDNDLeave(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onDNDLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onDNDMotion(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onDNDMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onDNDDrop(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onDNDDrop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDDrop", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDDrop(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onDNDRequest(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onDNDRequest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDRequest", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDRequest(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onSelectionLost(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onSelectionLost", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSelectionLost", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onSelectionLost(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onSelectionGained(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onSelectionGained", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSelectionGained", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onSelectionGained(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onSelectionRequest(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onSelectionRequest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSelectionRequest", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onSelectionRequest(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onClicked(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onDoubleClicked(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onDoubleClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDoubleClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onDoubleClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2UINT(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onCmdColorWell(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onCmdColorWell", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdColorWell", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2UINT(argv[2]));
+  result = (long)(arg1)->onCmdColorWell(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onChgColorWell(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onChgColorWell", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onChgColorWell", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2UINT(argv[2]));
+  result = (long)(arg1)->onChgColorWell(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onCmdSetHelp(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onCmdSetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onCmdGetHelp(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onCmdGetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onCmdSetTip(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onCmdSetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onCmdGetTip(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onCmdGetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXColorWell_allocate(VALUE self)
+#else
+_wrap_FXColorWell_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXColorWell);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXColorWell(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXColor arg2 = (FXColor) 0 ;
+  FXObject *arg3 = (FXObject *) 0 ;
+  FXSelector arg4 = (FXSelector) 0 ;
+  FXuint arg5 = (FXuint) COLORWELL_NORMAL ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  FXint arg13 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXColorWell *result = 0 ;
+  
+  if ((argc < 1) || (argc > 13)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXColorWell", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    arg2 = to_FXColor(argv[1]);
+  }
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXObject *","FXColorWell", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXObject * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXColorWell *)new_FXColorWell(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_setRGBA(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXColor arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","setRGBA", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setRGBA(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_getRGBA(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell const *","getRGBA", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  result = (FXColor)((FXColorWell const *)arg1)->getRGBA();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  result = (FXString *) &((FXColorWell const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_setTipText(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_getTipText(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  result = (FXString *) &((FXColorWell const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_isOpaqueOnly(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell const *","isOpaqueOnly", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  result = (FXbool)((FXColorWell const *)arg1)->isOpaqueOnly();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_setOpaqueOnly(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","setOpaqueOnly", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->setOpaqueOnly(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_save(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXColorWell_save((FXColorWell const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_load(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXColorWell_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_create(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  FXColorWell_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_detach(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  FXColorWell_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_destroy(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  FXColorWell_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_resize(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXColorWell_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  result = (FXint)FXColorWell_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  result = (FXint)FXColorWell_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXColorWell_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXColorWell_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  result = (bool)FXColorWell_canFocus((FXColorWell const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  FXColorWell_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  FXColorWell_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXColorWell_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXColorWell_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_enable(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  FXColorWell_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_disable(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  FXColorWell_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  FXColorWell_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_lower(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  FXColorWell_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_move(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXColorWell_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_position(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXColorWell_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_layout(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  FXColorWell_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_recalc(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  FXColorWell_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_reparent(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXColorWell_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_show(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  FXColorWell_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_hide(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  FXColorWell_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  result = (bool)FXColorWell_isComposite((FXColorWell const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_contains(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXColorWell_contains((FXColorWell const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  result = (bool)FXColorWell_doesSaveUnder((FXColorWell const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXColorWell_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_tr(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXColorWell_tr((FXColorWell const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  FXColorWell_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  FXColorWell_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXColorWell_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXColorWell_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXColorWell_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXColorWell_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorWell, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXColorWell_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorWell, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXColorWell_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorWell, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXColorWell_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWell_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXColorWell *arg1 = (FXColorWell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWell *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWell * >(argp1);
+  FXColorWell_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXColorWheel;
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_onMouseWheel(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","onMouseWheel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMouseWheel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMouseWheel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_onCmdSetHelp(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","onCmdSetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_onCmdGetHelp(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","onCmdGetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_onCmdSetTip(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","onCmdSetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_onCmdGetTip(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","onCmdGetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXColorWheel_allocate(VALUE self)
+#else
+_wrap_FXColorWheel_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXColorWheel);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXColorWheel(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) FRAME_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) DEFAULT_PAD ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXColorWheel *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXColorWheel", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXColorWheel", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXColorWheel *)new_FXColorWheel(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_setHue(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","setHue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","setHue", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  (arg1)->setHue(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_getHue(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel const *","getHue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  result = (FXfloat)((FXColorWheel const *)arg1)->getHue();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_setSat(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","setSat", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","setSat", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  (arg1)->setSat(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_getSat(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel const *","getSat", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  result = (FXfloat)((FXColorWheel const *)arg1)->getSat();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_setVal(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","setVal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","setVal", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  (arg1)->setVal(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_getVal(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel const *","getVal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  result = (FXfloat)((FXColorWheel const *)arg1)->getVal();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_setHueSatVal(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  FXfloat arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","setHueSatVal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","setHueSatVal", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","setHueSatVal", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  ecode4 = SWIG_AsVal_float(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","setHueSatVal", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXfloat >(val4);
+  (arg1)->setHueSatVal(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  result = (FXString *) &((FXColorWheel const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_setTipText(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_getTipText(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  result = (FXString *) &((FXColorWheel const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_save(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXColorWheel_save((FXColorWheel const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_load(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXColorWheel_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_create(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  FXColorWheel_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_detach(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  FXColorWheel_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_destroy(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  FXColorWheel_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_resize(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXColorWheel_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  result = (FXint)FXColorWheel_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  result = (FXint)FXColorWheel_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXColorWheel_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXColorWheel_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  result = (bool)FXColorWheel_canFocus((FXColorWheel const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  FXColorWheel_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  FXColorWheel_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXColorWheel_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXColorWheel_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_enable(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  FXColorWheel_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_disable(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  FXColorWheel_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  FXColorWheel_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_lower(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  FXColorWheel_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_move(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXColorWheel_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_position(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXColorWheel_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_layout(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  FXColorWheel_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_recalc(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  FXColorWheel_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_reparent(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXColorWheel_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_show(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  FXColorWheel_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_hide(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  FXColorWheel_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  result = (bool)FXColorWheel_isComposite((FXColorWheel const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_contains(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXColorWheel_contains((FXColorWheel const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  result = (bool)FXColorWheel_doesSaveUnder((FXColorWheel const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXColorWheel_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_tr(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXColorWheel_tr((FXColorWheel const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  FXColorWheel_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  FXColorWheel_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXColorWheel_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXColorWheel_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXColorWheel_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXColorWheel_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorWheel, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXColorWheel_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorWheel, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXColorWheel_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorWheel, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXColorWheel_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorWheel_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXColorWheel *arg1 = (FXColorWheel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorWheel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorWheel *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorWheel * >(argp1);
+  FXColorWheel_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXDial;
+
+SWIGINTERN VALUE
+_wrap_FXDial_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_onMouseWheel(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","onMouseWheel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMouseWheel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMouseWheel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXint) NUM2INT(argv[2]);
+    arg4 = static_cast<void*>(&value4);
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_onCmdSetRealValue(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXdouble value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","onCmdSetRealValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetRealValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXdouble) NUM2DBL(argv[2]);
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetRealValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_onCmdGetRealValue(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","onCmdGetRealValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetRealValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetRealValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_onCmdSetIntRange(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint values4[2] ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","onCmdSetIntRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    Check_Type(argv[2], T_ARRAY);
+    values4[0] = (FXint) NUM2INT(rb_ary_entry(argv[2], 0));
+    values4[1] = (FXint) NUM2INT(rb_ary_entry(argv[2], 1));
+    arg4 = static_cast<void*>(values4);
+  }
+  result = (long)(arg1)->onCmdSetIntRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_onCmdGetIntRange(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","onCmdGetIntRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetIntRange", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetIntRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_onCmdSetRealRange(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXdouble values4[2] ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","onCmdSetRealRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetRealRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    Check_Type(argv[2], T_ARRAY);
+    values4[0] = (FXdouble) NUM2DBL(rb_ary_entry(argv[2], 0));
+    values4[1] = (FXdouble) NUM2DBL(rb_ary_entry(argv[2], 1));
+    arg4 = (void *) values4;
+  }
+  result = (long)(arg1)->onCmdSetRealRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_onCmdGetRealRange(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","onCmdGetRealRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetRealRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetRealRange", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetRealRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_onCmdSetHelp(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","onCmdSetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_onCmdGetHelp(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","onCmdGetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_onCmdSetTip(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","onCmdSetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_onCmdGetTip(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","onCmdGetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXDial_allocate(VALUE self)
+#else
+_wrap_FXDial_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXDial);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXDial(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) DIAL_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) DEFAULT_PAD ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXDial *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXDial", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXDial", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXDial *)new_FXDial(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_setValue(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","setValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setValue(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_getValue(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial const *","getValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  result = (FXint)((FXDial const *)arg1)->getValue();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_setRange(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","setRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  arg2 = argv[0];
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXDial_setRange(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_getRange(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial const *","getRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  result = (VALUE)FXDial_getRange((FXDial const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_setRevolutionIncrement(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","setRevolutionIncrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setRevolutionIncrement(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_getRevolutionIncrement(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial const *","getRevolutionIncrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  result = (FXint)((FXDial const *)arg1)->getRevolutionIncrement();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_setNotchSpacing(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","setNotchSpacing", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setNotchSpacing(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_getNotchSpacing(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial const *","getNotchSpacing", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  result = (FXint)((FXDial const *)arg1)->getNotchSpacing();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_setNotchOffset(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","setNotchOffset", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setNotchOffset(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_getNotchOffset(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial const *","getNotchOffset", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  result = (FXint)((FXDial const *)arg1)->getNotchOffset();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_setDialStyle(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","setDialStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setDialStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_getDialStyle(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial const *","getDialStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  result = (FXuint)((FXDial const *)arg1)->getDialStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_setNotchColor(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","setNotchColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setNotchColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_getNotchColor(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial const *","getNotchColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  result = (FXColor)((FXDial const *)arg1)->getNotchColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  result = (FXString *) &((FXDial const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_setTipText(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_getTipText(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  result = (FXString *) &((FXDial const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_save(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDial_save((FXDial const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_load(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDial_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_create(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  FXDial_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_detach(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  FXDial_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_destroy(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  FXDial_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_resize(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDial_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  result = (FXint)FXDial_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  result = (FXint)FXDial_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDial_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDial_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  result = (bool)FXDial_canFocus((FXDial const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  FXDial_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  FXDial_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXDial_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXDial_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_enable(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  FXDial_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_disable(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  FXDial_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  FXDial_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_lower(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  FXDial_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_move(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDial_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_position(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDial_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_layout(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  FXDial_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_recalc(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  FXDial_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_reparent(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXDial_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_show(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  FXDial_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_hide(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  FXDial_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  result = (bool)FXDial_isComposite((FXDial const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_contains(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXDial_contains((FXDial const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  result = (bool)FXDial_doesSaveUnder((FXDial const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXDial_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_tr(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXDial_tr((FXDial const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  FXDial_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  FXDial_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXDial_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXDial_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXDial_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDial_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDial, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDial_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDial, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDial_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDial, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDial_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDial_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXDial *arg1 = (FXDial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDial *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDial * >(argp1);
+  FXDial_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXHeaderItem;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXHeaderItem_allocate(VALUE self)
+#else
+_wrap_FXHeaderItem_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXHeaderItem);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXHeaderItem(int argc, VALUE *argv, VALUE self) {
+  FXString *arg1 = 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXint arg3 = (FXint) 0 ;
+  void *arg4 = (void *) 0 ;
+  SwigValueWrapper< FXString > p1 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXHeaderItem *result = 0 ;
+  
+  if ((argc < 1) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  p1 = to_FXString(argv[0]); arg1 = &p1;
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","FXHeaderItem", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXIcon * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = (argv[3] == Qnil) ? NULL : (void *) argv[3];
+  }
+  {
+    result = (FXHeaderItem *)new_FXHeaderItem((FXString const &)*arg1,arg2,arg3,arg4);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_getText(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem const *","getText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  result = (FXString *) &((FXHeaderItem const *)arg1)->getText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_getIcon(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem const *","getIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  result = (FXIcon *)((FXHeaderItem const *)arg1)->getIcon();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_setData(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem *","setData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  arg2 = argv[0];
+  FXHeaderItem_setData(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_getData(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem const *","getData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  result = (VALUE)FXHeaderItem_getData((FXHeaderItem const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_setSize(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem *","setSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_getSize(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem const *","getSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  result = (FXint)((FXHeaderItem const *)arg1)->getSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_setPos(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem *","setPos", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setPos(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_getPos(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem const *","getPos", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  result = (FXint)((FXHeaderItem const *)arg1)->getPos();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_setArrowDir(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  FXuint arg2 = (FXuint) 2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem *","setArrowDir", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  (arg1)->setArrowDir(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_getArrowDir(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem const *","getArrowDir", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  result = (FXuint)((FXHeaderItem const *)arg1)->getArrowDir();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_setJustify(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  FXuint arg2 = (FXuint) FXHeaderItem::LEFT|FXHeaderItem::CENTER_Y ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem *","setJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  (arg1)->setJustify(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_getJustify(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem const *","getJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  result = (FXuint)((FXHeaderItem const *)arg1)->getJustify();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_setIconPosition(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  FXuint arg2 = (FXuint) FXHeaderItem::BEFORE ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem *","setIconPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  (arg1)->setIconPosition(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_getIconPosition(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem const *","getIconPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  result = (FXuint)((FXHeaderItem const *)arg1)->getIconPosition();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_setPressed(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem *","setPressed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->setPressed(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_isPressed(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem const *","isPressed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  result = (FXbool)((FXHeaderItem const *)arg1)->isPressed();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_save(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXHeaderItem_save((FXHeaderItem const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_load(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXHeaderItem_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_setText(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem *","setText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  FXHeaderItem_setText(arg1,(FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_setIcon(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem *","setIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXHeaderItem_setIcon(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_getWidth(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  FXHeader *arg2 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem const *","getWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXHeader const *","getWidth", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXHeader * >(argp2);
+  result = (FXint)FXHeaderItem_getWidth((FXHeaderItem const *)arg1,(FXHeader const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_getHeight(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  FXHeader *arg2 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem const *","getHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXHeader const *","getHeight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXHeader * >(argp2);
+  result = (FXint)FXHeaderItem_getHeight((FXHeaderItem const *)arg1,(FXHeader const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_create(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  FXHeaderItem_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_detach(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  FXHeaderItem_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeaderItem_destroy(int argc, VALUE *argv, VALUE self) {
+  FXHeaderItem *arg1 = (FXHeaderItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeaderItem *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeaderItem * >(argp1);
+  FXHeaderItem_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXHeader;
+
+SWIGINTERN VALUE
+_wrap_FXHeader_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_onTipTimer(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","onTipTimer", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTipTimer", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onTipTimer(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXHeader_allocate(VALUE self)
+#else
+_wrap_FXHeader_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXHeader);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXHeader(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) HEADER_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) DEFAULT_PAD ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXHeader *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXHeader", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXHeader", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXHeader *)new_FXHeader(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_getNumItems(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getNumItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  result = (FXint)((FXHeader const *)arg1)->getNumItems();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_getTotalSize(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getTotalSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  result = (FXint)((FXHeader const *)arg1)->getTotalSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_setPosition(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setPosition(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_getPosition(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  result = (FXint)((FXHeader const *)arg1)->getPosition();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_getItem(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXHeaderItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  result = (FXHeaderItem *)((FXHeader const *)arg1)->getItem(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXHeaderItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_getItemAt(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getItemAt", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)((FXHeader const *)arg1)->getItemAt(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_setItem__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  FXHeaderItem *arg3 = (FXHeaderItem *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXHeaderItem *","setItem", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXHeaderItem * >(argp3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  result = (FXint)FXHeader_setItem__SWIG_0(arg1,arg2,arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_setItem__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  void *arg6 = (void *) 0 ;
+  FXbool arg7 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  if (argc > 2) {
+    res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","setItem", 4, argv[2] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 3) {
+    arg5 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg6 = (argv[4] == Qnil) ? NULL : (void *) argv[4];
+  }
+  if (argc > 5) {
+    arg7 = to_FXbool(argv[5]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  result = (FXint)FXHeader_setItem__SWIG_1(arg1,arg2,(FXString const &)*arg3,arg4,arg5,arg6,arg7);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXHeader_setItem(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[8];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 8) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 3) && (argc <= 4)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHeader, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXHeaderItem, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXHeader_setItem__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (argv[3] == Qtrue || argv[3] == Qfalse) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_FXHeader_setItem__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 3) && (argc <= 7)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHeader, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXHeader_setItem__SWIG_1(nargs, args, self);
+          }
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXHeader_setItem__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_FXHeader_setItem__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = 1;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_FXHeader_setItem__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (argv[6] == Qtrue || argv[6] == Qfalse) ? 1 : 0;
+                }
+                if (_v) {
+                  return _wrap_FXHeader_setItem__SWIG_1(nargs, args, self);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 8, "setItem", 
+    "    FXint setItem(FXint index, FXHeaderItem *item, FXbool notify)\n"
+    "    FXint setItem(FXint index, FXString const &text, FXIcon *icon, FXint size, void *ITEMDATA, FXbool notify)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_fillItems(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXchar **arg2 = (FXchar **) 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  void *arg5 = (void *) 0 ;
+  FXbool arg6 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","fillItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  {
+    arg2 = NULL;
+    if(!NIL_P(argv[0])){
+      Check_Type(argv[0], T_ARRAY);
+      if (FXMALLOC(&arg2, FXchar *, RARRAY_LEN(argv[0])+1)) {
+        for (long i = 0; i < RARRAY_LEN(argv[0]); i++) {
+          VALUE e = rb_ary_entry(argv[0], i);
+          arg2[i] = (FXchar *) StringValuePtr(e);
+        }
+        arg2[RARRAY_LEN(argv[0])] = 0;
+      }
+    }
+  }
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","fillItems", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg5 = (argv[3] == Qnil) ? NULL : (void *) argv[3];
+  }
+  if (argc > 4) {
+    arg6 = to_FXbool(argv[4]);
+  }
+  result = (FXint)(arg1)->fillItems((FXchar const **)arg2,arg3,arg4,arg5,arg6);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  FXFREE(&arg2);
+  return vresult;
+fail:
+  FXFREE(&arg2);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_insertItem__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  FXHeaderItem *arg3 = (FXHeaderItem *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","insertItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXHeaderItem *","insertItem", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXHeaderItem * >(argp3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  result = (FXint)FXHeader_insertItem__SWIG_0(arg1,arg2,arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_insertItem__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  void *arg6 = (void *) 0 ;
+  FXbool arg7 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","insertItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  if (argc > 2) {
+    res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","insertItem", 4, argv[2] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 3) {
+    arg5 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg6 = (argv[4] == Qnil) ? NULL : (void *) argv[4];
+  }
+  if (argc > 5) {
+    arg7 = to_FXbool(argv[5]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  result = (FXint)(arg1)->insertItem(arg2,(FXString const &)*arg3,arg4,arg5,arg6,arg7);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXHeader_insertItem(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[8];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 8) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 3) && (argc <= 4)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHeader, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXHeaderItem, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXHeader_insertItem__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (argv[3] == Qtrue || argv[3] == Qfalse) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_FXHeader_insertItem__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 3) && (argc <= 7)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHeader, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXHeader_insertItem__SWIG_1(nargs, args, self);
+          }
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXHeader_insertItem__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_FXHeader_insertItem__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = 1;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_FXHeader_insertItem__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (argv[6] == Qtrue || argv[6] == Qfalse) ? 1 : 0;
+                }
+                if (_v) {
+                  return _wrap_FXHeader_insertItem__SWIG_1(nargs, args, self);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 8, "insertItem", 
+    "    FXint insertItem(FXint index, FXHeaderItem *item, FXbool notify)\n"
+    "    FXint insertItem(FXint index, FXString const &text, FXIcon *icon, FXint size, void *ITEMDATA, FXbool notify)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_appendItem__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXHeaderItem *arg2 = (FXHeaderItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","appendItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXHeaderItem *","appendItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXHeaderItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXint)FXHeader_appendItem__SWIG_0(arg1,arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_appendItem__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  void *arg5 = (void *) 0 ;
+  FXbool arg6 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","appendItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","appendItem", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg5 = (argv[3] == Qnil) ? NULL : (void *) argv[3];
+  }
+  if (argc > 4) {
+    arg6 = to_FXbool(argv[4]);
+  }
+  result = (FXint)(arg1)->appendItem((FXString const &)*arg2,arg3,arg4,arg5,arg6);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXHeader_appendItem(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[7];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 7) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 2) && (argc <= 3)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHeader, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXHeaderItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_FXHeader_appendItem__SWIG_0(nargs, args, self);
+        }
+        {
+          _v = (argv[2] == Qtrue || argv[2] == Qfalse) ? 1 : 0;
+        }
+        if (_v) {
+          return _wrap_FXHeader_appendItem__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  if ((argc >= 2) && (argc <= 6)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHeader, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_FXHeader_appendItem__SWIG_1(nargs, args, self);
+        }
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXIcon, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXHeader_appendItem__SWIG_1(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXHeader_appendItem__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = 1;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_FXHeader_appendItem__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = (argv[5] == Qtrue || argv[5] == Qfalse) ? 1 : 0;
+              }
+              if (_v) {
+                return _wrap_FXHeader_appendItem__SWIG_1(nargs, args, self);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 7, "appendItem", 
+    "    FXint appendItem(FXHeaderItem *item, FXbool notify)\n"
+    "    FXint appendItem(FXString const &text, FXIcon *icon, FXint size, void *ITEMDATA, FXbool notify)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_prependItem__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXHeaderItem *arg2 = (FXHeaderItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","prependItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXHeaderItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXHeaderItem *","prependItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXHeaderItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXint)FXHeader_prependItem__SWIG_0(arg1,arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_prependItem__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  void *arg5 = (void *) 0 ;
+  FXbool arg6 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","prependItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","prependItem", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg5 = (argv[3] == Qnil) ? NULL : (void *) argv[3];
+  }
+  if (argc > 4) {
+    arg6 = to_FXbool(argv[4]);
+  }
+  result = (FXint)(arg1)->prependItem((FXString const &)*arg2,arg3,arg4,arg5,arg6);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXHeader_prependItem(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[7];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 7) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 2) && (argc <= 3)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHeader, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXHeaderItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_FXHeader_prependItem__SWIG_0(nargs, args, self);
+        }
+        {
+          _v = (argv[2] == Qtrue || argv[2] == Qfalse) ? 1 : 0;
+        }
+        if (_v) {
+          return _wrap_FXHeader_prependItem__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  if ((argc >= 2) && (argc <= 6)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHeader, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_FXHeader_prependItem__SWIG_1(nargs, args, self);
+        }
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXIcon, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXHeader_prependItem__SWIG_1(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXHeader_prependItem__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = 1;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_FXHeader_prependItem__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = (argv[5] == Qtrue || argv[5] == Qfalse) ? 1 : 0;
+              }
+              if (_v) {
+                return _wrap_FXHeader_prependItem__SWIG_1(nargs, args, self);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 7, "prependItem", 
+    "    FXint prependItem(FXHeaderItem *item, FXbool notify)\n"
+    "    FXint prependItem(FXString const &text, FXIcon *icon, FXint size, void *ITEMDATA, FXbool notify)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_extractItem(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXHeaderItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","extractItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  result = (FXHeaderItem *)(arg1)->extractItem(arg2,arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXHeaderItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_removeItem(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","removeItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  FXHeader_removeItem(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_clearItems(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","clearItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXHeader_clearItems(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_setItemText(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setItemText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  (arg1)->setItemText(arg2,(FXString const &)*arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_getItemText(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getItemText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  result = ((FXHeader const *)arg1)->getItemText(arg2);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_setItemIcon(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setItemIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","setItemIcon", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXIcon * >(argp3);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  (arg1)->setItemIcon(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_getItemIcon(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getItemIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  result = (FXIcon *)((FXHeader const *)arg1)->getItemIcon(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_setItemSize(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setItemSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  (arg1)->setItemSize(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_getItemSize(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getItemSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  result = (FXint)((FXHeader const *)arg1)->getItemSize(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_getItemOffset(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getItemOffset", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  result = (FXint)((FXHeader const *)arg1)->getItemOffset(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_setItemData(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  VALUE arg3 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setItemData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = argv[1];
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  FXHeader_setItemData(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_getItemData(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getItemData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  result = (VALUE)FXHeader_getItemData((FXHeader const *)arg1,arg2);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_setArrowDir(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setArrowDir", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  (arg1)->setArrowDir(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_getArrowDir(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getArrowDir", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  result = (FXuint)((FXHeader const *)arg1)->getArrowDir(arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_setItemJustify(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setItemJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  (arg1)->setItemJustify(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_getItemJustify(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getItemJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  result = (FXuint)((FXHeader const *)arg1)->getItemJustify(arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_setItemIconPosition(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setItemIconPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  (arg1)->setItemIconPosition(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_getItemIconPosition(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getItemIconPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  result = (FXuint)((FXHeader const *)arg1)->getItemIconPosition(arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_setItemPressed(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setItemPressed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  (arg1)->setItemPressed(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_isItemPressed(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","isItemPressed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  result = (FXbool)((FXHeader const *)arg1)->isItemPressed(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_makeItemVisible(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","makeItemVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  (arg1)->makeItemVisible(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_updateItem(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","updateItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "header item index out of bounds");
+    }
+  }
+  ((FXHeader const *)arg1)->updateItem(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_setFont(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  (arg1)->setFont(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_getFont(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  result = (FXFont *)((FXHeader const *)arg1)->getFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_getTextColor(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  result = (FXColor)((FXHeader const *)arg1)->getTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_setTextColor(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_setHeaderStyle(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setHeaderStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setHeaderStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_getHeaderStyle(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getHeaderStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  result = (FXuint)((FXHeader const *)arg1)->getHeaderStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  result = (FXString *) &((FXHeader const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_save(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXHeader_save((FXHeader const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_load(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXHeader_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_create(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  FXHeader_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_detach(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  FXHeader_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_destroy(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  FXHeader_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_resize(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXHeader_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  result = (FXint)FXHeader_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  result = (FXint)FXHeader_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXHeader_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXHeader_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  result = (bool)FXHeader_canFocus((FXHeader const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  FXHeader_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  FXHeader_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXHeader_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXHeader_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_enable(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  FXHeader_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_disable(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  FXHeader_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  FXHeader_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_lower(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  FXHeader_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_move(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXHeader_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_position(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXHeader_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_layout(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  FXHeader_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_recalc(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  FXHeader_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_reparent(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXHeader_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_show(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  FXHeader_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_hide(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  FXHeader_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  result = (bool)FXHeader_isComposite((FXHeader const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_contains(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXHeader_contains((FXHeader const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  result = (bool)FXHeader_doesSaveUnder((FXHeader const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXHeader_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_tr(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXHeader_tr((FXHeader const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  FXHeader_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  FXHeader_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXHeader_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXHeader_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXHeader_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXHeader_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHeader, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXHeader_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHeader, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXHeader_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHeader, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXHeader_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHeader_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXHeader *arg1 = (FXHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHeader *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHeader * >(argp1);
+  FXHeader_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXImageFrame;
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXImageFrame_allocate(VALUE self)
+#else
+_wrap_FXImageFrame_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXImageFrame);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXImageFrame(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXImage *arg2 = (FXImage *) 0 ;
+  FXuint arg3 = (FXuint) FRAME_SUNKEN|FRAME_THICK ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) 0 ;
+  FXint arg11 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXImageFrame *result = 0 ;
+  
+  if ((argc < 2) || (argc > 11)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXImageFrame", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXImage *","FXImageFrame", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXImage * >(argp2);
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXImageFrame *)new_FXImageFrame(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_setImage(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  FXImage *arg2 = (FXImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","setImage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXImage *","setImage", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXImage * >(argp2);
+  (arg1)->setImage(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_getImage(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXImage *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame const *","getImage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  result = (FXImage *)((FXImageFrame const *)arg1)->getImage();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXImage, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_setJustify(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","setJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setJustify(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_getJustify(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame const *","getJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  result = (FXuint)((FXImageFrame const *)arg1)->getJustify();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_save(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXImageFrame_save((FXImageFrame const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_load(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXImageFrame_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_create(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  FXImageFrame_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_detach(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  FXImageFrame_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_destroy(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  FXImageFrame_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_resize(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXImageFrame_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  result = (FXint)FXImageFrame_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  result = (FXint)FXImageFrame_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXImageFrame_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXImageFrame_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  result = (bool)FXImageFrame_canFocus((FXImageFrame const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  FXImageFrame_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  FXImageFrame_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXImageFrame_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXImageFrame_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_enable(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  FXImageFrame_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_disable(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  FXImageFrame_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  FXImageFrame_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_lower(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  FXImageFrame_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_move(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXImageFrame_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_position(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXImageFrame_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_layout(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  FXImageFrame_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_recalc(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  FXImageFrame_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_reparent(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXImageFrame_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_show(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  FXImageFrame_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_hide(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  FXImageFrame_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  result = (bool)FXImageFrame_isComposite((FXImageFrame const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_contains(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXImageFrame_contains((FXImageFrame const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  result = (bool)FXImageFrame_doesSaveUnder((FXImageFrame const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXImageFrame_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_tr(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXImageFrame_tr((FXImageFrame const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  FXImageFrame_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  FXImageFrame_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXImageFrame_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXImageFrame_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXImageFrame_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXImageFrame_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXImageFrame, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXImageFrame_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXImageFrame, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXImageFrame_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXImageFrame, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXImageFrame_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageFrame_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXImageFrame *arg1 = (FXImageFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageFrame *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageFrame * >(argp1);
+  FXImageFrame_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXBitmapFrame;
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXBitmapFrame_allocate(VALUE self)
+#else
+_wrap_FXBitmapFrame_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXBitmapFrame);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXBitmapFrame(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  FXuint arg3 = (FXuint) FRAME_SUNKEN|FRAME_THICK ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) 0 ;
+  FXint arg11 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXBitmapFrame *result = 0 ;
+  
+  if ((argc < 2) || (argc > 11)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXBitmapFrame", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","FXBitmapFrame", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXBitmapFrame *)new_FXBitmapFrame(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_setBitmap(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","setBitmap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setBitmap", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  (arg1)->setBitmap(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_getBitmap(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXBitmap *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame const *","getBitmap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  result = (FXBitmap *)((FXBitmapFrame const *)arg1)->getBitmap();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXBitmap, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_setOnColor(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","setOnColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setOnColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_getOnColor(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame const *","getOnColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  result = (FXColor)((FXBitmapFrame const *)arg1)->getOnColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_setOffColor(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","setOffColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setOffColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_getOffColor(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame const *","getOffColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  result = (FXColor)((FXBitmapFrame const *)arg1)->getOffColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_setJustify(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","setJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setJustify(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_getJustify(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame const *","getJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  result = (FXuint)((FXBitmapFrame const *)arg1)->getJustify();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_save(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXBitmapFrame_save((FXBitmapFrame const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_load(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXBitmapFrame_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_create(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  FXBitmapFrame_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_detach(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  FXBitmapFrame_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_destroy(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  FXBitmapFrame_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_resize(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXBitmapFrame_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  result = (FXint)FXBitmapFrame_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  result = (FXint)FXBitmapFrame_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXBitmapFrame_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXBitmapFrame_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  result = (bool)FXBitmapFrame_canFocus((FXBitmapFrame const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  FXBitmapFrame_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  FXBitmapFrame_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXBitmapFrame_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXBitmapFrame_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_enable(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  FXBitmapFrame_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_disable(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  FXBitmapFrame_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  FXBitmapFrame_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_lower(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  FXBitmapFrame_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_move(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXBitmapFrame_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_position(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXBitmapFrame_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_layout(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  FXBitmapFrame_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_recalc(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  FXBitmapFrame_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_reparent(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXBitmapFrame_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_show(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  FXBitmapFrame_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_hide(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  FXBitmapFrame_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  result = (bool)FXBitmapFrame_isComposite((FXBitmapFrame const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_contains(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXBitmapFrame_contains((FXBitmapFrame const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  result = (bool)FXBitmapFrame_doesSaveUnder((FXBitmapFrame const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXBitmapFrame_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_tr(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXBitmapFrame_tr((FXBitmapFrame const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  FXBitmapFrame_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  FXBitmapFrame_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXBitmapFrame_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXBitmapFrame_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXBitmapFrame_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXBitmapFrame_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXBitmapFrame, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXBitmapFrame_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXBitmapFrame, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXBitmapFrame_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXBitmapFrame, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXBitmapFrame_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmapFrame_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXBitmapFrame *arg1 = (FXBitmapFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmapFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmapFrame *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmapFrame * >(argp1);
+  FXBitmapFrame_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXKnob;
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onMiddleBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onMiddleBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMiddleBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMiddleBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onMiddleBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onMiddleBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMiddleBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMiddleBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onMouseWheel(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onMouseWheel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMouseWheel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMouseWheel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onFocusIn(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onFocusIn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusIn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusIn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onFocusOut(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onFocusOut", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusOut", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusOut(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onAutoSlide(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onAutoSlide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onAutoSlide", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(static_cast<FXival>(NUM2LONG(argv[2])));
+  result = (long)(arg1)->onAutoSlide(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(static_cast<FXival>(NUM2LONG(argv[2])));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXint) NUM2INT(argv[2]);
+    arg4 = static_cast<void*>(&value4);
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onCmdSetRealValue(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXdouble value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onCmdSetRealValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetRealValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXdouble) NUM2DBL(argv[2]);
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetRealValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onCmdGetRealValue(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onCmdGetRealValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetRealValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetRealValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onCmdSetIntRange(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint values4[2] ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onCmdSetIntRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    Check_Type(argv[2], T_ARRAY);
+    values4[0] = (FXint) NUM2INT(rb_ary_entry(argv[2], 0));
+    values4[1] = (FXint) NUM2INT(rb_ary_entry(argv[2], 1));
+    arg4 = static_cast<void*>(values4);
+  }
+  result = (long)(arg1)->onCmdSetIntRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onCmdGetIntRange(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onCmdGetIntRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetIntRange", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetIntRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onCmdSetRealRange(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXdouble values4[2] ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onCmdSetRealRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetRealRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    Check_Type(argv[2], T_ARRAY);
+    values4[0] = (FXdouble) NUM2DBL(rb_ary_entry(argv[2], 0));
+    values4[1] = (FXdouble) NUM2DBL(rb_ary_entry(argv[2], 1));
+    arg4 = (void *) values4;
+  }
+  result = (long)(arg1)->onCmdSetRealRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onCmdGetRealRange(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onCmdGetRealRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetRealRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetRealRange", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetRealRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onCmdSetHelp(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onCmdSetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onCmdGetHelp(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onCmdGetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onCmdSetTip(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onCmdSetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onCmdGetTip(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onCmdGetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXKnob_allocate(VALUE self)
+#else
+_wrap_FXKnob_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXKnob);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXKnob(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) KNOB_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) DEFAULT_PAD ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXKnob *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXKnob", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXKnob", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXKnob *)new_FXKnob(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_valuee___(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","setValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setValue(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_setRange(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","setRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  arg2 = argv[0];
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXKnob_setRange(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_getRange(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob const *","getRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  result = (VALUE)FXKnob_getRange((FXKnob const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_setLimits(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","setLimits", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  (arg1)->setLimits(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_getLimits(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXint *arg2 = 0 ;
+  FXint *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","getLimits", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_int,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXint &","getLimits", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXint &","getLimits", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXint * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_int,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXint &","getLimits", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXint &","getLimits", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXint * >(argp3);
+  (arg1)->getLimits(*arg2,*arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_knobStyle(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob const *","getKnobStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  result = (FXuint)((FXKnob const *)arg1)->getKnobStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_knobStylee___(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","setKnobStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setKnobStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_increment(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob const *","getIncrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  result = (FXint)((FXKnob const *)arg1)->getIncrement();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_incremente___(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","setIncrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setIncrement(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_tickDeltae___(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","setTickDelta", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setTickDelta(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_tickDelta(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob const *","getTickDelta", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  result = (FXint)((FXKnob const *)arg1)->getTickDelta();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_lineColore___(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","setLineColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setLineColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_lineColor(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob const *","getLineColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  result = (FXColor)((FXKnob const *)arg1)->getLineColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_helpTexte___(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_helpText(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  result = (FXString *) &((FXKnob const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_tipTexte___(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_tipText(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  result = (FXString *) &((FXKnob const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_save(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXKnob_save((FXKnob const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_load(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXKnob_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_create(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  FXKnob_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_detach(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  FXKnob_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_destroy(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  FXKnob_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_resize(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXKnob_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  result = (FXint)FXKnob_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  result = (FXint)FXKnob_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXKnob_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXKnob_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  result = (bool)FXKnob_canFocus((FXKnob const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  FXKnob_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  FXKnob_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXKnob_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXKnob_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_enable(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  FXKnob_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_disable(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  FXKnob_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  FXKnob_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_lower(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  FXKnob_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_move(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXKnob_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_position(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXKnob_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_layout(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  FXKnob_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_recalc(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  FXKnob_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_reparent(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXKnob_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_show(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  FXKnob_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_hide(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  FXKnob_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  result = (bool)FXKnob_isComposite((FXKnob const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_contains(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXKnob_contains((FXKnob const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  result = (bool)FXKnob_doesSaveUnder((FXKnob const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXKnob_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_tr(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXKnob_tr((FXKnob const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  FXKnob_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  FXKnob_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXKnob_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXKnob_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXKnob_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXKnob_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXKnob, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXKnob_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXKnob, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXKnob_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXKnob, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXKnob_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXKnob_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXKnob *arg1 = (FXKnob *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXKnob, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXKnob *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXKnob * >(argp1);
+  FXKnob_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXProgressBar;
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2UINT(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXint) NUM2INT(argv[2]);
+    arg4 = static_cast<void*>(&value4);
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXProgressBar_allocate(VALUE self)
+#else
+_wrap_FXProgressBar_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXProgressBar);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXProgressBar(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) PROGRESSBAR_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) DEFAULT_PAD ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXProgressBar *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXProgressBar", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXProgressBar", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXProgressBar *)new_FXProgressBar(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_setProgress(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","setProgress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setProgress(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_getProgress(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar const *","getProgress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  result = (FXuint)((FXProgressBar const *)arg1)->getProgress();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_setTotal(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","setTotal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setTotal(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_getTotal(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar const *","getTotal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  result = (FXuint)((FXProgressBar const *)arg1)->getTotal();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_increment(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","increment", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->increment(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_hideNumber(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","hideNumber", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  (arg1)->hideNumber();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_showNumber(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","showNumber", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  (arg1)->showNumber();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_setBarSize(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","setBarSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setBarSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_getBarSize(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar const *","getBarSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  result = (FXint)((FXProgressBar const *)arg1)->getBarSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_setBarBGColor(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","setBarBGColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setBarBGColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_getBarBGColor(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar const *","getBarBGColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  result = (FXColor)((FXProgressBar const *)arg1)->getBarBGColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_setBarColor(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","setBarColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setBarColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_getBarColor(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar const *","getBarColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  result = (FXColor)((FXProgressBar const *)arg1)->getBarColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_setTextColor(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","setTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_getTextColor(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar const *","getTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  result = (FXColor)((FXProgressBar const *)arg1)->getTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_setTextAltColor(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","setTextAltColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTextAltColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_getTextAltColor(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar const *","getTextAltColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  result = (FXColor)((FXProgressBar const *)arg1)->getTextAltColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_setFont(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  (arg1)->setFont(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_getFont(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  result = (FXFont *)((FXProgressBar const *)arg1)->getFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_setBarStyle(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","setBarStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setBarStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_getBarStyle(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar const *","getBarStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  result = (FXuint)((FXProgressBar const *)arg1)->getBarStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_save(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXProgressBar_save((FXProgressBar const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_load(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXProgressBar_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_create(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  FXProgressBar_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_detach(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  FXProgressBar_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_destroy(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  FXProgressBar_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_resize(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXProgressBar_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  result = (FXint)FXProgressBar_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  result = (FXint)FXProgressBar_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXProgressBar_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXProgressBar_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  result = (bool)FXProgressBar_canFocus((FXProgressBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  FXProgressBar_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  FXProgressBar_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXProgressBar_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXProgressBar_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_enable(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  FXProgressBar_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_disable(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  FXProgressBar_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  FXProgressBar_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_lower(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  FXProgressBar_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_move(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXProgressBar_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_position(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXProgressBar_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_layout(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  FXProgressBar_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_recalc(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  FXProgressBar_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_reparent(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXProgressBar_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_show(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  FXProgressBar_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_hide(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  FXProgressBar_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  result = (bool)FXProgressBar_isComposite((FXProgressBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_contains(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXProgressBar_contains((FXProgressBar const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  result = (bool)FXProgressBar_doesSaveUnder((FXProgressBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXProgressBar_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_tr(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXProgressBar_tr((FXProgressBar const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  FXProgressBar_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  FXProgressBar_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXProgressBar_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXProgressBar_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXProgressBar_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXProgressBar_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXProgressBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXProgressBar_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXProgressBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXProgressBar_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXProgressBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXProgressBar_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXProgressBar_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXProgressBar *arg1 = (FXProgressBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXProgressBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXProgressBar *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXProgressBar * >(argp1);
+  FXProgressBar_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXRuler;
+
+SWIGINTERN VALUE
+_wrap_FXRuler_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdSetValue", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdSetIntValue", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetIntValue", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_onCmdSetHelp(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","onCmdSetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_onCmdGetHelp(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","onCmdGetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_onCmdSetTip(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","onCmdSetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_onCmdGetTip(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","onCmdGetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXRuler_allocate(VALUE self)
+#else
+_wrap_FXRuler_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXRuler);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRuler(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) RULER_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) DEFAULT_PAD ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXRuler *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXRuler", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXRuler", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXRuler *)new_FXRuler(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setPosition(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setPosition(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getPosition(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXint)((FXRuler const *)arg1)->getPosition();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setContentSize(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setContentSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setContentSize(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getContentSize(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getContentSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXint)((FXRuler const *)arg1)->getContentSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_documentLower(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getDocumentLower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXint)((FXRuler const *)arg1)->getDocumentLower();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_documentUpper(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getDocumentUpper", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXint)((FXRuler const *)arg1)->getDocumentUpper();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setDocumentSize(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setDocumentSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setDocumentSize(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getDocumentSize(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getDocumentSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXint)((FXRuler const *)arg1)->getDocumentSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setEdgeSpacing(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setEdgeSpacing", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setEdgeSpacing(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getEdgeSpacing(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getEdgeSpacing", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXint)((FXRuler const *)arg1)->getEdgeSpacing();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setMarginLower(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setMarginLower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setMarginLower(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getMarginLower(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getMarginLower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXint)((FXRuler const *)arg1)->getMarginLower();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setMarginUpper(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setMarginUpper", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setMarginUpper(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getMarginUpper(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getMarginUpper", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXint)((FXRuler const *)arg1)->getMarginUpper();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setIndentFirst(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setIndentFirst", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setIndentFirst(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getIndentFirst(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getIndentFirst", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXint)((FXRuler const *)arg1)->getIndentFirst();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setIndentLower(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setIndentLower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setIndentLower(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getIndentLower(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getIndentLower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXint)((FXRuler const *)arg1)->getIndentLower();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setIndentUpper(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setIndentUpper", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setIndentUpper(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getIndentUpper(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getIndentUpper", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXint)((FXRuler const *)arg1)->getIndentUpper();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setNumberTicks(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setNumberTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setNumberTicks(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getNumberTicks(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getNumberTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXint)((FXRuler const *)arg1)->getNumberTicks();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setMajorTicks(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setMajorTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setMajorTicks(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getMajorTicks(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getMajorTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXint)((FXRuler const *)arg1)->getMajorTicks();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setMediumTicks(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setMediumTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setMediumTicks(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getMediumTicks(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getMediumTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXint)((FXRuler const *)arg1)->getMediumTicks();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setTinyTicks(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setTinyTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setTinyTicks(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getTinyTicks(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getTinyTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXint)((FXRuler const *)arg1)->getTinyTicks();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setPixelPerTick(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXdouble arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setPixelPerTick", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","setPixelPerTick", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setPixelPerTick(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getPixelPerTick(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getPixelPerTick", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXdouble)((FXRuler const *)arg1)->getPixelPerTick();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setFont(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setFont(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getFont(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXFont *)((FXRuler const *)arg1)->getFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setValue(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setValue(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getValue(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXint)((FXRuler const *)arg1)->getValue();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setRulerStyle(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setRulerStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setRulerStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getRulerStyle(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getRulerStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXuint)((FXRuler const *)arg1)->getRulerStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setRulerAlignment(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXuint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setRulerAlignment", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setRulerAlignment(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getRulerAlignment(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getRulerAlignment", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXuint)((FXRuler const *)arg1)->getRulerAlignment();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getTextColor(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXColor)((FXRuler const *)arg1)->getTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setTextColor(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXString *) &((FXRuler const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setTipText(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getTipText(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXString *) &((FXRuler const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_save(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXRuler_save((FXRuler const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_load(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXRuler_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_create(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  FXRuler_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_detach(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  FXRuler_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_destroy(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  FXRuler_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_resize(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXRuler_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXint)FXRuler_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (FXint)FXRuler_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXRuler_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXRuler_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (bool)FXRuler_canFocus((FXRuler const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  FXRuler_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  FXRuler_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXRuler_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXRuler_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_enable(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  FXRuler_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_disable(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  FXRuler_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  FXRuler_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_lower(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  FXRuler_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_move(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXRuler_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_position(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXRuler_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_layout(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  FXRuler_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_recalc(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  FXRuler_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_reparent(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXRuler_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_show(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  FXRuler_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_hide(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  FXRuler_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (bool)FXRuler_isComposite((FXRuler const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_contains(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXRuler_contains((FXRuler const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  result = (bool)FXRuler_doesSaveUnder((FXRuler const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXRuler_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_tr(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXRuler_tr((FXRuler const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  FXRuler_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  FXRuler_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXRuler_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXRuler_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXRuler_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXRuler_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRuler, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRuler_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRuler, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRuler_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRuler, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRuler_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRuler_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXRuler *arg1 = (FXRuler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRuler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRuler *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRuler * >(argp1);
+  FXRuler_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXSeparator;
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXSeparator_allocate(VALUE self)
+#else
+_wrap_FXSeparator_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXSeparator);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSeparator(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXuint arg2 = (FXuint) SEPARATOR_GROOVE|LAYOUT_FILL_X ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXSeparator *result = 0 ;
+  
+  if ((argc < 1) || (argc > 10)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXSeparator", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXSeparator *)new_FXSeparator(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_setSeparatorStyle(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","setSeparatorStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setSeparatorStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_getSeparatorStyle(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator const *","getSeparatorStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  result = (FXuint)((FXSeparator const *)arg1)->getSeparatorStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_save(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXSeparator_save((FXSeparator const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_load(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXSeparator_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_create(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  FXSeparator_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_detach(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  FXSeparator_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_destroy(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  FXSeparator_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_resize(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXSeparator_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  result = (FXint)FXSeparator_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  result = (FXint)FXSeparator_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXSeparator_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXSeparator_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  result = (bool)FXSeparator_canFocus((FXSeparator const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  FXSeparator_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  FXSeparator_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXSeparator_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXSeparator_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_enable(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  FXSeparator_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_disable(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  FXSeparator_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  FXSeparator_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_lower(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  FXSeparator_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_move(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXSeparator_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_position(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXSeparator_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_layout(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  FXSeparator_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_recalc(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  FXSeparator_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_reparent(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXSeparator_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_show(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  FXSeparator_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_hide(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  FXSeparator_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  result = (bool)FXSeparator_isComposite((FXSeparator const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_contains(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXSeparator_contains((FXSeparator const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  result = (bool)FXSeparator_doesSaveUnder((FXSeparator const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXSeparator_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_tr(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXSeparator_tr((FXSeparator const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  FXSeparator_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  FXSeparator_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXSeparator_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXSeparator_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXSeparator_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXSeparator_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSeparator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSeparator_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSeparator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSeparator_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSeparator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSeparator_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSeparator_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXSeparator *arg1 = (FXSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSeparator *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSeparator * >(argp1);
+  FXSeparator_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXHorizontalSeparator;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXHorizontalSeparator_allocate(VALUE self)
+#else
+_wrap_FXHorizontalSeparator_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXHorizontalSeparator);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXHorizontalSeparator(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXuint arg2 = (FXuint) SEPARATOR_GROOVE|LAYOUT_FILL_X ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 1 ;
+  FXint arg8 = (FXint) 1 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXHorizontalSeparator *result = 0 ;
+  
+  if ((argc < 1) || (argc > 10)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXHorizontalSeparator", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXHorizontalSeparator *)new_FXHorizontalSeparator(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_save(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXHorizontalSeparator_save((FXHorizontalSeparator const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_load(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXHorizontalSeparator_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_create(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  FXHorizontalSeparator_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_detach(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  FXHorizontalSeparator_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_destroy(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  FXHorizontalSeparator_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_resize(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXHorizontalSeparator_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  result = (FXint)FXHorizontalSeparator_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  result = (FXint)FXHorizontalSeparator_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXHorizontalSeparator_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXHorizontalSeparator_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  result = (bool)FXHorizontalSeparator_canFocus((FXHorizontalSeparator const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  FXHorizontalSeparator_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  FXHorizontalSeparator_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXHorizontalSeparator_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXHorizontalSeparator_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_enable(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  FXHorizontalSeparator_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_disable(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  FXHorizontalSeparator_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  FXHorizontalSeparator_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_lower(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  FXHorizontalSeparator_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_move(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXHorizontalSeparator_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_position(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXHorizontalSeparator_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_layout(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  FXHorizontalSeparator_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_recalc(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  FXHorizontalSeparator_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_reparent(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXHorizontalSeparator_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_show(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  FXHorizontalSeparator_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_hide(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  FXHorizontalSeparator_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  result = (bool)FXHorizontalSeparator_isComposite((FXHorizontalSeparator const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_contains(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXHorizontalSeparator_contains((FXHorizontalSeparator const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  result = (bool)FXHorizontalSeparator_doesSaveUnder((FXHorizontalSeparator const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXHorizontalSeparator_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_tr(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXHorizontalSeparator_tr((FXHorizontalSeparator const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  FXHorizontalSeparator_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  FXHorizontalSeparator_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXHorizontalSeparator_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXHorizontalSeparator_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXHorizontalSeparator_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXHorizontalSeparator_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHorizontalSeparator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXHorizontalSeparator_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHorizontalSeparator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXHorizontalSeparator_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHorizontalSeparator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXHorizontalSeparator_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalSeparator_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalSeparator *arg1 = (FXHorizontalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalSeparator *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalSeparator * >(argp1);
+  FXHorizontalSeparator_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXVerticalSeparator;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXVerticalSeparator_allocate(VALUE self)
+#else
+_wrap_FXVerticalSeparator_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXVerticalSeparator);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVerticalSeparator(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXuint arg2 = (FXuint) SEPARATOR_GROOVE|LAYOUT_FILL_Y ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 1 ;
+  FXint arg10 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVerticalSeparator *result = 0 ;
+  
+  if ((argc < 1) || (argc > 10)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXVerticalSeparator", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXVerticalSeparator *)new_FXVerticalSeparator(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_save(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXVerticalSeparator_save((FXVerticalSeparator const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_load(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXVerticalSeparator_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_create(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  FXVerticalSeparator_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_detach(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  FXVerticalSeparator_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_destroy(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  FXVerticalSeparator_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_resize(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXVerticalSeparator_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  result = (FXint)FXVerticalSeparator_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  result = (FXint)FXVerticalSeparator_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXVerticalSeparator_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXVerticalSeparator_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  result = (bool)FXVerticalSeparator_canFocus((FXVerticalSeparator const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  FXVerticalSeparator_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  FXVerticalSeparator_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXVerticalSeparator_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXVerticalSeparator_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_enable(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  FXVerticalSeparator_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_disable(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  FXVerticalSeparator_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  FXVerticalSeparator_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_lower(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  FXVerticalSeparator_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_move(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXVerticalSeparator_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_position(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXVerticalSeparator_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_layout(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  FXVerticalSeparator_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_recalc(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  FXVerticalSeparator_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_reparent(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXVerticalSeparator_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_show(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  FXVerticalSeparator_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_hide(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  FXVerticalSeparator_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  result = (bool)FXVerticalSeparator_isComposite((FXVerticalSeparator const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_contains(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXVerticalSeparator_contains((FXVerticalSeparator const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  result = (bool)FXVerticalSeparator_doesSaveUnder((FXVerticalSeparator const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXVerticalSeparator_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_tr(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXVerticalSeparator_tr((FXVerticalSeparator const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  FXVerticalSeparator_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  FXVerticalSeparator_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXVerticalSeparator_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXVerticalSeparator_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXVerticalSeparator_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXVerticalSeparator_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVerticalSeparator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXVerticalSeparator_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVerticalSeparator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXVerticalSeparator_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVerticalSeparator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXVerticalSeparator_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalSeparator_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXVerticalSeparator *arg1 = (FXVerticalSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalSeparator *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalSeparator * >(argp1);
+  FXVerticalSeparator_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXSlider;
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onMouseWheel(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onMouseWheel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMouseWheel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMouseWheel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onMiddleBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onMiddleBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMiddleBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMiddleBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onMiddleBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onMiddleBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMiddleBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMiddleBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onAutoSlide(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onAutoSlide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onAutoSlide", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onAutoSlide(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXint) NUM2INT(argv[2]);
+    arg4 = static_cast<void*>(&value4);
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onCmdSetRealValue(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXdouble value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onCmdSetRealValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetRealValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXdouble) NUM2DBL(argv[2]);
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetRealValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onCmdGetRealValue(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onCmdGetRealValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetRealValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetRealValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onCmdSetIntRange(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint values4[2] ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onCmdSetIntRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    Check_Type(argv[2], T_ARRAY);
+    values4[0] = (FXint) NUM2INT(rb_ary_entry(argv[2], 0));
+    values4[1] = (FXint) NUM2INT(rb_ary_entry(argv[2], 1));
+    arg4 = static_cast<void*>(values4);
+  }
+  result = (long)(arg1)->onCmdSetIntRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onCmdGetIntRange(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onCmdGetIntRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetIntRange", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetIntRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onCmdSetRealRange(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXdouble values4[2] ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onCmdSetRealRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetRealRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    Check_Type(argv[2], T_ARRAY);
+    values4[0] = (FXdouble) NUM2DBL(rb_ary_entry(argv[2], 0));
+    values4[1] = (FXdouble) NUM2DBL(rb_ary_entry(argv[2], 1));
+    arg4 = (void *) values4;
+  }
+  result = (long)(arg1)->onCmdSetRealRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onCmdGetRealRange(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onCmdGetRealRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetRealRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetRealRange", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetRealRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onCmdSetHelp(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onCmdSetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onCmdGetHelp(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onCmdGetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onCmdSetTip(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onCmdSetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onCmdGetTip(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onCmdGetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXSlider_allocate(VALUE self)
+#else
+_wrap_FXSlider_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXSlider);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSlider(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) SLIDER_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) 0 ;
+  FXint arg11 = (FXint) 0 ;
+  FXint arg12 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXSlider *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXSlider", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXSlider", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXSlider *)new_FXSlider(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_setValue(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","setValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setValue(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_getValue(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider const *","getValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  result = (FXint)((FXSlider const *)arg1)->getValue();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_setRange(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","setRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  arg2 = argv[0];
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXSlider_setRange(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_getRange(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider const *","getRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  result = (VALUE)FXSlider_getRange((FXSlider const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_getSliderStyle(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider const *","getSliderStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  result = (FXuint)((FXSlider const *)arg1)->getSliderStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_setSliderStyle(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","setSliderStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setSliderStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_getHeadSize(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider const *","getHeadSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  result = (FXint)((FXSlider const *)arg1)->getHeadSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_setHeadSize(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","setHeadSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setHeadSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_getSlotSize(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider const *","getSlotSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  result = (FXint)((FXSlider const *)arg1)->getSlotSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_setSlotSize(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","setSlotSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setSlotSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_getIncrement(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider const *","getIncrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  result = (FXint)((FXSlider const *)arg1)->getIncrement();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_setIncrement(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","setIncrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setIncrement(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_setTickDelta(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","setTickDelta", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setTickDelta(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_getTickDelta(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider const *","getTickDelta", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  result = (FXint)((FXSlider const *)arg1)->getTickDelta();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_setSlotColor(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","setSlotColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSlotColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_getSlotColor(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider const *","getSlotColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  result = (FXColor)((FXSlider const *)arg1)->getSlotColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  result = (FXString *) &((FXSlider const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_setTipText(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_getTipText(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  result = (FXString *) &((FXSlider const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_save(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXSlider_save((FXSlider const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_load(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXSlider_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_create(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  FXSlider_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_detach(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  FXSlider_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_destroy(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  FXSlider_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_resize(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXSlider_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  result = (FXint)FXSlider_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  result = (FXint)FXSlider_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXSlider_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXSlider_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  result = (bool)FXSlider_canFocus((FXSlider const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  FXSlider_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  FXSlider_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXSlider_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXSlider_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_enable(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  FXSlider_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_disable(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  FXSlider_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  FXSlider_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_lower(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  FXSlider_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_move(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXSlider_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_position(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXSlider_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_layout(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  FXSlider_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_recalc(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  FXSlider_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_reparent(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXSlider_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_show(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  FXSlider_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_hide(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  FXSlider_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  result = (bool)FXSlider_isComposite((FXSlider const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_contains(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXSlider_contains((FXSlider const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  result = (bool)FXSlider_doesSaveUnder((FXSlider const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXSlider_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_tr(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXSlider_tr((FXSlider const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  FXSlider_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  FXSlider_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXSlider_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXSlider_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXSlider_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXSlider_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSlider, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSlider_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSlider, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSlider_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSlider, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSlider_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSlider_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXSlider *arg1 = (FXSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSlider *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSlider * >(argp1);
+  FXSlider_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXRealSlider;
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onMouseWheel(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onMouseWheel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMouseWheel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMouseWheel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onMiddleBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onMiddleBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMiddleBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMiddleBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onMiddleBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onMiddleBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMiddleBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMiddleBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onAutoSlide(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onAutoSlide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onAutoSlide", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onAutoSlide(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXint) NUM2INT(argv[2]);
+    arg4 = static_cast<void*>(&value4);
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onCmdSetRealValue(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXdouble value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onCmdSetRealValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetRealValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXdouble) NUM2DBL(argv[2]);
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetRealValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onCmdGetRealValue(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onCmdGetRealValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetRealValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetRealValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onCmdSetIntRange(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint values4[2] ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onCmdSetIntRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    Check_Type(argv[2], T_ARRAY);
+    values4[0] = (FXint) NUM2INT(rb_ary_entry(argv[2], 0));
+    values4[1] = (FXint) NUM2INT(rb_ary_entry(argv[2], 1));
+    arg4 = static_cast<void*>(values4);
+  }
+  result = (long)(arg1)->onCmdSetIntRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onCmdGetIntRange(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onCmdGetIntRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetIntRange", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetIntRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onCmdSetRealRange(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXdouble values4[2] ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onCmdSetRealRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetRealRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    Check_Type(argv[2], T_ARRAY);
+    values4[0] = (FXdouble) NUM2DBL(rb_ary_entry(argv[2], 0));
+    values4[1] = (FXdouble) NUM2DBL(rb_ary_entry(argv[2], 1));
+    arg4 = (void *) values4;
+  }
+  result = (long)(arg1)->onCmdSetRealRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onCmdGetRealRange(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onCmdGetRealRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetRealRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetRealRange", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetRealRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onCmdSetHelp(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onCmdSetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onCmdGetHelp(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onCmdGetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onCmdSetTip(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onCmdSetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onCmdGetTip(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onCmdGetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXRealSlider_allocate(VALUE self)
+#else
+_wrap_FXRealSlider_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXRealSlider);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRealSlider(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) REALSLIDER_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) 0 ;
+  FXint arg11 = (FXint) 0 ;
+  FXint arg12 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXRealSlider *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXRealSlider", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXRealSlider", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXRealSlider *)new_FXRealSlider(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_setValue(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXdouble arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","setValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","setValue", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setValue(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_getValue(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider const *","getValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  result = (FXdouble)((FXRealSlider const *)arg1)->getValue();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_setRange(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","setRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","setRange", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","setRange", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  (arg1)->setRange(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_getRange(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider const *","getRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  result = (VALUE)FXRealSlider_getRange((FXRealSlider const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_getSliderStyle(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider const *","getSliderStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  result = (FXuint)((FXRealSlider const *)arg1)->getSliderStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_setSliderStyle(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","setSliderStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setSliderStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_getHeadSize(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider const *","getHeadSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  result = (FXint)((FXRealSlider const *)arg1)->getHeadSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_setHeadSize(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","setHeadSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setHeadSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_getSlotSize(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider const *","getSlotSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  result = (FXint)((FXRealSlider const *)arg1)->getSlotSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_setSlotSize(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","setSlotSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setSlotSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_getIncrement(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider const *","getIncrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  result = (FXdouble)((FXRealSlider const *)arg1)->getIncrement();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_setIncrement(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","setIncrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","setIncrement", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  (arg1)->setIncrement(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_setTickDelta(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","setTickDelta", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","setTickDelta", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  (arg1)->setTickDelta(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_getTickDelta(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider const *","getTickDelta", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  result = (FXdouble)((FXRealSlider const *)arg1)->getTickDelta();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_setSlotColor(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","setSlotColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSlotColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_getSlotColor(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider const *","getSlotColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  result = (FXColor)((FXRealSlider const *)arg1)->getSlotColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  result = (FXString *) &((FXRealSlider const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_setTipText(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_getTipText(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  result = (FXString *) &((FXRealSlider const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_save(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXRealSlider_save((FXRealSlider const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_load(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXRealSlider_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_create(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  FXRealSlider_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_detach(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  FXRealSlider_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_destroy(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  FXRealSlider_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_resize(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXRealSlider_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  result = (FXint)FXRealSlider_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  result = (FXint)FXRealSlider_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXRealSlider_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXRealSlider_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  result = (bool)FXRealSlider_canFocus((FXRealSlider const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  FXRealSlider_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  FXRealSlider_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXRealSlider_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXRealSlider_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_enable(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  FXRealSlider_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_disable(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  FXRealSlider_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  FXRealSlider_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_lower(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  FXRealSlider_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_move(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXRealSlider_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_position(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXRealSlider_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_layout(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  FXRealSlider_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_recalc(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  FXRealSlider_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_reparent(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXRealSlider_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_show(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  FXRealSlider_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_hide(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  FXRealSlider_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  result = (bool)FXRealSlider_isComposite((FXRealSlider const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_contains(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXRealSlider_contains((FXRealSlider const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  result = (bool)FXRealSlider_doesSaveUnder((FXRealSlider const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXRealSlider_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_tr(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXRealSlider_tr((FXRealSlider const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  FXRealSlider_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  FXRealSlider_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXRealSlider_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXRealSlider_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXRealSlider_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXRealSlider_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRealSlider, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRealSlider_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRealSlider, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRealSlider_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRealSlider, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRealSlider_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSlider_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXRealSlider *arg1 = (FXRealSlider *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSlider, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSlider *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSlider * >(argp1);
+  FXRealSlider_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXStatusLine;
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_onUpdate(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","onUpdate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdate", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdate(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_onCmdGetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","onCmdGetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_onCmdSetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","onCmdSetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXStatusLine_allocate(VALUE self)
+#else
+_wrap_FXStatusLine_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXStatusLine);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXStatusLine(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXStatusLine *result = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXStatusLine", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXStatusLine", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXStatusLine *)new_FXStatusLine(arg1,arg2,arg3);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_setText(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","setText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_getText(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine const *","getText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  result = ((FXStatusLine const *)arg1)->getText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_setNormalText(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","setNormalText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setNormalText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_getNormalText(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine const *","getNormalText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  result = ((FXStatusLine const *)arg1)->getNormalText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_setFont(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  (arg1)->setFont(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_getFont(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  result = (FXFont *)((FXStatusLine const *)arg1)->getFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_getTextColor(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine const *","getTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  result = (FXColor)((FXStatusLine const *)arg1)->getTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_setTextColor(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","setTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_getTextHighlightColor(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine const *","getTextHighlightColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  result = (FXColor)((FXStatusLine const *)arg1)->getTextHighlightColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_setTextHighlightColor(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","setTextHighlightColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTextHighlightColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_save(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXStatusLine_save((FXStatusLine const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_load(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXStatusLine_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_create(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  FXStatusLine_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_detach(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  FXStatusLine_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_destroy(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  FXStatusLine_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_resize(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXStatusLine_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  result = (FXint)FXStatusLine_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  result = (FXint)FXStatusLine_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXStatusLine_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXStatusLine_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  result = (bool)FXStatusLine_canFocus((FXStatusLine const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  FXStatusLine_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  FXStatusLine_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXStatusLine_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXStatusLine_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_enable(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  FXStatusLine_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_disable(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  FXStatusLine_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  FXStatusLine_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_lower(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  FXStatusLine_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_move(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXStatusLine_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_position(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXStatusLine_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_layout(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  FXStatusLine_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_recalc(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  FXStatusLine_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_reparent(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXStatusLine_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_show(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  FXStatusLine_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_hide(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  FXStatusLine_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  result = (bool)FXStatusLine_isComposite((FXStatusLine const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_contains(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXStatusLine_contains((FXStatusLine const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  result = (bool)FXStatusLine_doesSaveUnder((FXStatusLine const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXStatusLine_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_tr(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXStatusLine_tr((FXStatusLine const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  FXStatusLine_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  FXStatusLine_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXStatusLine_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXStatusLine_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXStatusLine_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXStatusLine_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXStatusLine, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXStatusLine_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXStatusLine, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXStatusLine_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXStatusLine, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXStatusLine_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusLine_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXStatusLine *arg1 = (FXStatusLine *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusLine, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusLine *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusLine * >(argp1);
+  FXStatusLine_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXTextField;
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onUpdate(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onUpdate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdate", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdate(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onMiddleBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onMiddleBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMiddleBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMiddleBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onMiddleBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onMiddleBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMiddleBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMiddleBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onVerify(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onVerify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onVerify", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = static_cast<void*>(StringValuePtr(argv[2]));
+  result = (long)(arg1)->onVerify(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onSelectionLost(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onSelectionLost", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSelectionLost", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onSelectionLost(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onSelectionGained(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onSelectionGained", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSelectionGained", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onSelectionGained(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onSelectionRequest(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onSelectionRequest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSelectionRequest", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onSelectionRequest", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onSelectionRequest(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onClipboardLost(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onClipboardLost", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClipboardLost", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onClipboardLost(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onClipboardGained(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onClipboardGained", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClipboardGained", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onClipboardGained(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onClipboardRequest(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onClipboardRequest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClipboardRequest", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onClipboardRequest(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onFocusSelf(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onFocusSelf", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusSelf", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusSelf(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onFocusIn(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onFocusIn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusIn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusIn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onFocusOut(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onFocusOut", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusOut", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusOut(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onBlink(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onBlink", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onBlink", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onBlink(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onAutoScroll(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onAutoScroll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onAutoScroll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onAutoScroll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = static_cast<void*>(StringValuePtr(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXint) NUM2INT(argv[2]);
+    arg4 = static_cast<void*>(&value4);
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdSetRealValue(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXdouble value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdSetRealValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetRealValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXdouble) NUM2DBL(argv[2]);
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetRealValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdSetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdSetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdGetRealValue(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdGetRealValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetRealValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetRealValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdGetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdGetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdCursorHome(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdCursorHome", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorHome", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorHome(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdCursorEnd(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdCursorEnd", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorEnd", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorEnd(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdCursorRight(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdCursorRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorRight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorRight(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdCursorLeft(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdCursorLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorLeft", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorLeft(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdCursorWordLeft(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdCursorWordLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorWordLeft", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorWordLeft(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdCursorWordRight(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdCursorWordRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorWordRight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorWordRight(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdCursorWordStart(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdCursorWordStart", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorWordStart", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorWordStart(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdCursorWordEnd(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdCursorWordEnd", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorWordEnd", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorWordEnd(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdMark(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdMark", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMark", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdMark(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdExtend(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdExtend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdExtend", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdExtend(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdSelectAll(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdSelectAll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSelectAll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSelectAll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdDeselectAll(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdDeselectAll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDeselectAll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDeselectAll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdCutSel(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdCutSel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCutSel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCutSel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdCopySel(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdCopySel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCopySel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCopySel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdPasteSel(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdPasteSel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdPasteSel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdPasteSel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdPasteMiddle(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdPasteMiddle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdPasteMiddle", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdPasteMiddle(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdDeleteSel(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdDeleteSel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDeleteSel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDeleteSel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdDeleteAll(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdDeleteAll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDeleteAll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDeleteAll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdOverstString(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdOverstString", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdOverstString", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdOverstString", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdOverstString(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdInsertString(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdInsertString", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdInsertString", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = static_cast<void*>(StringValuePtr(argv[2]));
+  result = (long)(arg1)->onCmdInsertString(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdBackspace(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdBackspace", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdBackspace", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdBackspace(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdDelete(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdDelete", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDelete", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDelete(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdToggleEditable(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdToggleEditable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdToggleEditable", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdToggleEditable(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onUpdToggleEditable(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onUpdToggleEditable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdToggleEditable", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdToggleEditable(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdToggleOverstrike(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdToggleOverstrike", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdToggleOverstrike", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdToggleOverstrike(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onUpdToggleOverstrike(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onUpdToggleOverstrike", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdToggleOverstrike", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdToggleOverstrike(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onUpdHaveSelection(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onUpdHaveSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdHaveSelection", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdHaveSelection(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onUpdSelectAll(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onUpdSelectAll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSelectAll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdSelectAll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdSetHelp(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdSetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdGetHelp(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdGetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdSetTip(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdSetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onCmdGetTip(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onCmdGetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_textDelimiters_get(VALUE self) {
+  VALUE _val;
+  
+  _val = SWIG_FromCharPtr(FXTextField::textDelimiters);
+  return _val;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXTextField_allocate(VALUE self)
+#else
+_wrap_FXTextField_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXTextField);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXTextField(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXint arg2 ;
+  FXObject *arg3 = (FXObject *) 0 ;
+  FXSelector arg4 = (FXSelector) 0 ;
+  FXuint arg5 = (FXuint) TEXTFIELD_NORMAL ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  FXint arg13 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXTextField *result = 0 ;
+  
+  if ((argc < 2) || (argc > 13)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXTextField", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  arg2 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXObject *","FXTextField", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXObject * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXTextField *)new_FXTextField(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_setEditable(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","setEditable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->setEditable(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_isEditable(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","isEditable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  result = (FXbool)((FXTextField const *)arg1)->isEditable();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_overstrikee___(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","setOverstrike", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->setOverstrike(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_overstrikeq___(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","isOverstrike", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  result = (FXbool)((FXTextField const *)arg1)->isOverstrike();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_setCursorPos(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","setCursorPos", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setCursorPos(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_getCursorPos(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","getCursorPos", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  result = (FXint)((FXTextField const *)arg1)->getCursorPos();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_setAnchorPos(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","setAnchorPos", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setAnchorPos(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_getAnchorPos(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","getAnchorPos", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  result = (FXint)((FXTextField const *)arg1)->getAnchorPos();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_setText(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXString *arg2 = 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","setText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setText((FXString const &)*arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_getText(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","getText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  result = ((FXTextField const *)arg1)->getText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_setFont(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  (arg1)->setFont(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_getFont(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  result = (FXFont *)((FXTextField const *)arg1)->getFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_setTextColor(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","setTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_getTextColor(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","getTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  result = (FXColor)((FXTextField const *)arg1)->getTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_setSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","setSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelBackColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_getSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","getSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  result = (FXColor)((FXTextField const *)arg1)->getSelBackColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_setSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","setSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_getSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","getSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  result = (FXColor)((FXTextField const *)arg1)->getSelTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_setCursorColor(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","setCursorColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setCursorColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_getCursorColor(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","getCursorColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  result = (FXColor)((FXTextField const *)arg1)->getCursorColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_setNumColumns(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","setNumColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setNumColumns(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_getNumColumns(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","getNumColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  result = (FXint)((FXTextField const *)arg1)->getNumColumns();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_setJustify(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","setJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setJustify(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_getJustify(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","getJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  result = (FXuint)((FXTextField const *)arg1)->getJustify();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_setDelimiters(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXchar *arg2 = (FXchar *) FXTextField::textDelimiters ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","setDelimiters", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  if (argc > 0) {
+    arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  }
+  (arg1)->setDelimiters((FXchar const *)arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_getDelimiters(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","getDelimiters", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  result = (FXchar *)((FXTextField const *)arg1)->getDelimiters();
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  result = (FXString *) &((FXTextField const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_setTipText(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_getTipText(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  result = (FXString *) &((FXTextField const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_setTextStyle(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","setTextStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setTextStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_getTextStyle(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","getTextStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  result = (FXuint)((FXTextField const *)arg1)->getTextStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_selectAll(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","selectAll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  result = (FXbool)(arg1)->selectAll();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_setSelection(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","setSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXbool)(arg1)->setSelection(arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_extendSelection(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","extendSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXbool)(arg1)->extendSelection(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_killSelection(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","killSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  result = (FXbool)(arg1)->killSelection();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_isPosSelected(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","isPosSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXbool)((FXTextField const *)arg1)->isPosSelected(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_isPosVisible(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","isPosVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXbool)((FXTextField const *)arg1)->isPosVisible(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_makePositionVisible(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","makePositionVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->makePositionVisible(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_save(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTextField_save((FXTextField const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_load(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTextField_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_create(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  FXTextField_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_detach(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  FXTextField_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_destroy(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  FXTextField_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_resize(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXTextField_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  result = (FXint)FXTextField_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  result = (FXint)FXTextField_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXTextField_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXTextField_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  result = (bool)FXTextField_canFocus((FXTextField const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  FXTextField_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  FXTextField_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXTextField_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXTextField_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_enable(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  FXTextField_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_disable(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  FXTextField_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  FXTextField_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_lower(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  FXTextField_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_move(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXTextField_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_position(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXTextField_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_layout(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  FXTextField_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_recalc(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  FXTextField_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_reparent(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXTextField_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_show(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  FXTextField_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_hide(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  FXTextField_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  result = (bool)FXTextField_isComposite((FXTextField const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_contains(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXTextField_contains((FXTextField const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  result = (bool)FXTextField_doesSaveUnder((FXTextField const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXTextField_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_tr(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXTextField_tr((FXTextField const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  FXTextField_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  FXTextField_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXTextField_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXTextField_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXTextField_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXTextField_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTextField, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTextField_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTextField, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTextField_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTextField, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTextField_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextField_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXTextField *arg1 = (FXTextField *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextField, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextField *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextField * >(argp1);
+  FXTextField_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXToolBarTab;
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_onUpdate(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","onUpdate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdate", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdate(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_onEnter(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","onEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_onLeave(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","onLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_onCmdCollapse(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","onCmdCollapse", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCollapse", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCollapse(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_onUpdCollapse(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","onUpdCollapse", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdCollapse", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdCollapse(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_onCmdUncollapse(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","onCmdUncollapse", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdUncollapse", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdUncollapse(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_onUpdUncollapse(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","onUpdUncollapse", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdUncollapse", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdUncollapse(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_onCmdSetTip(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","onCmdSetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_onCmdGetTip(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","onCmdGetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXToolBarTab_allocate(VALUE self)
+#else
+_wrap_FXToolBarTab_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXToolBarTab);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXToolBarTab(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) FRAME_RAISED ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXToolBarTab *result = 0 ;
+  
+  if ((argc < 1) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXToolBarTab", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXToolBarTab", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXToolBarTab *)new_FXToolBarTab(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_collapse(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXbool arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","collapse", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->collapse(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_isCollapsed(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab const *","isCollapsed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  result = (FXbool)((FXToolBarTab const *)arg1)->isCollapsed();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_setTabStyle(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","setTabStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setTabStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_getTabStyle(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab const *","getTabStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  result = (FXuint)((FXToolBarTab const *)arg1)->getTabStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_getActiveColor(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab const *","getActiveColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  result = (FXColor)((FXToolBarTab const *)arg1)->getActiveColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_setActiveColor(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","setActiveColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setActiveColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_setTipText(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_getTipText(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  result = (FXString *) &((FXToolBarTab const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_save(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXToolBarTab_save((FXToolBarTab const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_load(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXToolBarTab_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_create(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  FXToolBarTab_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_detach(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  FXToolBarTab_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_destroy(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  FXToolBarTab_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_resize(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXToolBarTab_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  result = (FXint)FXToolBarTab_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  result = (FXint)FXToolBarTab_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXToolBarTab_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXToolBarTab_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  result = (bool)FXToolBarTab_canFocus((FXToolBarTab const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  FXToolBarTab_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  FXToolBarTab_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXToolBarTab_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXToolBarTab_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_enable(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  FXToolBarTab_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_disable(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  FXToolBarTab_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  FXToolBarTab_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_lower(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  FXToolBarTab_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_move(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXToolBarTab_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_position(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXToolBarTab_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_layout(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  FXToolBarTab_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_recalc(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  FXToolBarTab_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_reparent(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXToolBarTab_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_show(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  FXToolBarTab_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_hide(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  FXToolBarTab_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  result = (bool)FXToolBarTab_isComposite((FXToolBarTab const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_contains(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXToolBarTab_contains((FXToolBarTab const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  result = (bool)FXToolBarTab_doesSaveUnder((FXToolBarTab const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXToolBarTab_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_tr(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXToolBarTab_tr((FXToolBarTab const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  FXToolBarTab_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  FXToolBarTab_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXToolBarTab_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXToolBarTab_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXToolBarTab_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXToolBarTab_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToolBarTab, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXToolBarTab_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToolBarTab, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXToolBarTab_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToolBarTab, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXToolBarTab_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarTab_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXToolBarTab *arg1 = (FXToolBarTab *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarTab, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarTab *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarTab * >(argp1);
+  FXToolBarTab_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXGradient;
+
+SWIGINTERN VALUE
+_wrap_FXGradient_lower_set(int argc, VALUE *argv, VALUE self) {
+  FXGradient *arg1 = (FXGradient *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradient *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradient * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","lower", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->lower = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradient_lower_get(int argc, VALUE *argv, VALUE self) {
+  FXGradient *arg1 = (FXGradient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradient *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradient * >(argp1);
+  result = (FXdouble) ((arg1)->lower);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradient_middle_set(int argc, VALUE *argv, VALUE self) {
+  FXGradient *arg1 = (FXGradient *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradient *","middle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradient * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","middle", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->middle = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradient_middle_get(int argc, VALUE *argv, VALUE self) {
+  FXGradient *arg1 = (FXGradient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradient *","middle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradient * >(argp1);
+  result = (FXdouble) ((arg1)->middle);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradient_upper_set(int argc, VALUE *argv, VALUE self) {
+  FXGradient *arg1 = (FXGradient *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradient *","upper", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradient * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","upper", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->upper = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradient_upper_get(int argc, VALUE *argv, VALUE self) {
+  FXGradient *arg1 = (FXGradient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradient *","upper", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradient * >(argp1);
+  result = (FXdouble) ((arg1)->upper);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradient_lowerColor_set(int argc, VALUE *argv, VALUE self) {
+  FXGradient *arg1 = (FXGradient *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradient *","lowerColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradient * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (arg1) (arg1)->lowerColor = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradient_lowerColor_get(int argc, VALUE *argv, VALUE self) {
+  FXGradient *arg1 = (FXGradient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradient *","lowerColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradient * >(argp1);
+  result = (FXColor) ((arg1)->lowerColor);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradient_upperColor_set(int argc, VALUE *argv, VALUE self) {
+  FXGradient *arg1 = (FXGradient *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradient *","upperColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradient * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (arg1) (arg1)->upperColor = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradient_upperColor_get(int argc, VALUE *argv, VALUE self) {
+  FXGradient *arg1 = (FXGradient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradient *","upperColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradient * >(argp1);
+  result = (FXColor) ((arg1)->upperColor);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradient_blend_set(int argc, VALUE *argv, VALUE self) {
+  FXGradient *arg1 = (FXGradient *) 0 ;
+  FXuchar arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradient *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradient * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (arg1) (arg1)->blend = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradient_blend_get(int argc, VALUE *argv, VALUE self) {
+  FXGradient *arg1 = (FXGradient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuchar result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradient *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradient * >(argp1);
+  result = (FXuchar) ((arg1)->blend);
+  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXGradientBar;
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onDNDEnter(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onDNDEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onDNDLeave(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onDNDLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onDNDMotion(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onDNDMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onDNDDrop(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onDNDDrop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDDrop", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDDrop(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onCmdBlending(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onCmdBlending", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdBlending", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdBlending(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onUpdBlending(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onUpdBlending", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdBlending", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdBlending(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onUpdSegColor(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onUpdSegColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSegColor", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdSegColor(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onCmdSegColor(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onCmdSegColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSegColor", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSegColor(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onUpdRecenter(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onUpdRecenter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdRecenter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdRecenter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onCmdRecenter(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onCmdRecenter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdRecenter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdRecenter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onUpdSplit(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onUpdSplit", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSplit", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdSplit(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onCmdSplit(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onCmdSplit", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSplit", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSplit(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onUpdMerge(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onUpdMerge", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdMerge", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdMerge(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onCmdMerge(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onCmdMerge", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMerge", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdMerge(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onUpdUniform(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onUpdUniform", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdUniform", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdUniform(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onCmdUniform(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onCmdUniform", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdUniform", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdUniform(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onCmdSetHelp(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onCmdSetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onCmdGetHelp(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onCmdGetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onCmdSetTip(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onCmdSetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onCmdGetTip(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onCmdGetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXGradientBar_allocate(VALUE self)
+#else
+_wrap_FXGradientBar_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXGradientBar);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXGradientBar(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) FRAME_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) DEFAULT_PAD ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXGradientBar *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXGradientBar", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXGradientBar", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXGradientBar *)new_FXGradientBar(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_getSegment(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar const *","getSegment", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXint)((FXGradientBar const *)arg1)->getSegment(arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_getGrip(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar const *","getGrip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  result = (FXint)((FXGradientBar const *)arg1)->getGrip(arg2,arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_getNumSegments(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar const *","getNumSegments", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  result = (FXint)((FXGradientBar const *)arg1)->getNumSegments();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_setGradients(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXGradient *arg2 = (FXGradient *) 0 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","setGradients", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXGradient, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXGradient const *","setGradients", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXGradient * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  (arg1)->setGradients((FXGradient const *)arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_getGradients(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXGradient **arg2 = 0 ;
+  FXint *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar const *","getGradients", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_p_FXGradient,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXGradient *&","getGradients", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXGradient *&","getGradients", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXGradient ** >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_int,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXint &","getGradients", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXint &","getGradients", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXint * >(argp3);
+  ((FXGradientBar const *)arg1)->getGradients(*arg2,*arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_setCurrentSegment(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","setCurrentSegment", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < -1 || arg2 >= arg1->getNumSegments()) {
+      rb_raise(rb_eIndexError, "segment index %d out of bounds",arg2);
+    }
+  }
+  (arg1)->setCurrentSegment(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_getCurrentSegment(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar const *","getCurrentSegment", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  result = (FXint)((FXGradientBar const *)arg1)->getCurrentSegment();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_setAnchorSegment(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","setAnchorSegment", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < -1 || arg2 >= arg1->getNumSegments()) {
+      rb_raise(rb_eIndexError, "segment index %d out of bounds",arg2);
+    }
+  }
+  (arg1)->setAnchorSegment(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_getAnchorSegment(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar const *","getAnchorSegment", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  result = (FXint)((FXGradientBar const *)arg1)->getAnchorSegment();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_selectSegments(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","selectSegments", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  result = (FXbool)FXGradientBar_selectSegments(arg1,arg2,arg3,arg4);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_deselectSegments(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","deselectSegments", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  result = (FXbool)(arg1)->deselectSegments(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_isSegmentSelected(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar const *","isSegmentSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumSegments()) {
+      rb_raise(rb_eIndexError, "segment index %d out of bounds",arg2);
+    }
+  }
+  result = (FXbool)((FXGradientBar const *)arg1)->isSegmentSelected(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_setSegmentLowerColor(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","setSegmentLowerColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumSegments()) {
+      rb_raise(rb_eIndexError, "segment index %d out of bounds",arg2);
+    }
+  }
+  (arg1)->setSegmentLowerColor(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_setSegmentUpperColor(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","setSegmentUpperColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumSegments()) {
+      rb_raise(rb_eIndexError, "segment index %d out of bounds",arg2);
+    }
+  }
+  (arg1)->setSegmentUpperColor(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_getSegmentLowerColor(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar const *","getSegmentLowerColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumSegments()) {
+      rb_raise(rb_eIndexError, "segment index %d out of bounds",arg2);
+    }
+  }
+  result = (FXColor)((FXGradientBar const *)arg1)->getSegmentLowerColor(arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_getSegmentUpperColor(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar const *","getSegmentUpperColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumSegments()) {
+      rb_raise(rb_eIndexError, "segment index %d out of bounds",arg2);
+    }
+  }
+  result = (FXColor)((FXGradientBar const *)arg1)->getSegmentUpperColor(arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_moveSegmentLower(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  FXdouble arg3 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","moveSegmentLower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","moveSegmentLower", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  {
+    if (arg2 < 1 || arg2 >= arg1->getNumSegments()) {
+      rb_raise(rb_eIndexError, "segment index %d out of bounds",arg2);
+    }
+  }
+  (arg1)->moveSegmentLower(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_moveSegmentMiddle(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  FXdouble arg3 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","moveSegmentMiddle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","moveSegmentMiddle", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumSegments()) {
+      rb_raise(rb_eIndexError, "segment index %d out of bounds",arg2);
+    }
+  }
+  (arg1)->moveSegmentMiddle(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_moveSegmentUpper(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  FXdouble arg3 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","moveSegmentUpper", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","moveSegmentUpper", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumSegments()-1) {
+      rb_raise(rb_eIndexError, "segment index %d out of bounds",arg2);
+    }
+  }
+  (arg1)->moveSegmentUpper(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_moveSegments(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXdouble arg4 ;
+  FXbool arg5 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  
+  if ((argc < 3) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","moveSegments", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  ecode4 = SWIG_AsVal_double(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","moveSegments", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXdouble >(val4);
+  if (argc > 3) {
+    arg5 = to_FXbool(argv[3]);
+  }
+  (arg1)->moveSegments(arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_getSegmentLower(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar const *","getSegmentLower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumSegments()) {
+      rb_raise(rb_eIndexError, "segment index %d out of bounds",arg2);
+    }
+  }
+  result = (FXdouble)((FXGradientBar const *)arg1)->getSegmentLower(arg2);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_getSegmentMiddle(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar const *","getSegmentMiddle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumSegments()) {
+      rb_raise(rb_eIndexError, "segment index %d out of bounds",arg2);
+    }
+  }
+  result = (FXdouble)((FXGradientBar const *)arg1)->getSegmentMiddle(arg2);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_getSegmentUpper(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar const *","getSegmentUpper", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumSegments()) {
+      rb_raise(rb_eIndexError, "segment index %d out of bounds",arg2);
+    }
+  }
+  result = (FXdouble)((FXGradientBar const *)arg1)->getSegmentUpper(arg2);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_gradient(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (VALUE)FXGradientBar_gradient(arg1,arg2);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_getSegmentBlend(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar const *","getSegmentBlend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumSegments()) {
+      rb_raise(rb_eIndexError, "segment index %d out of bounds",arg2);
+    }
+  }
+  result = (FXuint)((FXGradientBar const *)arg1)->getSegmentBlend(arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_splitSegments(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","splitSegments", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  (arg1)->splitSegments(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_mergeSegments(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","mergeSegments", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  (arg1)->mergeSegments(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_uniformSegments(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","uniformSegments", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  (arg1)->uniformSegments(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_blendSegments(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXuint arg4 = (FXuint) GRADIENT_BLEND_LINEAR ;
+  FXbool arg5 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","blendSegments", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg5 = to_FXbool(argv[3]);
+  }
+  (arg1)->blendSegments(arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_getBarStyle(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar const *","getBarStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  result = (FXuint)((FXGradientBar const *)arg1)->getBarStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_setBarStyle(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","setBarStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setBarStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_setSelectColor(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","setSelectColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelectColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_getSelectColor(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar const *","getSelectColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  result = (FXColor)((FXGradientBar const *)arg1)->getSelectColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  result = (FXString *) &((FXGradientBar const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_setTipText(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_getTipText(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  result = (FXString *) &((FXGradientBar const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_save(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXGradientBar_save((FXGradientBar const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_load(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXGradientBar_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_create(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  FXGradientBar_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_detach(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  FXGradientBar_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_destroy(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  FXGradientBar_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_resize(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXGradientBar_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  result = (FXint)FXGradientBar_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  result = (FXint)FXGradientBar_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXGradientBar_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXGradientBar_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  result = (bool)FXGradientBar_canFocus((FXGradientBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  FXGradientBar_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  FXGradientBar_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXGradientBar_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXGradientBar_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_enable(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  FXGradientBar_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_disable(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  FXGradientBar_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  FXGradientBar_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_lower(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  FXGradientBar_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_move(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXGradientBar_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_position(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXGradientBar_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_layout(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  FXGradientBar_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_recalc(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  FXGradientBar_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_reparent(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXGradientBar_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_show(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  FXGradientBar_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_hide(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  FXGradientBar_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  result = (bool)FXGradientBar_isComposite((FXGradientBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_contains(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXGradientBar_contains((FXGradientBar const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  result = (bool)FXGradientBar_doesSaveUnder((FXGradientBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXGradientBar_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_tr(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXGradientBar_tr((FXGradientBar const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  FXGradientBar_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  FXGradientBar_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXGradientBar_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXGradientBar_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXGradientBar_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXGradientBar_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXGradientBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXGradientBar_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXGradientBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXGradientBar_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXGradientBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXGradientBar_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGradientBar_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXGradientBar *arg1 = (FXGradientBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGradientBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGradientBar *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGradientBar * >(argp1);
+  FXGradientBar_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_FXShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXShell *) x));
+}
+static void *_p_FXRootWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXRootWindow *) x));
+}
+static void *_p_FXPopupTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXTopWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXFrame *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXColorRingTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXColorBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXPopupTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXDialTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXRulerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXCompositeTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXComposite *) x));
+}
+static void *_p_FXColorWheelTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXColorWellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXProgressBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXGradientBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXStatusLineTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXTextFieldTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXHeaderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXImageFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXKnobTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXSliderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXRealSliderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXSeparator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXSeparator *)  ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXSeparator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXSeparator *)  ((FXVerticalSeparator *) x));
+}
+static void *_p_FXSettingsTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXSettings *) x));
+}
+static void *_p_FXAccelTableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXAccelTable *) x));
+}
+static void *_p_FXCompositeTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXRegistryTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *)(FXSettings *) ((FXRegistry *) x));
+}
+static void *_p_FXTextFieldTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXIconDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXIconDict *) x));
+}
+static void *_p_FXShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXPopupTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXRecentFilesTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXRecentFiles *) x));
+}
+static void *_p_FXDocumentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDocument *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXRulerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXStatusLineTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXKnobTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXStringDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXStringDict *) x));
+}
+static void *_p_FXColorWheelTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXGradientBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXFontTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXFont *) x));
+}
+static void *_p_FXFileDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXFileDict *) x));
+}
+static void *_p_FXImageFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXDataTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDataTarget *) x));
+}
+static void *_p_FXDebugTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDebugTarget *) x));
+}
+static void *_p_FXDelegatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDelegator *) x));
+}
+static void *_p_FXDrawableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXDrawable *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXCursor *) x));
+}
+static void *_p_FXProgressBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXTranslatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXTranslator *) x));
+}
+static void *_p_FXDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDict *) x));
+}
+static void *_p_FXHeaderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXColorWellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXHeaderItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXHeaderItem *) x));
+}
+static void *_p_FXDialTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXIdTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXId *) x));
+}
+static void *_p_FXFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FXSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXRealSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXVisualTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXVisual *) x));
+}
+static void *_p_FXColorRingTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXColorBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXAppTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXApp *) x));
+}
+static void *_p_FXFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXColorRingTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXColorBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXPopupTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXDialTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXRulerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *)  ((FXWindow *) x));
+}
+static void *_p_FXCompositeTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXColorWheelTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXColorWellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXProgressBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXGradientBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXStatusLineTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXTextFieldTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXHeaderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXImageFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXKnobTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXRealSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXFileStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXFileStream *) x));
+}
+static void *_p_FXMemoryStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXMemoryStream *) x));
+}
+static void *_p_FXCompositeTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXTextFieldTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXPopupTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXRulerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXStatusLineTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXKnobTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXColorWheelTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXGradientBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXFontTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXFont *) x));
+}
+static void *_p_FXImageFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXDrawableTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXDrawable *) x));
+}
+static void *_p_FXCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXProgressBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXHeaderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXColorWellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDialTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXVisualTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXVisual *) x));
+}
+static void *_p_FXColorRingTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXColorBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXToolBarTab *) x));
+}
+static void *_p_FXColorRingTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXColorRing *) x));
+}
+static void *_p_FXColorBarTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXColorBar *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXBitmapFrame *) x));
+}
+static void *_p_FXDialTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXDial *) x));
+}
+static void *_p_FXRulerTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXRuler *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXArrowButton *) x));
+}
+static void *_p_FXColorWheelTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXColorWheel *) x));
+}
+static void *_p_FXProgressBarTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXProgressBar *) x));
+}
+static void *_p_FXColorWellTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXColorWell *) x));
+}
+static void *_p_FXGradientBarTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXGradientBar *) x));
+}
+static void *_p_FXStatusLineTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXStatusLine *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXSeparator *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXTextFieldTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXTextField *) x));
+}
+static void *_p_FXHeaderTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXHeader *) x));
+}
+static void *_p_FXImageFrameTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXImageFrame *) x));
+}
+static void *_p_FXKnobTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXKnob *) x));
+}
+static void *_p_FXSliderTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXSlider *) x));
+}
+static void *_p_FXRealSliderTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXRealSlider *) x));
+}
+static swig_type_info _swigt__p_FXArrowButton = {"_p_FXArrowButton", "FXArrowButton *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXBitmap = {"_p_FXBitmap", "FXBitmap *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXBitmapFrame = {"_p_FXBitmapFrame", "FXBitmapFrame *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXColorBar = {"_p_FXColorBar", "FXColorBar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXColorRing = {"_p_FXColorRing", "FXColorRing *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXColorWell = {"_p_FXColorWell", "FXColorWell *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXColorWheel = {"_p_FXColorWheel", "FXColorWheel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXComposite = {"_p_FXComposite", "FXComposite *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXShell = {"_p_FXShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRootWindow = {"_p_FXRootWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPopup = {"_p_FXPopup", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTopWindow = {"_p_FXTopWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMainWindow = {"_p_FXMainWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplashWindow = {"_p_FXSplashWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDial = {"_p_FXDial", "FXDial *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDrawable = {"_p_FXDrawable", "FXDrawable *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFont = {"_p_FXFont", "FXFont *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFrame = {"_p_FXFrame", "FXFrame *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGradient = {"_p_FXGradient", "FXGradient *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGradientBar = {"_p_FXGradientBar", "FXGradientBar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXHeader = {"_p_FXHeader", "FXHeader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXHeaderItem = {"_p_FXHeaderItem", "FXHeaderItem *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXHorizontalSeparator = {"_p_FXHorizontalSeparator", "FXHorizontalSeparator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXIcon = {"_p_FXIcon", "FXIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXId = {"_p_FXId", "FXId *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXCursor = {"_p_FXCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCURCursor = {"_p_FXCURCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGIFCursor = {"_p_FXGIFCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVisual = {"_p_FXVisual", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImage = {"_p_FXImage", "FXImage *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXImageFrame = {"_p_FXImageFrame", "FXImageFrame *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXKnob = {"_p_FXKnob", "FXKnob *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXObject = {"_p_FXObject", "FXObject *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDict = {"_p_FXDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSettings = {"_p_FXSettings", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXAccelTable = {"_p_FXAccelTable", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRegistry = {"_p_FXRegistry", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXIconDict = {"_p_FXIconDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRecentFiles = {"_p_FXRecentFiles", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDocument = {"_p_FXDocument", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStringDict = {"_p_FXStringDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileDict = {"_p_FXFileDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDebugTarget = {"_p_FXDebugTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDataTarget = {"_p_FXDataTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDelegator = {"_p_FXDelegator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTranslator = {"_p_FXTranslator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXApp = {"_p_FXApp", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXProgressBar = {"_p_FXProgressBar", "FXProgressBar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRealSlider = {"_p_FXRealSlider", "FXRealSlider *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRegion = {"_p_FXRegion", "FXRegion *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRuler = {"_p_FXRuler", "FXRuler *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXSeparator = {"_p_FXSeparator", "FXSeparator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXSlider = {"_p_FXSlider", "FXSlider *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXStatusLine = {"_p_FXStatusLine", "FXStatusLine *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXStream = {"_p_FXStream", "FXStream *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFileStream = {"_p_FXFileStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMemoryStream = {"_p_FXMemoryStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTextField = {"_p_FXTextField", "FXTextField *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXToolBarTab = {"_p_FXToolBarTab", "FXToolBarTab *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXVerticalSeparator = {"_p_FXVerticalSeparator", "FXVerticalSeparator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXWindow = {"_p_FXWindow", "FXWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_char = {"_p_char", "char *|FXchar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "double *|FXdouble *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_float = {"_p_float", "float *|FXfloat *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "FXint *|int *|FXInputHandle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_long = {"_p_long", "long *|FXTime *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_FXGradient = {"_p_p_FXGradient", "FXGradient **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_short = {"_p_short", "short *|FXshort *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "FXuchar *|unsigned char *|FXbool *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "FXwchar *|FXDragType *|unsigned int *|FXuint *|FXColor *|FXSelector *|FXHotKey *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|FXuval *|FXPixel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|FXushort *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_FXAccelTable,
+  &_swigt__p_FXApp,
+  &_swigt__p_FXArrowButton,
+  &_swigt__p_FXBitmap,
+  &_swigt__p_FXBitmapFrame,
+  &_swigt__p_FXCURCursor,
+  &_swigt__p_FXColorBar,
+  &_swigt__p_FXColorRing,
+  &_swigt__p_FXColorWell,
+  &_swigt__p_FXColorWheel,
+  &_swigt__p_FXComposite,
+  &_swigt__p_FXCursor,
+  &_swigt__p_FXDataTarget,
+  &_swigt__p_FXDebugTarget,
+  &_swigt__p_FXDelegator,
+  &_swigt__p_FXDial,
+  &_swigt__p_FXDict,
+  &_swigt__p_FXDocument,
+  &_swigt__p_FXDrawable,
+  &_swigt__p_FXFileDict,
+  &_swigt__p_FXFileStream,
+  &_swigt__p_FXFont,
+  &_swigt__p_FXFrame,
+  &_swigt__p_FXGIFCursor,
+  &_swigt__p_FXGradient,
+  &_swigt__p_FXGradientBar,
+  &_swigt__p_FXHeader,
+  &_swigt__p_FXHeaderItem,
+  &_swigt__p_FXHorizontalSeparator,
+  &_swigt__p_FXIcon,
+  &_swigt__p_FXIconDict,
+  &_swigt__p_FXId,
+  &_swigt__p_FXImage,
+  &_swigt__p_FXImageFrame,
+  &_swigt__p_FXKnob,
+  &_swigt__p_FXMainWindow,
+  &_swigt__p_FXMemoryStream,
+  &_swigt__p_FXObject,
+  &_swigt__p_FXPopup,
+  &_swigt__p_FXProgressBar,
+  &_swigt__p_FXRealSlider,
+  &_swigt__p_FXRecentFiles,
+  &_swigt__p_FXRegion,
+  &_swigt__p_FXRegistry,
+  &_swigt__p_FXRootWindow,
+  &_swigt__p_FXRuler,
+  &_swigt__p_FXSeparator,
+  &_swigt__p_FXSettings,
+  &_swigt__p_FXShell,
+  &_swigt__p_FXSlider,
+  &_swigt__p_FXSplashWindow,
+  &_swigt__p_FXStatusLine,
+  &_swigt__p_FXStream,
+  &_swigt__p_FXStringDict,
+  &_swigt__p_FXTextField,
+  &_swigt__p_FXToolBarTab,
+  &_swigt__p_FXTopWindow,
+  &_swigt__p_FXTranslator,
+  &_swigt__p_FXVerticalSeparator,
+  &_swigt__p_FXVisual,
+  &_swigt__p_FXWindow,
+  &_swigt__p_char,
+  &_swigt__p_double,
+  &_swigt__p_float,
+  &_swigt__p_int,
+  &_swigt__p_long,
+  &_swigt__p_p_FXGradient,
+  &_swigt__p_short,
+  &_swigt__p_unsigned_char,
+  &_swigt__p_unsigned_int,
+  &_swigt__p_unsigned_long,
+  &_swigt__p_unsigned_short,
+};
+
+static swig_cast_info _swigc__p_FXArrowButton[] = {  {&_swigt__p_FXArrowButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBitmap[] = {  {&_swigt__p_FXBitmap, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBitmapFrame[] = {  {&_swigt__p_FXBitmapFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorBar[] = {  {&_swigt__p_FXColorBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorRing[] = {  {&_swigt__p_FXColorRing, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWell[] = {  {&_swigt__p_FXColorWell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWheel[] = {  {&_swigt__p_FXColorWheel, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShell[] = {{&_swigt__p_FXShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRootWindow[] = {{&_swigt__p_FXRootWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPopup[] = {{&_swigt__p_FXPopup, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTopWindow[] = {{&_swigt__p_FXTopWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMainWindow[] = {{&_swigt__p_FXMainWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplashWindow[] = {{&_swigt__p_FXSplashWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComposite[] = {  {&_swigt__p_FXComposite, 0, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXComposite, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDial[] = {  {&_swigt__p_FXDial, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDrawable[] = {  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDrawable, 0, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXDrawable, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFont[] = {  {&_swigt__p_FXFont, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFrame[] = {  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXFrame, 0, 0},  {&_swigt__p_FXFrame, 0, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXFrame, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXFrame, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXFrame, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXFrame, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXFrame, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXFrame, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXFrame, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXFrame, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXFrame, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXFrame, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXFrame, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXFrame, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXFrame, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXFrame, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXFrame, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXFrame, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXFrame, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXFrame, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXFrame, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXFrame, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGradient[] = {  {&_swigt__p_FXGradient, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGradientBar[] = {  {&_swigt__p_FXGradientBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeader[] = {  {&_swigt__p_FXHeader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeaderItem[] = {  {&_swigt__p_FXHeaderItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalSeparator[] = {  {&_swigt__p_FXHorizontalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIcon[] = {  {&_swigt__p_FXIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCursor[] = {{&_swigt__p_FXCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCURCursor[] = {{&_swigt__p_FXCURCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGIFCursor[] = {{&_swigt__p_FXGIFCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVisual[] = {{&_swigt__p_FXVisual, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXId[] = {  {&_swigt__p_FXDial, _p_FXDialTo_p_FXId, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXId, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXId, 0, 0},  {&_swigt__p_FXId, 0, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXId, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXId, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXId, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXId, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXId, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXId, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXId, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXId, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXId, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXId, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXId, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXId, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXId, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImage[] = {  {&_swigt__p_FXImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageFrame[] = {  {&_swigt__p_FXImageFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXKnob[] = {  {&_swigt__p_FXKnob, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDict[] = {{&_swigt__p_FXDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSettings[] = {{&_swigt__p_FXSettings, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXAccelTable[] = {{&_swigt__p_FXAccelTable, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegistry[] = {{&_swigt__p_FXRegistry, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIconDict[] = {{&_swigt__p_FXIconDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRecentFiles[] = {{&_swigt__p_FXRecentFiles, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDocument[] = {{&_swigt__p_FXDocument, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStringDict[] = {{&_swigt__p_FXStringDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileDict[] = {{&_swigt__p_FXFileDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDebugTarget[] = {{&_swigt__p_FXDebugTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDataTarget[] = {{&_swigt__p_FXDataTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDelegator[] = {{&_swigt__p_FXDelegator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTranslator[] = {{&_swigt__p_FXTranslator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXApp[] = {{&_swigt__p_FXApp, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXObject[] = {  {&_swigt__p_FXDict, _p_FXDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXObject, 0, 0},  {&_swigt__p_FXSettings, _p_FXSettingsTo_p_FXObject, 0, 0},  {&_swigt__p_FXAccelTable, _p_FXAccelTableTo_p_FXObject, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXObject, 0, 0},  {&_swigt__p_FXRegistry, _p_FXRegistryTo_p_FXObject, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXObject, 0, 0},  {&_swigt__p_FXId, _p_FXIdTo_p_FXObject, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXIconDict, _p_FXIconDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXObject, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXObject, 0, 0},  {&_swigt__p_FXRecentFiles, _p_FXRecentFilesTo_p_FXObject, 0, 0},  {&_swigt__p_FXDocument, _p_FXDocumentTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXObject, 0, 0},  {&_swigt__p_FXObject, 0, 0, 0},  {&_swigt__p_FXStringDict, _p_FXStringDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXObject, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileDict, _p_FXFileDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXDebugTarget, _p_FXDebugTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDataTarget, _p_FXDataTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXObject, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXObject, 0, 0},  {&_swigt__p_FXDelegator, _p_FXDelegatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXTranslator, _p_FXTranslatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXObject, 0, 0},  {&_swigt__p_FXApp, _p_FXAppTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeaderItem, _p_FXHeaderItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXObject, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXObject, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXObject, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXProgressBar[] = {  {&_swigt__p_FXProgressBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSlider[] = {  {&_swigt__p_FXRealSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegion[] = {  {&_swigt__p_FXRegion, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRuler[] = {  {&_swigt__p_FXRuler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSeparator[] = {  {&_swigt__p_FXSeparator, 0, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXSeparator, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXSeparator, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSlider[] = {  {&_swigt__p_FXSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusLine[] = {  {&_swigt__p_FXStatusLine, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileStream[] = {{&_swigt__p_FXFileStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMemoryStream[] = {{&_swigt__p_FXMemoryStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStream[] = {  {&_swigt__p_FXFileStream, _p_FXFileStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXMemoryStream, _p_FXMemoryStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTextField[] = {  {&_swigt__p_FXTextField, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarTab[] = {  {&_swigt__p_FXToolBarTab, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalSeparator[] = {  {&_swigt__p_FXVerticalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXWindow[] = {  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXWindow, 0, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXWindow, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXWindow, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXWindow, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_FXGradient[] = {  {&_swigt__p_p_FXGradient, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
+
+static swig_cast_info *swig_cast_initial[] = {
+  _swigc__p_FXAccelTable,
+  _swigc__p_FXApp,
+  _swigc__p_FXArrowButton,
+  _swigc__p_FXBitmap,
+  _swigc__p_FXBitmapFrame,
+  _swigc__p_FXCURCursor,
+  _swigc__p_FXColorBar,
+  _swigc__p_FXColorRing,
+  _swigc__p_FXColorWell,
+  _swigc__p_FXColorWheel,
+  _swigc__p_FXComposite,
+  _swigc__p_FXCursor,
+  _swigc__p_FXDataTarget,
+  _swigc__p_FXDebugTarget,
+  _swigc__p_FXDelegator,
+  _swigc__p_FXDial,
+  _swigc__p_FXDict,
+  _swigc__p_FXDocument,
+  _swigc__p_FXDrawable,
+  _swigc__p_FXFileDict,
+  _swigc__p_FXFileStream,
+  _swigc__p_FXFont,
+  _swigc__p_FXFrame,
+  _swigc__p_FXGIFCursor,
+  _swigc__p_FXGradient,
+  _swigc__p_FXGradientBar,
+  _swigc__p_FXHeader,
+  _swigc__p_FXHeaderItem,
+  _swigc__p_FXHorizontalSeparator,
+  _swigc__p_FXIcon,
+  _swigc__p_FXIconDict,
+  _swigc__p_FXId,
+  _swigc__p_FXImage,
+  _swigc__p_FXImageFrame,
+  _swigc__p_FXKnob,
+  _swigc__p_FXMainWindow,
+  _swigc__p_FXMemoryStream,
+  _swigc__p_FXObject,
+  _swigc__p_FXPopup,
+  _swigc__p_FXProgressBar,
+  _swigc__p_FXRealSlider,
+  _swigc__p_FXRecentFiles,
+  _swigc__p_FXRegion,
+  _swigc__p_FXRegistry,
+  _swigc__p_FXRootWindow,
+  _swigc__p_FXRuler,
+  _swigc__p_FXSeparator,
+  _swigc__p_FXSettings,
+  _swigc__p_FXShell,
+  _swigc__p_FXSlider,
+  _swigc__p_FXSplashWindow,
+  _swigc__p_FXStatusLine,
+  _swigc__p_FXStream,
+  _swigc__p_FXStringDict,
+  _swigc__p_FXTextField,
+  _swigc__p_FXToolBarTab,
+  _swigc__p_FXTopWindow,
+  _swigc__p_FXTranslator,
+  _swigc__p_FXVerticalSeparator,
+  _swigc__p_FXVisual,
+  _swigc__p_FXWindow,
+  _swigc__p_char,
+  _swigc__p_double,
+  _swigc__p_float,
+  _swigc__p_int,
+  _swigc__p_long,
+  _swigc__p_p_FXGradient,
+  _swigc__p_short,
+  _swigc__p_unsigned_char,
+  _swigc__p_unsigned_int,
+  _swigc__p_unsigned_long,
+  _swigc__p_unsigned_short,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned statically to an initial
+ * array. We just loop through that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded.
+ * There are three cases to handle:
+ *  1) If the cast->type has already been loaded AND the type we are adding
+ *     casting info to has not been loaded (it is in this module), THEN we
+ *     replace the cast->type pointer with the type pointer that has already
+ *     been loaded.
+ *  2) If BOTH types (the one we are adding casting info to, and the
+ *     cast->type) are loaded, THEN the cast info has already been loaded by
+ *     the previous module so we just ignore it.
+ *  3) Finally, if cast->type has not already been loaded, then we add that
+ *     swig_cast_info to the linked list (because the cast->type) pointer will
+ *     be correct.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* c-mode */
+#endif
+#endif
+
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+  size_t i;
+  swig_module_info *module_head, *iter;
+  int init;
+
+  /* check to see if the circular list has been setup, if not, set it up */
+  if (swig_module.next==0) {
+    /* Initialize the swig_module */
+    swig_module.type_initial = swig_type_initial;
+    swig_module.cast_initial = swig_cast_initial;
+    swig_module.next = &swig_module;
+    init = 1;
+  } else {
+    init = 0;
+  }
+
+  /* Try and load any already created modules */
+  module_head = SWIG_GetModule(clientdata);
+  if (!module_head) {
+    /* This is the first module loaded for this interpreter */
+    /* so set the swig module into the interpreter */
+    SWIG_SetModule(clientdata, &swig_module);
+  } else {
+    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+    iter=module_head;
+    do {
+      if (iter==&swig_module) {
+        /* Our module is already in the list, so there's nothing more to do. */
+        return;
+      }
+      iter=iter->next;
+    } while (iter!= module_head);
+
+    /* otherwise we must add our module into the list */
+    swig_module.next = module_head->next;
+    module_head->next = &swig_module;
+  }
+
+  /* When multiple interpreters are used, a module could have already been initialized in
+     a different interpreter, but not yet have a pointer in this interpreter.
+     In this case, we do not want to continue adding types... everything should be
+     set up already */
+  if (init == 0) return;
+
+  /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+  for (i = 0; i < swig_module.size; ++i) {
+    swig_type_info *type = 0;
+    swig_type_info *ret;
+    swig_cast_info *cast;
+
+#ifdef SWIGRUNTIME_DEBUG
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+
+    /* if there is another module already loaded */
+    if (swig_module.next != &swig_module) {
+      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
+    }
+    if (type) {
+      /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+      if (swig_module.type_initial[i]->clientdata) {
+	type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+      }
+    } else {
+      type = swig_module.type_initial[i];
+    }
+
+    /* Insert casting types */
+    cast = swig_module.cast_initial[i];
+    while (cast->type) {
+
+      /* Don't need to add information already in the list */
+      ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+      if (swig_module.next != &swig_module) {
+        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+      }
+      if (ret) {
+	if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+	  cast->type = ret;
+	  ret = 0;
+	} else {
+	  /* Check for casting already in the list */
+	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+	  if (!ocast) ret = 0;
+	}
+      }
+
+      if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+        if (type->cast) {
+          type->cast->prev = cast;
+          cast->next = type->cast;
+        }
+        type->cast = cast;
+      }
+      cast++;
+    }
+    /* Set entry in modules->types array equal to the type */
+    swig_module.types[i] = type;
+  }
+  swig_module.types[i] = 0;
+
+#ifdef SWIGRUNTIME_DEBUG
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+  for (i = 0; i < swig_module.size; ++i) {
+    int j = 0;
+    swig_cast_info *cast = swig_module.cast_initial[i];
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    while (cast->type) {
+      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+      cast++;
+      ++j;
+    }
+  printf("---- Total casts: %d\n",j);
+  }
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types.  It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+  size_t i;
+  swig_cast_info *equiv;
+  static int init_run = 0;
+
+  if (init_run) return;
+  init_run = 1;
+
+  for (i = 0; i < swig_module.size; i++) {
+    if (swig_module.types[i]->clientdata) {
+      equiv = swig_module.types[i]->cast;
+      while (equiv) {
+        if (!equiv->converter) {
+          if (equiv->type && !equiv->type->clientdata)
+            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+        }
+        equiv = equiv->next;
+      }
+    }
+  }
+}
+
+#ifdef __cplusplus
+#if 0
+{ /* c-mode */
+#endif
+}
+#endif
+
+/*
+
+*/
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void Init_frames(void) {
+  size_t i;
+  
+  SWIG_InitRuntime();
+  
+  
+  SWIG_InitializeModule(0);
+  for (i = 0; i < swig_module.size; i++) {
+    SWIG_define_class(swig_module.types[i]);
+  }
+  
+  SWIG_RubyInitializeTrackings();
+  
+  rb_define_const(mFox, "ARROW_NONE", SWIG_From_int(static_cast< int >(ARROW_NONE)));
+  rb_define_const(mFox, "ARROW_UP", SWIG_From_int(static_cast< int >(ARROW_UP)));
+  rb_define_const(mFox, "ARROW_DOWN", SWIG_From_int(static_cast< int >(ARROW_DOWN)));
+  rb_define_const(mFox, "ARROW_LEFT", SWIG_From_int(static_cast< int >(ARROW_LEFT)));
+  rb_define_const(mFox, "ARROW_RIGHT", SWIG_From_int(static_cast< int >(ARROW_RIGHT)));
+  rb_define_const(mFox, "ARROW_AUTO", SWIG_From_int(static_cast< int >(ARROW_AUTO)));
+  rb_define_const(mFox, "ARROW_REPEAT", SWIG_From_int(static_cast< int >(ARROW_REPEAT)));
+  rb_define_const(mFox, "ARROW_AUTOGRAY", SWIG_From_int(static_cast< int >(ARROW_AUTOGRAY)));
+  rb_define_const(mFox, "ARROW_AUTOHIDE", SWIG_From_int(static_cast< int >(ARROW_AUTOHIDE)));
+  rb_define_const(mFox, "ARROW_TOOLBAR", SWIG_From_int(static_cast< int >(ARROW_TOOLBAR)));
+  rb_define_const(mFox, "ARROW_NORMAL", SWIG_From_int(static_cast< int >(ARROW_NORMAL)));
+  
+  SwigClassFXArrowButton.klass = rb_define_class_under(mFox, "FXArrowButton", ((swig_class *) SWIGTYPE_p_FXFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXArrowButton, (void *) &SwigClassFXArrowButton);
+  rb_define_alloc_func(SwigClassFXArrowButton.klass, _wrap_FXArrowButton_allocate);
+  rb_define_method(SwigClassFXArrowButton.klass, "initialize", VALUEFUNC(_wrap_new_FXArrowButton), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "onPaint", VALUEFUNC(_wrap_FXArrowButton_onPaint), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "onUpdate", VALUEFUNC(_wrap_FXArrowButton_onUpdate), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "onEnter", VALUEFUNC(_wrap_FXArrowButton_onEnter), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "onLeave", VALUEFUNC(_wrap_FXArrowButton_onLeave), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXArrowButton_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXArrowButton_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "onUngrabbed", VALUEFUNC(_wrap_FXArrowButton_onUngrabbed), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "onRepeat", VALUEFUNC(_wrap_FXArrowButton_onRepeat), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "onAuto", VALUEFUNC(_wrap_FXArrowButton_onAuto), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "onKeyPress", VALUEFUNC(_wrap_FXArrowButton_onKeyPress), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "onKeyRelease", VALUEFUNC(_wrap_FXArrowButton_onKeyRelease), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "onHotKeyPress", VALUEFUNC(_wrap_FXArrowButton_onHotKeyPress), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "onHotKeyRelease", VALUEFUNC(_wrap_FXArrowButton_onHotKeyRelease), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "onCmdSetHelp", VALUEFUNC(_wrap_FXArrowButton_onCmdSetHelp), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "onCmdGetHelp", VALUEFUNC(_wrap_FXArrowButton_onCmdGetHelp), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "onCmdSetTip", VALUEFUNC(_wrap_FXArrowButton_onCmdSetTip), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "onCmdGetTip", VALUEFUNC(_wrap_FXArrowButton_onCmdGetTip), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "onQueryHelp", VALUEFUNC(_wrap_FXArrowButton_onQueryHelp), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "onQueryTip", VALUEFUNC(_wrap_FXArrowButton_onQueryTip), -1);
+  rb_define_const(SwigClassFXArrowButton.klass, "ID_REPEAT", SWIG_From_int(static_cast< int >(FXArrowButton::ID_REPEAT)));
+  rb_define_const(SwigClassFXArrowButton.klass, "ID_AUTO", SWIG_From_int(static_cast< int >(FXArrowButton::ID_AUTO)));
+  rb_define_const(SwigClassFXArrowButton.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXArrowButton::ID_LAST)));
+  rb_define_method(SwigClassFXArrowButton.klass, "setState", VALUEFUNC(_wrap_FXArrowButton_setState), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "getState", VALUEFUNC(_wrap_FXArrowButton_getState), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "setHelpText", VALUEFUNC(_wrap_FXArrowButton_setHelpText), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "getHelpText", VALUEFUNC(_wrap_FXArrowButton_getHelpText), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "setTipText", VALUEFUNC(_wrap_FXArrowButton_setTipText), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "getTipText", VALUEFUNC(_wrap_FXArrowButton_getTipText), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "setArrowStyle", VALUEFUNC(_wrap_FXArrowButton_setArrowStyle), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "getArrowStyle", VALUEFUNC(_wrap_FXArrowButton_getArrowStyle), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "setArrowSize", VALUEFUNC(_wrap_FXArrowButton_setArrowSize), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "getArrowSize", VALUEFUNC(_wrap_FXArrowButton_getArrowSize), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "setJustify", VALUEFUNC(_wrap_FXArrowButton_setJustify), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "getJustify", VALUEFUNC(_wrap_FXArrowButton_getJustify), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "getArrowColor", VALUEFUNC(_wrap_FXArrowButton_getArrowColor), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "setArrowColor", VALUEFUNC(_wrap_FXArrowButton_setArrowColor), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "save", VALUEFUNC(_wrap_FXArrowButton_save), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "load", VALUEFUNC(_wrap_FXArrowButton_load), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "create", VALUEFUNC(_wrap_FXArrowButton_create), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "detach", VALUEFUNC(_wrap_FXArrowButton_detach), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "destroy", VALUEFUNC(_wrap_FXArrowButton_destroy), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "resize", VALUEFUNC(_wrap_FXArrowButton_resize), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXArrowButton_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXArrowButton_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXArrowButton_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXArrowButton_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "canFocus", VALUEFUNC(_wrap_FXArrowButton_canFocus), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "setFocus", VALUEFUNC(_wrap_FXArrowButton_setFocus), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "killFocus", VALUEFUNC(_wrap_FXArrowButton_killFocus), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "changeFocus", VALUEFUNC(_wrap_FXArrowButton_changeFocus), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "setDefault", VALUEFUNC(_wrap_FXArrowButton_setDefault), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "enable", VALUEFUNC(_wrap_FXArrowButton_enable), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "disable", VALUEFUNC(_wrap_FXArrowButton_disable), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "raiseWindow", VALUEFUNC(_wrap_FXArrowButton_raiseWindow), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "lower", VALUEFUNC(_wrap_FXArrowButton_lower), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "move", VALUEFUNC(_wrap_FXArrowButton_move), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "position", VALUEFUNC(_wrap_FXArrowButton_position), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "layout", VALUEFUNC(_wrap_FXArrowButton_layout), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "recalc", VALUEFUNC(_wrap_FXArrowButton_recalc), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "reparent", VALUEFUNC(_wrap_FXArrowButton_reparent), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "show", VALUEFUNC(_wrap_FXArrowButton_show), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "hide", VALUEFUNC(_wrap_FXArrowButton_hide), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "isComposite", VALUEFUNC(_wrap_FXArrowButton_isComposite), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "contains", VALUEFUNC(_wrap_FXArrowButton_contains), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXArrowButton_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "setBackColor", VALUEFUNC(_wrap_FXArrowButton_setBackColor), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "tr", VALUEFUNC(_wrap_FXArrowButton_tr), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "dropEnable", VALUEFUNC(_wrap_FXArrowButton_dropEnable), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "dropDisable", VALUEFUNC(_wrap_FXArrowButton_dropDisable), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "setShape", VALUEFUNC(_wrap_FXArrowButton_setShape), -1);
+  rb_define_method(SwigClassFXArrowButton.klass, "clearShape", VALUEFUNC(_wrap_FXArrowButton_clearShape), -1);
+  SwigClassFXArrowButton.mark = (void (*)(void *)) FXRbArrowButton::markfunc;
+  SwigClassFXArrowButton.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXArrowButton.trackObjects = 0;
+  rb_define_const(mFox, "COLORBAR_HORIZONTAL", SWIG_From_int(static_cast< int >(COLORBAR_HORIZONTAL)));
+  rb_define_const(mFox, "COLORBAR_VERTICAL", SWIG_From_int(static_cast< int >(COLORBAR_VERTICAL)));
+  
+  SwigClassFXColorBar.klass = rb_define_class_under(mFox, "FXColorBar", ((swig_class *) SWIGTYPE_p_FXFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXColorBar, (void *) &SwigClassFXColorBar);
+  rb_define_alloc_func(SwigClassFXColorBar.klass, _wrap_FXColorBar_allocate);
+  rb_define_method(SwigClassFXColorBar.klass, "initialize", VALUEFUNC(_wrap_new_FXColorBar), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "onPaint", VALUEFUNC(_wrap_FXColorBar_onPaint), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXColorBar_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXColorBar_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "onMotion", VALUEFUNC(_wrap_FXColorBar_onMotion), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "onCmdSetHelp", VALUEFUNC(_wrap_FXColorBar_onCmdSetHelp), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "onCmdGetHelp", VALUEFUNC(_wrap_FXColorBar_onCmdGetHelp), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "onCmdSetTip", VALUEFUNC(_wrap_FXColorBar_onCmdSetTip), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "onCmdGetTip", VALUEFUNC(_wrap_FXColorBar_onCmdGetTip), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "onQueryHelp", VALUEFUNC(_wrap_FXColorBar_onQueryHelp), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "onQueryTip", VALUEFUNC(_wrap_FXColorBar_onQueryTip), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "setHue", VALUEFUNC(_wrap_FXColorBar_setHue), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "getHue", VALUEFUNC(_wrap_FXColorBar_getHue), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "setSat", VALUEFUNC(_wrap_FXColorBar_setSat), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "getSat", VALUEFUNC(_wrap_FXColorBar_getSat), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "setVal", VALUEFUNC(_wrap_FXColorBar_setVal), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "getVal", VALUEFUNC(_wrap_FXColorBar_getVal), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "getBarStyle", VALUEFUNC(_wrap_FXColorBar_getBarStyle), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "setBarStyle", VALUEFUNC(_wrap_FXColorBar_setBarStyle), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "setHelpText", VALUEFUNC(_wrap_FXColorBar_setHelpText), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "getHelpText", VALUEFUNC(_wrap_FXColorBar_getHelpText), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "setTipText", VALUEFUNC(_wrap_FXColorBar_setTipText), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "getTipText", VALUEFUNC(_wrap_FXColorBar_getTipText), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "save", VALUEFUNC(_wrap_FXColorBar_save), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "load", VALUEFUNC(_wrap_FXColorBar_load), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "create", VALUEFUNC(_wrap_FXColorBar_create), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "detach", VALUEFUNC(_wrap_FXColorBar_detach), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "destroy", VALUEFUNC(_wrap_FXColorBar_destroy), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "resize", VALUEFUNC(_wrap_FXColorBar_resize), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXColorBar_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXColorBar_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXColorBar_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXColorBar_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "canFocus", VALUEFUNC(_wrap_FXColorBar_canFocus), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "setFocus", VALUEFUNC(_wrap_FXColorBar_setFocus), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "killFocus", VALUEFUNC(_wrap_FXColorBar_killFocus), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "changeFocus", VALUEFUNC(_wrap_FXColorBar_changeFocus), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "setDefault", VALUEFUNC(_wrap_FXColorBar_setDefault), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "enable", VALUEFUNC(_wrap_FXColorBar_enable), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "disable", VALUEFUNC(_wrap_FXColorBar_disable), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "raiseWindow", VALUEFUNC(_wrap_FXColorBar_raiseWindow), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "lower", VALUEFUNC(_wrap_FXColorBar_lower), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "move", VALUEFUNC(_wrap_FXColorBar_move), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "position", VALUEFUNC(_wrap_FXColorBar_position), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "layout", VALUEFUNC(_wrap_FXColorBar_layout), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "recalc", VALUEFUNC(_wrap_FXColorBar_recalc), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "reparent", VALUEFUNC(_wrap_FXColorBar_reparent), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "show", VALUEFUNC(_wrap_FXColorBar_show), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "hide", VALUEFUNC(_wrap_FXColorBar_hide), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "isComposite", VALUEFUNC(_wrap_FXColorBar_isComposite), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "contains", VALUEFUNC(_wrap_FXColorBar_contains), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXColorBar_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "setBackColor", VALUEFUNC(_wrap_FXColorBar_setBackColor), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "tr", VALUEFUNC(_wrap_FXColorBar_tr), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "dropEnable", VALUEFUNC(_wrap_FXColorBar_dropEnable), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "dropDisable", VALUEFUNC(_wrap_FXColorBar_dropDisable), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "setShape", VALUEFUNC(_wrap_FXColorBar_setShape), -1);
+  rb_define_method(SwigClassFXColorBar.klass, "clearShape", VALUEFUNC(_wrap_FXColorBar_clearShape), -1);
+  SwigClassFXColorBar.mark = (void (*)(void *)) FXRbColorBar::markfunc;
+  SwigClassFXColorBar.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXColorBar.trackObjects = 0;
+  
+  SwigClassFXColorRing.klass = rb_define_class_under(mFox, "FXColorRing", ((swig_class *) SWIGTYPE_p_FXFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXColorRing, (void *) &SwigClassFXColorRing);
+  rb_define_alloc_func(SwigClassFXColorRing.klass, _wrap_FXColorRing_allocate);
+  rb_define_method(SwigClassFXColorRing.klass, "initialize", VALUEFUNC(_wrap_new_FXColorRing), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "onPaint", VALUEFUNC(_wrap_FXColorRing_onPaint), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXColorRing_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXColorRing_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "onMotion", VALUEFUNC(_wrap_FXColorRing_onMotion), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "onMouseWheel", VALUEFUNC(_wrap_FXColorRing_onMouseWheel), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "onCmdSetHelp", VALUEFUNC(_wrap_FXColorRing_onCmdSetHelp), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "onCmdGetHelp", VALUEFUNC(_wrap_FXColorRing_onCmdGetHelp), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "onCmdSetTip", VALUEFUNC(_wrap_FXColorRing_onCmdSetTip), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "onCmdGetTip", VALUEFUNC(_wrap_FXColorRing_onCmdGetTip), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "onQueryHelp", VALUEFUNC(_wrap_FXColorRing_onQueryHelp), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "onQueryTip", VALUEFUNC(_wrap_FXColorRing_onQueryTip), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "hue=", VALUEFUNC(_wrap_FXColorRing_huee___), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "hue", VALUEFUNC(_wrap_FXColorRing_hue), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "sat=", VALUEFUNC(_wrap_FXColorRing_sate___), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "sat", VALUEFUNC(_wrap_FXColorRing_sat), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "val=", VALUEFUNC(_wrap_FXColorRing_vale___), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "val", VALUEFUNC(_wrap_FXColorRing_val), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "setHueSatVal", VALUEFUNC(_wrap_FXColorRing_setHueSatVal), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "ringWidth=", VALUEFUNC(_wrap_FXColorRing_ringWidthe___), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "ringWidth", VALUEFUNC(_wrap_FXColorRing_ringWidth), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "helpText=", VALUEFUNC(_wrap_FXColorRing_helpTexte___), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "helpText", VALUEFUNC(_wrap_FXColorRing_helpText), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "tipText=", VALUEFUNC(_wrap_FXColorRing_tipTexte___), -1);
+  rb_define_method(SwigClassFXColorRing.klass, "tipText", VALUEFUNC(_wrap_FXColorRing_tipText), -1);
+  SwigClassFXColorRing.mark = 0;
+  SwigClassFXColorRing.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXColorRing.trackObjects = 0;
+  rb_define_const(mFox, "COLORWELL_OPAQUEONLY", SWIG_From_int(static_cast< int >(COLORWELL_OPAQUEONLY)));
+  rb_define_const(mFox, "COLORWELL_SOURCEONLY", SWIG_From_int(static_cast< int >(COLORWELL_SOURCEONLY)));
+  rb_define_const(mFox, "COLORWELL_NORMAL", SWIG_From_int(static_cast< int >(COLORWELL_NORMAL)));
+  
+  SwigClassFXColorWell.klass = rb_define_class_under(mFox, "FXColorWell", ((swig_class *) SWIGTYPE_p_FXFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXColorWell, (void *) &SwigClassFXColorWell);
+  rb_define_alloc_func(SwigClassFXColorWell.klass, _wrap_FXColorWell_allocate);
+  rb_define_method(SwigClassFXColorWell.klass, "initialize", VALUEFUNC(_wrap_new_FXColorWell), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onPaint", VALUEFUNC(_wrap_FXColorWell_onPaint), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXColorWell_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXColorWell_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onMiddleBtnPress", VALUEFUNC(_wrap_FXColorWell_onMiddleBtnPress), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onMiddleBtnRelease", VALUEFUNC(_wrap_FXColorWell_onMiddleBtnRelease), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onKeyPress", VALUEFUNC(_wrap_FXColorWell_onKeyPress), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onKeyRelease", VALUEFUNC(_wrap_FXColorWell_onKeyRelease), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onUngrabbed", VALUEFUNC(_wrap_FXColorWell_onUngrabbed), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onMotion", VALUEFUNC(_wrap_FXColorWell_onMotion), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onBeginDrag", VALUEFUNC(_wrap_FXColorWell_onBeginDrag), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onEndDrag", VALUEFUNC(_wrap_FXColorWell_onEndDrag), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onDragged", VALUEFUNC(_wrap_FXColorWell_onDragged), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onFocusIn", VALUEFUNC(_wrap_FXColorWell_onFocusIn), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onFocusOut", VALUEFUNC(_wrap_FXColorWell_onFocusOut), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onDNDEnter", VALUEFUNC(_wrap_FXColorWell_onDNDEnter), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onDNDLeave", VALUEFUNC(_wrap_FXColorWell_onDNDLeave), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onDNDMotion", VALUEFUNC(_wrap_FXColorWell_onDNDMotion), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onDNDDrop", VALUEFUNC(_wrap_FXColorWell_onDNDDrop), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onDNDRequest", VALUEFUNC(_wrap_FXColorWell_onDNDRequest), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onSelectionLost", VALUEFUNC(_wrap_FXColorWell_onSelectionLost), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onSelectionGained", VALUEFUNC(_wrap_FXColorWell_onSelectionGained), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onSelectionRequest", VALUEFUNC(_wrap_FXColorWell_onSelectionRequest), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onClicked", VALUEFUNC(_wrap_FXColorWell_onClicked), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onDoubleClicked", VALUEFUNC(_wrap_FXColorWell_onDoubleClicked), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXColorWell_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXColorWell_onCmdSetIntValue), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXColorWell_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onCmdColorWell", VALUEFUNC(_wrap_FXColorWell_onCmdColorWell), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onChgColorWell", VALUEFUNC(_wrap_FXColorWell_onChgColorWell), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onCmdSetHelp", VALUEFUNC(_wrap_FXColorWell_onCmdSetHelp), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onCmdGetHelp", VALUEFUNC(_wrap_FXColorWell_onCmdGetHelp), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onCmdSetTip", VALUEFUNC(_wrap_FXColorWell_onCmdSetTip), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onCmdGetTip", VALUEFUNC(_wrap_FXColorWell_onCmdGetTip), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onQueryHelp", VALUEFUNC(_wrap_FXColorWell_onQueryHelp), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "onQueryTip", VALUEFUNC(_wrap_FXColorWell_onQueryTip), -1);
+  rb_define_const(SwigClassFXColorWell.klass, "ID_COLORDIALOG", SWIG_From_int(static_cast< int >(FXColorWell::ID_COLORDIALOG)));
+  rb_define_const(SwigClassFXColorWell.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXColorWell::ID_LAST)));
+  rb_define_method(SwigClassFXColorWell.klass, "setRGBA", VALUEFUNC(_wrap_FXColorWell_setRGBA), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "getRGBA", VALUEFUNC(_wrap_FXColorWell_getRGBA), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "setHelpText", VALUEFUNC(_wrap_FXColorWell_setHelpText), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "getHelpText", VALUEFUNC(_wrap_FXColorWell_getHelpText), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "setTipText", VALUEFUNC(_wrap_FXColorWell_setTipText), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "getTipText", VALUEFUNC(_wrap_FXColorWell_getTipText), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "isOpaqueOnly", VALUEFUNC(_wrap_FXColorWell_isOpaqueOnly), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "setOpaqueOnly", VALUEFUNC(_wrap_FXColorWell_setOpaqueOnly), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "save", VALUEFUNC(_wrap_FXColorWell_save), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "load", VALUEFUNC(_wrap_FXColorWell_load), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "create", VALUEFUNC(_wrap_FXColorWell_create), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "detach", VALUEFUNC(_wrap_FXColorWell_detach), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "destroy", VALUEFUNC(_wrap_FXColorWell_destroy), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "resize", VALUEFUNC(_wrap_FXColorWell_resize), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXColorWell_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXColorWell_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXColorWell_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXColorWell_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "canFocus", VALUEFUNC(_wrap_FXColorWell_canFocus), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "setFocus", VALUEFUNC(_wrap_FXColorWell_setFocus), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "killFocus", VALUEFUNC(_wrap_FXColorWell_killFocus), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "changeFocus", VALUEFUNC(_wrap_FXColorWell_changeFocus), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "setDefault", VALUEFUNC(_wrap_FXColorWell_setDefault), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "enable", VALUEFUNC(_wrap_FXColorWell_enable), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "disable", VALUEFUNC(_wrap_FXColorWell_disable), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "raiseWindow", VALUEFUNC(_wrap_FXColorWell_raiseWindow), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "lower", VALUEFUNC(_wrap_FXColorWell_lower), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "move", VALUEFUNC(_wrap_FXColorWell_move), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "position", VALUEFUNC(_wrap_FXColorWell_position), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "layout", VALUEFUNC(_wrap_FXColorWell_layout), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "recalc", VALUEFUNC(_wrap_FXColorWell_recalc), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "reparent", VALUEFUNC(_wrap_FXColorWell_reparent), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "show", VALUEFUNC(_wrap_FXColorWell_show), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "hide", VALUEFUNC(_wrap_FXColorWell_hide), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "isComposite", VALUEFUNC(_wrap_FXColorWell_isComposite), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "contains", VALUEFUNC(_wrap_FXColorWell_contains), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXColorWell_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "setBackColor", VALUEFUNC(_wrap_FXColorWell_setBackColor), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "tr", VALUEFUNC(_wrap_FXColorWell_tr), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "dropEnable", VALUEFUNC(_wrap_FXColorWell_dropEnable), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "dropDisable", VALUEFUNC(_wrap_FXColorWell_dropDisable), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "setShape", VALUEFUNC(_wrap_FXColorWell_setShape), -1);
+  rb_define_method(SwigClassFXColorWell.klass, "clearShape", VALUEFUNC(_wrap_FXColorWell_clearShape), -1);
+  SwigClassFXColorWell.mark = (void (*)(void *)) FXRbColorWell::markfunc;
+  SwigClassFXColorWell.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXColorWell.trackObjects = 0;
+  
+  SwigClassFXColorWheel.klass = rb_define_class_under(mFox, "FXColorWheel", ((swig_class *) SWIGTYPE_p_FXFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXColorWheel, (void *) &SwigClassFXColorWheel);
+  rb_define_alloc_func(SwigClassFXColorWheel.klass, _wrap_FXColorWheel_allocate);
+  rb_define_method(SwigClassFXColorWheel.klass, "initialize", VALUEFUNC(_wrap_new_FXColorWheel), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "onPaint", VALUEFUNC(_wrap_FXColorWheel_onPaint), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXColorWheel_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXColorWheel_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "onMotion", VALUEFUNC(_wrap_FXColorWheel_onMotion), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "onMouseWheel", VALUEFUNC(_wrap_FXColorWheel_onMouseWheel), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "onCmdSetHelp", VALUEFUNC(_wrap_FXColorWheel_onCmdSetHelp), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "onCmdGetHelp", VALUEFUNC(_wrap_FXColorWheel_onCmdGetHelp), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "onCmdSetTip", VALUEFUNC(_wrap_FXColorWheel_onCmdSetTip), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "onCmdGetTip", VALUEFUNC(_wrap_FXColorWheel_onCmdGetTip), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "onQueryHelp", VALUEFUNC(_wrap_FXColorWheel_onQueryHelp), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "onQueryTip", VALUEFUNC(_wrap_FXColorWheel_onQueryTip), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "setHue", VALUEFUNC(_wrap_FXColorWheel_setHue), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "getHue", VALUEFUNC(_wrap_FXColorWheel_getHue), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "setSat", VALUEFUNC(_wrap_FXColorWheel_setSat), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "getSat", VALUEFUNC(_wrap_FXColorWheel_getSat), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "setVal", VALUEFUNC(_wrap_FXColorWheel_setVal), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "getVal", VALUEFUNC(_wrap_FXColorWheel_getVal), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "setHueSatVal", VALUEFUNC(_wrap_FXColorWheel_setHueSatVal), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "setHelpText", VALUEFUNC(_wrap_FXColorWheel_setHelpText), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "getHelpText", VALUEFUNC(_wrap_FXColorWheel_getHelpText), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "setTipText", VALUEFUNC(_wrap_FXColorWheel_setTipText), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "getTipText", VALUEFUNC(_wrap_FXColorWheel_getTipText), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "save", VALUEFUNC(_wrap_FXColorWheel_save), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "load", VALUEFUNC(_wrap_FXColorWheel_load), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "create", VALUEFUNC(_wrap_FXColorWheel_create), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "detach", VALUEFUNC(_wrap_FXColorWheel_detach), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "destroy", VALUEFUNC(_wrap_FXColorWheel_destroy), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "resize", VALUEFUNC(_wrap_FXColorWheel_resize), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXColorWheel_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXColorWheel_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXColorWheel_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXColorWheel_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "canFocus", VALUEFUNC(_wrap_FXColorWheel_canFocus), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "setFocus", VALUEFUNC(_wrap_FXColorWheel_setFocus), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "killFocus", VALUEFUNC(_wrap_FXColorWheel_killFocus), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "changeFocus", VALUEFUNC(_wrap_FXColorWheel_changeFocus), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "setDefault", VALUEFUNC(_wrap_FXColorWheel_setDefault), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "enable", VALUEFUNC(_wrap_FXColorWheel_enable), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "disable", VALUEFUNC(_wrap_FXColorWheel_disable), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "raiseWindow", VALUEFUNC(_wrap_FXColorWheel_raiseWindow), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "lower", VALUEFUNC(_wrap_FXColorWheel_lower), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "move", VALUEFUNC(_wrap_FXColorWheel_move), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "position", VALUEFUNC(_wrap_FXColorWheel_position), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "layout", VALUEFUNC(_wrap_FXColorWheel_layout), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "recalc", VALUEFUNC(_wrap_FXColorWheel_recalc), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "reparent", VALUEFUNC(_wrap_FXColorWheel_reparent), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "show", VALUEFUNC(_wrap_FXColorWheel_show), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "hide", VALUEFUNC(_wrap_FXColorWheel_hide), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "isComposite", VALUEFUNC(_wrap_FXColorWheel_isComposite), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "contains", VALUEFUNC(_wrap_FXColorWheel_contains), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXColorWheel_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "setBackColor", VALUEFUNC(_wrap_FXColorWheel_setBackColor), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "tr", VALUEFUNC(_wrap_FXColorWheel_tr), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "dropEnable", VALUEFUNC(_wrap_FXColorWheel_dropEnable), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "dropDisable", VALUEFUNC(_wrap_FXColorWheel_dropDisable), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "setShape", VALUEFUNC(_wrap_FXColorWheel_setShape), -1);
+  rb_define_method(SwigClassFXColorWheel.klass, "clearShape", VALUEFUNC(_wrap_FXColorWheel_clearShape), -1);
+  SwigClassFXColorWheel.mark = (void (*)(void *)) FXRbColorWheel::markfunc;
+  SwigClassFXColorWheel.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXColorWheel.trackObjects = 0;
+  rb_define_const(mFox, "DIAL_VERTICAL", SWIG_From_int(static_cast< int >(DIAL_VERTICAL)));
+  rb_define_const(mFox, "DIAL_HORIZONTAL", SWIG_From_int(static_cast< int >(DIAL_HORIZONTAL)));
+  rb_define_const(mFox, "DIAL_CYCLIC", SWIG_From_int(static_cast< int >(DIAL_CYCLIC)));
+  rb_define_const(mFox, "DIAL_HAS_NOTCH", SWIG_From_int(static_cast< int >(DIAL_HAS_NOTCH)));
+  rb_define_const(mFox, "DIAL_NORMAL", SWIG_From_int(static_cast< int >(DIAL_NORMAL)));
+  
+  SwigClassFXDial.klass = rb_define_class_under(mFox, "FXDial", ((swig_class *) SWIGTYPE_p_FXFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXDial, (void *) &SwigClassFXDial);
+  rb_define_alloc_func(SwigClassFXDial.klass, _wrap_FXDial_allocate);
+  rb_define_method(SwigClassFXDial.klass, "initialize", VALUEFUNC(_wrap_new_FXDial), -1);
+  rb_define_method(SwigClassFXDial.klass, "onPaint", VALUEFUNC(_wrap_FXDial_onPaint), -1);
+  rb_define_method(SwigClassFXDial.klass, "onMotion", VALUEFUNC(_wrap_FXDial_onMotion), -1);
+  rb_define_method(SwigClassFXDial.klass, "onMouseWheel", VALUEFUNC(_wrap_FXDial_onMouseWheel), -1);
+  rb_define_method(SwigClassFXDial.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXDial_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXDial.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXDial_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXDial.klass, "onKeyPress", VALUEFUNC(_wrap_FXDial_onKeyPress), -1);
+  rb_define_method(SwigClassFXDial.klass, "onKeyRelease", VALUEFUNC(_wrap_FXDial_onKeyRelease), -1);
+  rb_define_method(SwigClassFXDial.klass, "onUngrabbed", VALUEFUNC(_wrap_FXDial_onUngrabbed), -1);
+  rb_define_method(SwigClassFXDial.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXDial_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXDial.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXDial_onCmdSetIntValue), -1);
+  rb_define_method(SwigClassFXDial.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXDial_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXDial.klass, "onCmdSetRealValue", VALUEFUNC(_wrap_FXDial_onCmdSetRealValue), -1);
+  rb_define_method(SwigClassFXDial.klass, "onCmdGetRealValue", VALUEFUNC(_wrap_FXDial_onCmdGetRealValue), -1);
+  rb_define_method(SwigClassFXDial.klass, "onCmdSetIntRange", VALUEFUNC(_wrap_FXDial_onCmdSetIntRange), -1);
+  rb_define_method(SwigClassFXDial.klass, "onCmdGetIntRange", VALUEFUNC(_wrap_FXDial_onCmdGetIntRange), -1);
+  rb_define_method(SwigClassFXDial.klass, "onCmdSetRealRange", VALUEFUNC(_wrap_FXDial_onCmdSetRealRange), -1);
+  rb_define_method(SwigClassFXDial.klass, "onCmdGetRealRange", VALUEFUNC(_wrap_FXDial_onCmdGetRealRange), -1);
+  rb_define_method(SwigClassFXDial.klass, "onCmdSetHelp", VALUEFUNC(_wrap_FXDial_onCmdSetHelp), -1);
+  rb_define_method(SwigClassFXDial.klass, "onCmdGetHelp", VALUEFUNC(_wrap_FXDial_onCmdGetHelp), -1);
+  rb_define_method(SwigClassFXDial.klass, "onCmdSetTip", VALUEFUNC(_wrap_FXDial_onCmdSetTip), -1);
+  rb_define_method(SwigClassFXDial.klass, "onCmdGetTip", VALUEFUNC(_wrap_FXDial_onCmdGetTip), -1);
+  rb_define_method(SwigClassFXDial.klass, "onQueryHelp", VALUEFUNC(_wrap_FXDial_onQueryHelp), -1);
+  rb_define_method(SwigClassFXDial.klass, "onQueryTip", VALUEFUNC(_wrap_FXDial_onQueryTip), -1);
+  rb_define_method(SwigClassFXDial.klass, "setValue", VALUEFUNC(_wrap_FXDial_setValue), -1);
+  rb_define_method(SwigClassFXDial.klass, "getValue", VALUEFUNC(_wrap_FXDial_getValue), -1);
+  rb_define_method(SwigClassFXDial.klass, "setRange", VALUEFUNC(_wrap_FXDial_setRange), -1);
+  rb_define_method(SwigClassFXDial.klass, "getRange", VALUEFUNC(_wrap_FXDial_getRange), -1);
+  rb_define_method(SwigClassFXDial.klass, "setRevolutionIncrement", VALUEFUNC(_wrap_FXDial_setRevolutionIncrement), -1);
+  rb_define_method(SwigClassFXDial.klass, "getRevolutionIncrement", VALUEFUNC(_wrap_FXDial_getRevolutionIncrement), -1);
+  rb_define_method(SwigClassFXDial.klass, "setNotchSpacing", VALUEFUNC(_wrap_FXDial_setNotchSpacing), -1);
+  rb_define_method(SwigClassFXDial.klass, "getNotchSpacing", VALUEFUNC(_wrap_FXDial_getNotchSpacing), -1);
+  rb_define_method(SwigClassFXDial.klass, "setNotchOffset", VALUEFUNC(_wrap_FXDial_setNotchOffset), -1);
+  rb_define_method(SwigClassFXDial.klass, "getNotchOffset", VALUEFUNC(_wrap_FXDial_getNotchOffset), -1);
+  rb_define_method(SwigClassFXDial.klass, "setDialStyle", VALUEFUNC(_wrap_FXDial_setDialStyle), -1);
+  rb_define_method(SwigClassFXDial.klass, "getDialStyle", VALUEFUNC(_wrap_FXDial_getDialStyle), -1);
+  rb_define_method(SwigClassFXDial.klass, "setNotchColor", VALUEFUNC(_wrap_FXDial_setNotchColor), -1);
+  rb_define_method(SwigClassFXDial.klass, "getNotchColor", VALUEFUNC(_wrap_FXDial_getNotchColor), -1);
+  rb_define_method(SwigClassFXDial.klass, "setHelpText", VALUEFUNC(_wrap_FXDial_setHelpText), -1);
+  rb_define_method(SwigClassFXDial.klass, "getHelpText", VALUEFUNC(_wrap_FXDial_getHelpText), -1);
+  rb_define_method(SwigClassFXDial.klass, "setTipText", VALUEFUNC(_wrap_FXDial_setTipText), -1);
+  rb_define_method(SwigClassFXDial.klass, "getTipText", VALUEFUNC(_wrap_FXDial_getTipText), -1);
+  rb_define_method(SwigClassFXDial.klass, "save", VALUEFUNC(_wrap_FXDial_save), -1);
+  rb_define_method(SwigClassFXDial.klass, "load", VALUEFUNC(_wrap_FXDial_load), -1);
+  rb_define_method(SwigClassFXDial.klass, "create", VALUEFUNC(_wrap_FXDial_create), -1);
+  rb_define_method(SwigClassFXDial.klass, "detach", VALUEFUNC(_wrap_FXDial_detach), -1);
+  rb_define_method(SwigClassFXDial.klass, "destroy", VALUEFUNC(_wrap_FXDial_destroy), -1);
+  rb_define_method(SwigClassFXDial.klass, "resize", VALUEFUNC(_wrap_FXDial_resize), -1);
+  rb_define_method(SwigClassFXDial.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXDial_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXDial.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXDial_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXDial.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXDial_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXDial.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXDial_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXDial.klass, "canFocus", VALUEFUNC(_wrap_FXDial_canFocus), -1);
+  rb_define_method(SwigClassFXDial.klass, "setFocus", VALUEFUNC(_wrap_FXDial_setFocus), -1);
+  rb_define_method(SwigClassFXDial.klass, "killFocus", VALUEFUNC(_wrap_FXDial_killFocus), -1);
+  rb_define_method(SwigClassFXDial.klass, "changeFocus", VALUEFUNC(_wrap_FXDial_changeFocus), -1);
+  rb_define_method(SwigClassFXDial.klass, "setDefault", VALUEFUNC(_wrap_FXDial_setDefault), -1);
+  rb_define_method(SwigClassFXDial.klass, "enable", VALUEFUNC(_wrap_FXDial_enable), -1);
+  rb_define_method(SwigClassFXDial.klass, "disable", VALUEFUNC(_wrap_FXDial_disable), -1);
+  rb_define_method(SwigClassFXDial.klass, "raiseWindow", VALUEFUNC(_wrap_FXDial_raiseWindow), -1);
+  rb_define_method(SwigClassFXDial.klass, "lower", VALUEFUNC(_wrap_FXDial_lower), -1);
+  rb_define_method(SwigClassFXDial.klass, "move", VALUEFUNC(_wrap_FXDial_move), -1);
+  rb_define_method(SwigClassFXDial.klass, "position", VALUEFUNC(_wrap_FXDial_position), -1);
+  rb_define_method(SwigClassFXDial.klass, "layout", VALUEFUNC(_wrap_FXDial_layout), -1);
+  rb_define_method(SwigClassFXDial.klass, "recalc", VALUEFUNC(_wrap_FXDial_recalc), -1);
+  rb_define_method(SwigClassFXDial.klass, "reparent", VALUEFUNC(_wrap_FXDial_reparent), -1);
+  rb_define_method(SwigClassFXDial.klass, "show", VALUEFUNC(_wrap_FXDial_show), -1);
+  rb_define_method(SwigClassFXDial.klass, "hide", VALUEFUNC(_wrap_FXDial_hide), -1);
+  rb_define_method(SwigClassFXDial.klass, "isComposite", VALUEFUNC(_wrap_FXDial_isComposite), -1);
+  rb_define_method(SwigClassFXDial.klass, "contains", VALUEFUNC(_wrap_FXDial_contains), -1);
+  rb_define_method(SwigClassFXDial.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXDial_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXDial.klass, "setBackColor", VALUEFUNC(_wrap_FXDial_setBackColor), -1);
+  rb_define_method(SwigClassFXDial.klass, "tr", VALUEFUNC(_wrap_FXDial_tr), -1);
+  rb_define_method(SwigClassFXDial.klass, "dropEnable", VALUEFUNC(_wrap_FXDial_dropEnable), -1);
+  rb_define_method(SwigClassFXDial.klass, "dropDisable", VALUEFUNC(_wrap_FXDial_dropDisable), -1);
+  rb_define_method(SwigClassFXDial.klass, "setShape", VALUEFUNC(_wrap_FXDial_setShape), -1);
+  rb_define_method(SwigClassFXDial.klass, "clearShape", VALUEFUNC(_wrap_FXDial_clearShape), -1);
+  SwigClassFXDial.mark = (void (*)(void *)) FXRbDial::markfunc;
+  SwigClassFXDial.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXDial.trackObjects = 0;
+  rb_define_const(mFox, "HEADER_BUTTON", SWIG_From_int(static_cast< int >(HEADER_BUTTON)));
+  rb_define_const(mFox, "HEADER_HORIZONTAL", SWIG_From_int(static_cast< int >(HEADER_HORIZONTAL)));
+  rb_define_const(mFox, "HEADER_VERTICAL", SWIG_From_int(static_cast< int >(HEADER_VERTICAL)));
+  rb_define_const(mFox, "HEADER_TRACKING", SWIG_From_int(static_cast< int >(HEADER_TRACKING)));
+  rb_define_const(mFox, "HEADER_RESIZE", SWIG_From_int(static_cast< int >(HEADER_RESIZE)));
+  rb_define_const(mFox, "HEADER_NORMAL", SWIG_From_int(static_cast< int >(HEADER_NORMAL)));
+  
+  SwigClassFXHeaderItem.klass = rb_define_class_under(mFox, "FXHeaderItem", ((swig_class *) SWIGTYPE_p_FXObject->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXHeaderItem, (void *) &SwigClassFXHeaderItem);
+  rb_define_alloc_func(SwigClassFXHeaderItem.klass, _wrap_FXHeaderItem_allocate);
+  rb_define_method(SwigClassFXHeaderItem.klass, "initialize", VALUEFUNC(_wrap_new_FXHeaderItem), -1);
+  rb_define_const(SwigClassFXHeaderItem.klass, "ARROW_NONE", SWIG_From_int(static_cast< int >(FXHeaderItem::ARROW_NONE)));
+  rb_define_const(SwigClassFXHeaderItem.klass, "ARROW_UP", SWIG_From_int(static_cast< int >(FXHeaderItem::ARROW_UP)));
+  rb_define_const(SwigClassFXHeaderItem.klass, "ARROW_DOWN", SWIG_From_int(static_cast< int >(FXHeaderItem::ARROW_DOWN)));
+  rb_define_const(SwigClassFXHeaderItem.klass, "PRESSED", SWIG_From_int(static_cast< int >(FXHeaderItem::PRESSED)));
+  rb_define_const(SwigClassFXHeaderItem.klass, "RIGHT", SWIG_From_int(static_cast< int >(FXHeaderItem::RIGHT)));
+  rb_define_const(SwigClassFXHeaderItem.klass, "LEFT", SWIG_From_int(static_cast< int >(FXHeaderItem::LEFT)));
+  rb_define_const(SwigClassFXHeaderItem.klass, "CENTER_X", SWIG_From_int(static_cast< int >(FXHeaderItem::CENTER_X)));
+  rb_define_const(SwigClassFXHeaderItem.klass, "TOP", SWIG_From_int(static_cast< int >(FXHeaderItem::TOP)));
+  rb_define_const(SwigClassFXHeaderItem.klass, "BOTTOM", SWIG_From_int(static_cast< int >(FXHeaderItem::BOTTOM)));
+  rb_define_const(SwigClassFXHeaderItem.klass, "CENTER_Y", SWIG_From_int(static_cast< int >(FXHeaderItem::CENTER_Y)));
+  rb_define_const(SwigClassFXHeaderItem.klass, "BEFORE", SWIG_From_int(static_cast< int >(FXHeaderItem::BEFORE)));
+  rb_define_const(SwigClassFXHeaderItem.klass, "AFTER", SWIG_From_int(static_cast< int >(FXHeaderItem::AFTER)));
+  rb_define_const(SwigClassFXHeaderItem.klass, "ABOVE", SWIG_From_int(static_cast< int >(FXHeaderItem::ABOVE)));
+  rb_define_const(SwigClassFXHeaderItem.klass, "BELOW", SWIG_From_int(static_cast< int >(FXHeaderItem::BELOW)));
+  rb_define_method(SwigClassFXHeaderItem.klass, "getText", VALUEFUNC(_wrap_FXHeaderItem_getText), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "getIcon", VALUEFUNC(_wrap_FXHeaderItem_getIcon), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "setData", VALUEFUNC(_wrap_FXHeaderItem_setData), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "getData", VALUEFUNC(_wrap_FXHeaderItem_getData), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "setSize", VALUEFUNC(_wrap_FXHeaderItem_setSize), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "getSize", VALUEFUNC(_wrap_FXHeaderItem_getSize), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "setPos", VALUEFUNC(_wrap_FXHeaderItem_setPos), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "getPos", VALUEFUNC(_wrap_FXHeaderItem_getPos), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "setArrowDir", VALUEFUNC(_wrap_FXHeaderItem_setArrowDir), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "getArrowDir", VALUEFUNC(_wrap_FXHeaderItem_getArrowDir), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "setJustify", VALUEFUNC(_wrap_FXHeaderItem_setJustify), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "getJustify", VALUEFUNC(_wrap_FXHeaderItem_getJustify), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "setIconPosition", VALUEFUNC(_wrap_FXHeaderItem_setIconPosition), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "getIconPosition", VALUEFUNC(_wrap_FXHeaderItem_getIconPosition), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "setPressed", VALUEFUNC(_wrap_FXHeaderItem_setPressed), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "isPressed", VALUEFUNC(_wrap_FXHeaderItem_isPressed), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "save", VALUEFUNC(_wrap_FXHeaderItem_save), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "load", VALUEFUNC(_wrap_FXHeaderItem_load), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "setText", VALUEFUNC(_wrap_FXHeaderItem_setText), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "setIcon", VALUEFUNC(_wrap_FXHeaderItem_setIcon), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "getWidth", VALUEFUNC(_wrap_FXHeaderItem_getWidth), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "getHeight", VALUEFUNC(_wrap_FXHeaderItem_getHeight), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "create", VALUEFUNC(_wrap_FXHeaderItem_create), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "detach", VALUEFUNC(_wrap_FXHeaderItem_detach), -1);
+  rb_define_method(SwigClassFXHeaderItem.klass, "destroy", VALUEFUNC(_wrap_FXHeaderItem_destroy), -1);
+  SwigClassFXHeaderItem.mark = (void (*)(void *)) FXRbHeaderItem::markfunc;
+  SwigClassFXHeaderItem.destroy = (void (*)(void *)) FXRbHeaderItem::freefunc;
+  SwigClassFXHeaderItem.trackObjects = 0;
+  
+  SwigClassFXHeader.klass = rb_define_class_under(mFox, "FXHeader", ((swig_class *) SWIGTYPE_p_FXFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXHeader, (void *) &SwigClassFXHeader);
+  rb_define_alloc_func(SwigClassFXHeader.klass, _wrap_FXHeader_allocate);
+  rb_define_method(SwigClassFXHeader.klass, "initialize", VALUEFUNC(_wrap_new_FXHeader), -1);
+  rb_define_method(SwigClassFXHeader.klass, "onPaint", VALUEFUNC(_wrap_FXHeader_onPaint), -1);
+  rb_define_method(SwigClassFXHeader.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXHeader_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXHeader.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXHeader_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXHeader.klass, "onUngrabbed", VALUEFUNC(_wrap_FXHeader_onUngrabbed), -1);
+  rb_define_method(SwigClassFXHeader.klass, "onMotion", VALUEFUNC(_wrap_FXHeader_onMotion), -1);
+  rb_define_method(SwigClassFXHeader.klass, "onTipTimer", VALUEFUNC(_wrap_FXHeader_onTipTimer), -1);
+  rb_define_method(SwigClassFXHeader.klass, "onQueryTip", VALUEFUNC(_wrap_FXHeader_onQueryTip), -1);
+  rb_define_method(SwigClassFXHeader.klass, "onQueryHelp", VALUEFUNC(_wrap_FXHeader_onQueryHelp), -1);
+  rb_define_method(SwigClassFXHeader.klass, "getNumItems", VALUEFUNC(_wrap_FXHeader_getNumItems), -1);
+  rb_define_method(SwigClassFXHeader.klass, "getTotalSize", VALUEFUNC(_wrap_FXHeader_getTotalSize), -1);
+  rb_define_method(SwigClassFXHeader.klass, "setPosition", VALUEFUNC(_wrap_FXHeader_setPosition), -1);
+  rb_define_method(SwigClassFXHeader.klass, "getPosition", VALUEFUNC(_wrap_FXHeader_getPosition), -1);
+  rb_define_method(SwigClassFXHeader.klass, "getItem", VALUEFUNC(_wrap_FXHeader_getItem), -1);
+  rb_define_method(SwigClassFXHeader.klass, "getItemAt", VALUEFUNC(_wrap_FXHeader_getItemAt), -1);
+  rb_define_method(SwigClassFXHeader.klass, "setItem", VALUEFUNC(_wrap_FXHeader_setItem), -1);
+  rb_define_method(SwigClassFXHeader.klass, "fillItems", VALUEFUNC(_wrap_FXHeader_fillItems), -1);
+  rb_define_method(SwigClassFXHeader.klass, "insertItem", VALUEFUNC(_wrap_FXHeader_insertItem), -1);
+  rb_define_method(SwigClassFXHeader.klass, "appendItem", VALUEFUNC(_wrap_FXHeader_appendItem), -1);
+  rb_define_method(SwigClassFXHeader.klass, "prependItem", VALUEFUNC(_wrap_FXHeader_prependItem), -1);
+  rb_define_method(SwigClassFXHeader.klass, "extractItem", VALUEFUNC(_wrap_FXHeader_extractItem), -1);
+  rb_define_method(SwigClassFXHeader.klass, "removeItem", VALUEFUNC(_wrap_FXHeader_removeItem), -1);
+  rb_define_method(SwigClassFXHeader.klass, "clearItems", VALUEFUNC(_wrap_FXHeader_clearItems), -1);
+  rb_define_method(SwigClassFXHeader.klass, "setItemText", VALUEFUNC(_wrap_FXHeader_setItemText), -1);
+  rb_define_method(SwigClassFXHeader.klass, "getItemText", VALUEFUNC(_wrap_FXHeader_getItemText), -1);
+  rb_define_method(SwigClassFXHeader.klass, "setItemIcon", VALUEFUNC(_wrap_FXHeader_setItemIcon), -1);
+  rb_define_method(SwigClassFXHeader.klass, "getItemIcon", VALUEFUNC(_wrap_FXHeader_getItemIcon), -1);
+  rb_define_method(SwigClassFXHeader.klass, "setItemSize", VALUEFUNC(_wrap_FXHeader_setItemSize), -1);
+  rb_define_method(SwigClassFXHeader.klass, "getItemSize", VALUEFUNC(_wrap_FXHeader_getItemSize), -1);
+  rb_define_method(SwigClassFXHeader.klass, "getItemOffset", VALUEFUNC(_wrap_FXHeader_getItemOffset), -1);
+  rb_define_method(SwigClassFXHeader.klass, "setItemData", VALUEFUNC(_wrap_FXHeader_setItemData), -1);
+  rb_define_method(SwigClassFXHeader.klass, "getItemData", VALUEFUNC(_wrap_FXHeader_getItemData), -1);
+  rb_define_method(SwigClassFXHeader.klass, "setArrowDir", VALUEFUNC(_wrap_FXHeader_setArrowDir), -1);
+  rb_define_method(SwigClassFXHeader.klass, "getArrowDir", VALUEFUNC(_wrap_FXHeader_getArrowDir), -1);
+  rb_define_method(SwigClassFXHeader.klass, "setItemJustify", VALUEFUNC(_wrap_FXHeader_setItemJustify), -1);
+  rb_define_method(SwigClassFXHeader.klass, "getItemJustify", VALUEFUNC(_wrap_FXHeader_getItemJustify), -1);
+  rb_define_method(SwigClassFXHeader.klass, "setItemIconPosition", VALUEFUNC(_wrap_FXHeader_setItemIconPosition), -1);
+  rb_define_method(SwigClassFXHeader.klass, "getItemIconPosition", VALUEFUNC(_wrap_FXHeader_getItemIconPosition), -1);
+  rb_define_method(SwigClassFXHeader.klass, "setItemPressed", VALUEFUNC(_wrap_FXHeader_setItemPressed), -1);
+  rb_define_method(SwigClassFXHeader.klass, "isItemPressed", VALUEFUNC(_wrap_FXHeader_isItemPressed), -1);
+  rb_define_method(SwigClassFXHeader.klass, "makeItemVisible", VALUEFUNC(_wrap_FXHeader_makeItemVisible), -1);
+  rb_define_method(SwigClassFXHeader.klass, "updateItem", VALUEFUNC(_wrap_FXHeader_updateItem), -1);
+  rb_define_method(SwigClassFXHeader.klass, "setFont", VALUEFUNC(_wrap_FXHeader_setFont), -1);
+  rb_define_method(SwigClassFXHeader.klass, "getFont", VALUEFUNC(_wrap_FXHeader_getFont), -1);
+  rb_define_method(SwigClassFXHeader.klass, "getTextColor", VALUEFUNC(_wrap_FXHeader_getTextColor), -1);
+  rb_define_method(SwigClassFXHeader.klass, "setTextColor", VALUEFUNC(_wrap_FXHeader_setTextColor), -1);
+  rb_define_method(SwigClassFXHeader.klass, "setHeaderStyle", VALUEFUNC(_wrap_FXHeader_setHeaderStyle), -1);
+  rb_define_method(SwigClassFXHeader.klass, "getHeaderStyle", VALUEFUNC(_wrap_FXHeader_getHeaderStyle), -1);
+  rb_define_method(SwigClassFXHeader.klass, "setHelpText", VALUEFUNC(_wrap_FXHeader_setHelpText), -1);
+  rb_define_method(SwigClassFXHeader.klass, "getHelpText", VALUEFUNC(_wrap_FXHeader_getHelpText), -1);
+  rb_define_method(SwigClassFXHeader.klass, "save", VALUEFUNC(_wrap_FXHeader_save), -1);
+  rb_define_method(SwigClassFXHeader.klass, "load", VALUEFUNC(_wrap_FXHeader_load), -1);
+  rb_define_method(SwigClassFXHeader.klass, "create", VALUEFUNC(_wrap_FXHeader_create), -1);
+  rb_define_method(SwigClassFXHeader.klass, "detach", VALUEFUNC(_wrap_FXHeader_detach), -1);
+  rb_define_method(SwigClassFXHeader.klass, "destroy", VALUEFUNC(_wrap_FXHeader_destroy), -1);
+  rb_define_method(SwigClassFXHeader.klass, "resize", VALUEFUNC(_wrap_FXHeader_resize), -1);
+  rb_define_method(SwigClassFXHeader.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXHeader_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXHeader.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXHeader_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXHeader.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXHeader_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXHeader.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXHeader_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXHeader.klass, "canFocus", VALUEFUNC(_wrap_FXHeader_canFocus), -1);
+  rb_define_method(SwigClassFXHeader.klass, "setFocus", VALUEFUNC(_wrap_FXHeader_setFocus), -1);
+  rb_define_method(SwigClassFXHeader.klass, "killFocus", VALUEFUNC(_wrap_FXHeader_killFocus), -1);
+  rb_define_method(SwigClassFXHeader.klass, "changeFocus", VALUEFUNC(_wrap_FXHeader_changeFocus), -1);
+  rb_define_method(SwigClassFXHeader.klass, "setDefault", VALUEFUNC(_wrap_FXHeader_setDefault), -1);
+  rb_define_method(SwigClassFXHeader.klass, "enable", VALUEFUNC(_wrap_FXHeader_enable), -1);
+  rb_define_method(SwigClassFXHeader.klass, "disable", VALUEFUNC(_wrap_FXHeader_disable), -1);
+  rb_define_method(SwigClassFXHeader.klass, "raiseWindow", VALUEFUNC(_wrap_FXHeader_raiseWindow), -1);
+  rb_define_method(SwigClassFXHeader.klass, "lower", VALUEFUNC(_wrap_FXHeader_lower), -1);
+  rb_define_method(SwigClassFXHeader.klass, "move", VALUEFUNC(_wrap_FXHeader_move), -1);
+  rb_define_method(SwigClassFXHeader.klass, "position", VALUEFUNC(_wrap_FXHeader_position), -1);
+  rb_define_method(SwigClassFXHeader.klass, "layout", VALUEFUNC(_wrap_FXHeader_layout), -1);
+  rb_define_method(SwigClassFXHeader.klass, "recalc", VALUEFUNC(_wrap_FXHeader_recalc), -1);
+  rb_define_method(SwigClassFXHeader.klass, "reparent", VALUEFUNC(_wrap_FXHeader_reparent), -1);
+  rb_define_method(SwigClassFXHeader.klass, "show", VALUEFUNC(_wrap_FXHeader_show), -1);
+  rb_define_method(SwigClassFXHeader.klass, "hide", VALUEFUNC(_wrap_FXHeader_hide), -1);
+  rb_define_method(SwigClassFXHeader.klass, "isComposite", VALUEFUNC(_wrap_FXHeader_isComposite), -1);
+  rb_define_method(SwigClassFXHeader.klass, "contains", VALUEFUNC(_wrap_FXHeader_contains), -1);
+  rb_define_method(SwigClassFXHeader.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXHeader_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXHeader.klass, "setBackColor", VALUEFUNC(_wrap_FXHeader_setBackColor), -1);
+  rb_define_method(SwigClassFXHeader.klass, "tr", VALUEFUNC(_wrap_FXHeader_tr), -1);
+  rb_define_method(SwigClassFXHeader.klass, "dropEnable", VALUEFUNC(_wrap_FXHeader_dropEnable), -1);
+  rb_define_method(SwigClassFXHeader.klass, "dropDisable", VALUEFUNC(_wrap_FXHeader_dropDisable), -1);
+  rb_define_method(SwigClassFXHeader.klass, "setShape", VALUEFUNC(_wrap_FXHeader_setShape), -1);
+  rb_define_method(SwigClassFXHeader.klass, "clearShape", VALUEFUNC(_wrap_FXHeader_clearShape), -1);
+  SwigClassFXHeader.mark = (void (*)(void *)) FXRbHeader::markfunc;
+  SwigClassFXHeader.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXHeader.trackObjects = 0;
+  
+  SwigClassFXImageFrame.klass = rb_define_class_under(mFox, "FXImageFrame", ((swig_class *) SWIGTYPE_p_FXFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXImageFrame, (void *) &SwigClassFXImageFrame);
+  rb_define_alloc_func(SwigClassFXImageFrame.klass, _wrap_FXImageFrame_allocate);
+  rb_define_method(SwigClassFXImageFrame.klass, "initialize", VALUEFUNC(_wrap_new_FXImageFrame), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "onPaint", VALUEFUNC(_wrap_FXImageFrame_onPaint), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "setImage", VALUEFUNC(_wrap_FXImageFrame_setImage), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "getImage", VALUEFUNC(_wrap_FXImageFrame_getImage), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "setJustify", VALUEFUNC(_wrap_FXImageFrame_setJustify), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "getJustify", VALUEFUNC(_wrap_FXImageFrame_getJustify), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "save", VALUEFUNC(_wrap_FXImageFrame_save), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "load", VALUEFUNC(_wrap_FXImageFrame_load), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "create", VALUEFUNC(_wrap_FXImageFrame_create), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "detach", VALUEFUNC(_wrap_FXImageFrame_detach), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "destroy", VALUEFUNC(_wrap_FXImageFrame_destroy), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "resize", VALUEFUNC(_wrap_FXImageFrame_resize), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXImageFrame_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXImageFrame_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXImageFrame_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXImageFrame_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "canFocus", VALUEFUNC(_wrap_FXImageFrame_canFocus), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "setFocus", VALUEFUNC(_wrap_FXImageFrame_setFocus), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "killFocus", VALUEFUNC(_wrap_FXImageFrame_killFocus), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "changeFocus", VALUEFUNC(_wrap_FXImageFrame_changeFocus), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "setDefault", VALUEFUNC(_wrap_FXImageFrame_setDefault), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "enable", VALUEFUNC(_wrap_FXImageFrame_enable), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "disable", VALUEFUNC(_wrap_FXImageFrame_disable), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "raiseWindow", VALUEFUNC(_wrap_FXImageFrame_raiseWindow), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "lower", VALUEFUNC(_wrap_FXImageFrame_lower), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "move", VALUEFUNC(_wrap_FXImageFrame_move), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "position", VALUEFUNC(_wrap_FXImageFrame_position), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "layout", VALUEFUNC(_wrap_FXImageFrame_layout), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "recalc", VALUEFUNC(_wrap_FXImageFrame_recalc), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "reparent", VALUEFUNC(_wrap_FXImageFrame_reparent), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "show", VALUEFUNC(_wrap_FXImageFrame_show), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "hide", VALUEFUNC(_wrap_FXImageFrame_hide), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "isComposite", VALUEFUNC(_wrap_FXImageFrame_isComposite), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "contains", VALUEFUNC(_wrap_FXImageFrame_contains), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXImageFrame_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "setBackColor", VALUEFUNC(_wrap_FXImageFrame_setBackColor), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "tr", VALUEFUNC(_wrap_FXImageFrame_tr), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "dropEnable", VALUEFUNC(_wrap_FXImageFrame_dropEnable), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "dropDisable", VALUEFUNC(_wrap_FXImageFrame_dropDisable), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "setShape", VALUEFUNC(_wrap_FXImageFrame_setShape), -1);
+  rb_define_method(SwigClassFXImageFrame.klass, "clearShape", VALUEFUNC(_wrap_FXImageFrame_clearShape), -1);
+  SwigClassFXImageFrame.mark = (void (*)(void *)) FXRbImageFrame::markfunc;
+  SwigClassFXImageFrame.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXImageFrame.trackObjects = 0;
+  
+  SwigClassFXBitmapFrame.klass = rb_define_class_under(mFox, "FXBitmapFrame", ((swig_class *) SWIGTYPE_p_FXFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXBitmapFrame, (void *) &SwigClassFXBitmapFrame);
+  rb_define_alloc_func(SwigClassFXBitmapFrame.klass, _wrap_FXBitmapFrame_allocate);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "initialize", VALUEFUNC(_wrap_new_FXBitmapFrame), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "onPaint", VALUEFUNC(_wrap_FXBitmapFrame_onPaint), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "setBitmap", VALUEFUNC(_wrap_FXBitmapFrame_setBitmap), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "getBitmap", VALUEFUNC(_wrap_FXBitmapFrame_getBitmap), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "setOnColor", VALUEFUNC(_wrap_FXBitmapFrame_setOnColor), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "getOnColor", VALUEFUNC(_wrap_FXBitmapFrame_getOnColor), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "setOffColor", VALUEFUNC(_wrap_FXBitmapFrame_setOffColor), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "getOffColor", VALUEFUNC(_wrap_FXBitmapFrame_getOffColor), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "setJustify", VALUEFUNC(_wrap_FXBitmapFrame_setJustify), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "getJustify", VALUEFUNC(_wrap_FXBitmapFrame_getJustify), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "save", VALUEFUNC(_wrap_FXBitmapFrame_save), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "load", VALUEFUNC(_wrap_FXBitmapFrame_load), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "create", VALUEFUNC(_wrap_FXBitmapFrame_create), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "detach", VALUEFUNC(_wrap_FXBitmapFrame_detach), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "destroy", VALUEFUNC(_wrap_FXBitmapFrame_destroy), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "resize", VALUEFUNC(_wrap_FXBitmapFrame_resize), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXBitmapFrame_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXBitmapFrame_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXBitmapFrame_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXBitmapFrame_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "canFocus", VALUEFUNC(_wrap_FXBitmapFrame_canFocus), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "setFocus", VALUEFUNC(_wrap_FXBitmapFrame_setFocus), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "killFocus", VALUEFUNC(_wrap_FXBitmapFrame_killFocus), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "changeFocus", VALUEFUNC(_wrap_FXBitmapFrame_changeFocus), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "setDefault", VALUEFUNC(_wrap_FXBitmapFrame_setDefault), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "enable", VALUEFUNC(_wrap_FXBitmapFrame_enable), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "disable", VALUEFUNC(_wrap_FXBitmapFrame_disable), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "raiseWindow", VALUEFUNC(_wrap_FXBitmapFrame_raiseWindow), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "lower", VALUEFUNC(_wrap_FXBitmapFrame_lower), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "move", VALUEFUNC(_wrap_FXBitmapFrame_move), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "position", VALUEFUNC(_wrap_FXBitmapFrame_position), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "layout", VALUEFUNC(_wrap_FXBitmapFrame_layout), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "recalc", VALUEFUNC(_wrap_FXBitmapFrame_recalc), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "reparent", VALUEFUNC(_wrap_FXBitmapFrame_reparent), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "show", VALUEFUNC(_wrap_FXBitmapFrame_show), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "hide", VALUEFUNC(_wrap_FXBitmapFrame_hide), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "isComposite", VALUEFUNC(_wrap_FXBitmapFrame_isComposite), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "contains", VALUEFUNC(_wrap_FXBitmapFrame_contains), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXBitmapFrame_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "setBackColor", VALUEFUNC(_wrap_FXBitmapFrame_setBackColor), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "tr", VALUEFUNC(_wrap_FXBitmapFrame_tr), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "dropEnable", VALUEFUNC(_wrap_FXBitmapFrame_dropEnable), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "dropDisable", VALUEFUNC(_wrap_FXBitmapFrame_dropDisable), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "setShape", VALUEFUNC(_wrap_FXBitmapFrame_setShape), -1);
+  rb_define_method(SwigClassFXBitmapFrame.klass, "clearShape", VALUEFUNC(_wrap_FXBitmapFrame_clearShape), -1);
+  SwigClassFXBitmapFrame.mark = (void (*)(void *)) FXRbBitmapFrame::markfunc;
+  SwigClassFXBitmapFrame.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXBitmapFrame.trackObjects = 0;
+  rb_define_const(mFox, "KNOB_NEEDLE", SWIG_From_int(static_cast< int >(KNOB_NEEDLE)));
+  rb_define_const(mFox, "KNOB_DOT", SWIG_From_int(static_cast< int >(KNOB_DOT)));
+  rb_define_const(mFox, "KNOB_TICKS", SWIG_From_int(static_cast< int >(KNOB_TICKS)));
+  rb_define_const(mFox, "KNOB_INDICATOR", SWIG_From_int(static_cast< int >(KNOB_INDICATOR)));
+  rb_define_const(mFox, "KNOB_NORMAL", SWIG_From_int(static_cast< int >(KNOB_NORMAL)));
+  
+  SwigClassFXKnob.klass = rb_define_class_under(mFox, "FXKnob", ((swig_class *) SWIGTYPE_p_FXFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXKnob, (void *) &SwigClassFXKnob);
+  rb_define_alloc_func(SwigClassFXKnob.klass, _wrap_FXKnob_allocate);
+  rb_define_method(SwigClassFXKnob.klass, "initialize", VALUEFUNC(_wrap_new_FXKnob), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onPaint", VALUEFUNC(_wrap_FXKnob_onPaint), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXKnob_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXKnob_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onMiddleBtnPress", VALUEFUNC(_wrap_FXKnob_onMiddleBtnPress), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onMiddleBtnRelease", VALUEFUNC(_wrap_FXKnob_onMiddleBtnRelease), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onMouseWheel", VALUEFUNC(_wrap_FXKnob_onMouseWheel), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onUngrabbed", VALUEFUNC(_wrap_FXKnob_onUngrabbed), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onMotion", VALUEFUNC(_wrap_FXKnob_onMotion), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onFocusIn", VALUEFUNC(_wrap_FXKnob_onFocusIn), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onFocusOut", VALUEFUNC(_wrap_FXKnob_onFocusOut), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onKeyPress", VALUEFUNC(_wrap_FXKnob_onKeyPress), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onKeyRelease", VALUEFUNC(_wrap_FXKnob_onKeyRelease), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onAutoSlide", VALUEFUNC(_wrap_FXKnob_onAutoSlide), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXKnob_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXKnob_onCmdSetIntValue), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXKnob_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onCmdSetRealValue", VALUEFUNC(_wrap_FXKnob_onCmdSetRealValue), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onCmdGetRealValue", VALUEFUNC(_wrap_FXKnob_onCmdGetRealValue), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onCmdSetIntRange", VALUEFUNC(_wrap_FXKnob_onCmdSetIntRange), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onCmdGetIntRange", VALUEFUNC(_wrap_FXKnob_onCmdGetIntRange), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onCmdSetRealRange", VALUEFUNC(_wrap_FXKnob_onCmdSetRealRange), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onCmdGetRealRange", VALUEFUNC(_wrap_FXKnob_onCmdGetRealRange), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onCmdSetHelp", VALUEFUNC(_wrap_FXKnob_onCmdSetHelp), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onCmdGetHelp", VALUEFUNC(_wrap_FXKnob_onCmdGetHelp), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onCmdSetTip", VALUEFUNC(_wrap_FXKnob_onCmdSetTip), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onCmdGetTip", VALUEFUNC(_wrap_FXKnob_onCmdGetTip), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onQueryHelp", VALUEFUNC(_wrap_FXKnob_onQueryHelp), -1);
+  rb_define_method(SwigClassFXKnob.klass, "onQueryTip", VALUEFUNC(_wrap_FXKnob_onQueryTip), -1);
+  rb_define_const(SwigClassFXKnob.klass, "ID_AUTOSLIDE", SWIG_From_int(static_cast< int >(FXKnob::ID_AUTOSLIDE)));
+  rb_define_const(SwigClassFXKnob.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXKnob::ID_LAST)));
+  rb_define_method(SwigClassFXKnob.klass, "value=", VALUEFUNC(_wrap_FXKnob_valuee___), -1);
+  rb_define_method(SwigClassFXKnob.klass, "setRange", VALUEFUNC(_wrap_FXKnob_setRange), -1);
+  rb_define_method(SwigClassFXKnob.klass, "getRange", VALUEFUNC(_wrap_FXKnob_getRange), -1);
+  rb_define_method(SwigClassFXKnob.klass, "setLimits", VALUEFUNC(_wrap_FXKnob_setLimits), -1);
+  rb_define_method(SwigClassFXKnob.klass, "getLimits", VALUEFUNC(_wrap_FXKnob_getLimits), -1);
+  rb_define_method(SwigClassFXKnob.klass, "knobStyle", VALUEFUNC(_wrap_FXKnob_knobStyle), -1);
+  rb_define_method(SwigClassFXKnob.klass, "knobStyle=", VALUEFUNC(_wrap_FXKnob_knobStylee___), -1);
+  rb_define_method(SwigClassFXKnob.klass, "increment", VALUEFUNC(_wrap_FXKnob_increment), -1);
+  rb_define_method(SwigClassFXKnob.klass, "increment=", VALUEFUNC(_wrap_FXKnob_incremente___), -1);
+  rb_define_method(SwigClassFXKnob.klass, "tickDelta=", VALUEFUNC(_wrap_FXKnob_tickDeltae___), -1);
+  rb_define_method(SwigClassFXKnob.klass, "tickDelta", VALUEFUNC(_wrap_FXKnob_tickDelta), -1);
+  rb_define_method(SwigClassFXKnob.klass, "lineColor=", VALUEFUNC(_wrap_FXKnob_lineColore___), -1);
+  rb_define_method(SwigClassFXKnob.klass, "lineColor", VALUEFUNC(_wrap_FXKnob_lineColor), -1);
+  rb_define_method(SwigClassFXKnob.klass, "helpText=", VALUEFUNC(_wrap_FXKnob_helpTexte___), -1);
+  rb_define_method(SwigClassFXKnob.klass, "helpText", VALUEFUNC(_wrap_FXKnob_helpText), -1);
+  rb_define_method(SwigClassFXKnob.klass, "tipText=", VALUEFUNC(_wrap_FXKnob_tipTexte___), -1);
+  rb_define_method(SwigClassFXKnob.klass, "tipText", VALUEFUNC(_wrap_FXKnob_tipText), -1);
+  rb_define_method(SwigClassFXKnob.klass, "save", VALUEFUNC(_wrap_FXKnob_save), -1);
+  rb_define_method(SwigClassFXKnob.klass, "load", VALUEFUNC(_wrap_FXKnob_load), -1);
+  rb_define_method(SwigClassFXKnob.klass, "create", VALUEFUNC(_wrap_FXKnob_create), -1);
+  rb_define_method(SwigClassFXKnob.klass, "detach", VALUEFUNC(_wrap_FXKnob_detach), -1);
+  rb_define_method(SwigClassFXKnob.klass, "destroy", VALUEFUNC(_wrap_FXKnob_destroy), -1);
+  rb_define_method(SwigClassFXKnob.klass, "resize", VALUEFUNC(_wrap_FXKnob_resize), -1);
+  rb_define_method(SwigClassFXKnob.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXKnob_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXKnob.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXKnob_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXKnob.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXKnob_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXKnob.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXKnob_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXKnob.klass, "canFocus", VALUEFUNC(_wrap_FXKnob_canFocus), -1);
+  rb_define_method(SwigClassFXKnob.klass, "setFocus", VALUEFUNC(_wrap_FXKnob_setFocus), -1);
+  rb_define_method(SwigClassFXKnob.klass, "killFocus", VALUEFUNC(_wrap_FXKnob_killFocus), -1);
+  rb_define_method(SwigClassFXKnob.klass, "changeFocus", VALUEFUNC(_wrap_FXKnob_changeFocus), -1);
+  rb_define_method(SwigClassFXKnob.klass, "setDefault", VALUEFUNC(_wrap_FXKnob_setDefault), -1);
+  rb_define_method(SwigClassFXKnob.klass, "enable", VALUEFUNC(_wrap_FXKnob_enable), -1);
+  rb_define_method(SwigClassFXKnob.klass, "disable", VALUEFUNC(_wrap_FXKnob_disable), -1);
+  rb_define_method(SwigClassFXKnob.klass, "raiseWindow", VALUEFUNC(_wrap_FXKnob_raiseWindow), -1);
+  rb_define_method(SwigClassFXKnob.klass, "lower", VALUEFUNC(_wrap_FXKnob_lower), -1);
+  rb_define_method(SwigClassFXKnob.klass, "move", VALUEFUNC(_wrap_FXKnob_move), -1);
+  rb_define_method(SwigClassFXKnob.klass, "position", VALUEFUNC(_wrap_FXKnob_position), -1);
+  rb_define_method(SwigClassFXKnob.klass, "layout", VALUEFUNC(_wrap_FXKnob_layout), -1);
+  rb_define_method(SwigClassFXKnob.klass, "recalc", VALUEFUNC(_wrap_FXKnob_recalc), -1);
+  rb_define_method(SwigClassFXKnob.klass, "reparent", VALUEFUNC(_wrap_FXKnob_reparent), -1);
+  rb_define_method(SwigClassFXKnob.klass, "show", VALUEFUNC(_wrap_FXKnob_show), -1);
+  rb_define_method(SwigClassFXKnob.klass, "hide", VALUEFUNC(_wrap_FXKnob_hide), -1);
+  rb_define_method(SwigClassFXKnob.klass, "isComposite", VALUEFUNC(_wrap_FXKnob_isComposite), -1);
+  rb_define_method(SwigClassFXKnob.klass, "contains", VALUEFUNC(_wrap_FXKnob_contains), -1);
+  rb_define_method(SwigClassFXKnob.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXKnob_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXKnob.klass, "setBackColor", VALUEFUNC(_wrap_FXKnob_setBackColor), -1);
+  rb_define_method(SwigClassFXKnob.klass, "tr", VALUEFUNC(_wrap_FXKnob_tr), -1);
+  rb_define_method(SwigClassFXKnob.klass, "dropEnable", VALUEFUNC(_wrap_FXKnob_dropEnable), -1);
+  rb_define_method(SwigClassFXKnob.klass, "dropDisable", VALUEFUNC(_wrap_FXKnob_dropDisable), -1);
+  rb_define_method(SwigClassFXKnob.klass, "setShape", VALUEFUNC(_wrap_FXKnob_setShape), -1);
+  rb_define_method(SwigClassFXKnob.klass, "clearShape", VALUEFUNC(_wrap_FXKnob_clearShape), -1);
+  SwigClassFXKnob.mark = 0;
+  SwigClassFXKnob.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXKnob.trackObjects = 0;
+  rb_define_const(mFox, "PROGRESSBAR_HORIZONTAL", SWIG_From_int(static_cast< int >(PROGRESSBAR_HORIZONTAL)));
+  rb_define_const(mFox, "PROGRESSBAR_VERTICAL", SWIG_From_int(static_cast< int >(PROGRESSBAR_VERTICAL)));
+  rb_define_const(mFox, "PROGRESSBAR_PERCENTAGE", SWIG_From_int(static_cast< int >(PROGRESSBAR_PERCENTAGE)));
+  rb_define_const(mFox, "PROGRESSBAR_DIAL", SWIG_From_int(static_cast< int >(PROGRESSBAR_DIAL)));
+  rb_define_const(mFox, "PROGRESSBAR_NORMAL", SWIG_From_int(static_cast< int >(PROGRESSBAR_NORMAL)));
+  
+  SwigClassFXProgressBar.klass = rb_define_class_under(mFox, "FXProgressBar", ((swig_class *) SWIGTYPE_p_FXFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXProgressBar, (void *) &SwigClassFXProgressBar);
+  rb_define_alloc_func(SwigClassFXProgressBar.klass, _wrap_FXProgressBar_allocate);
+  rb_define_method(SwigClassFXProgressBar.klass, "initialize", VALUEFUNC(_wrap_new_FXProgressBar), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "onPaint", VALUEFUNC(_wrap_FXProgressBar_onPaint), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXProgressBar_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXProgressBar_onCmdSetIntValue), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXProgressBar_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "setProgress", VALUEFUNC(_wrap_FXProgressBar_setProgress), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "getProgress", VALUEFUNC(_wrap_FXProgressBar_getProgress), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "setTotal", VALUEFUNC(_wrap_FXProgressBar_setTotal), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "getTotal", VALUEFUNC(_wrap_FXProgressBar_getTotal), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "increment", VALUEFUNC(_wrap_FXProgressBar_increment), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "hideNumber", VALUEFUNC(_wrap_FXProgressBar_hideNumber), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "showNumber", VALUEFUNC(_wrap_FXProgressBar_showNumber), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "setBarSize", VALUEFUNC(_wrap_FXProgressBar_setBarSize), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "getBarSize", VALUEFUNC(_wrap_FXProgressBar_getBarSize), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "setBarBGColor", VALUEFUNC(_wrap_FXProgressBar_setBarBGColor), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "getBarBGColor", VALUEFUNC(_wrap_FXProgressBar_getBarBGColor), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "setBarColor", VALUEFUNC(_wrap_FXProgressBar_setBarColor), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "getBarColor", VALUEFUNC(_wrap_FXProgressBar_getBarColor), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "setTextColor", VALUEFUNC(_wrap_FXProgressBar_setTextColor), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "getTextColor", VALUEFUNC(_wrap_FXProgressBar_getTextColor), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "setTextAltColor", VALUEFUNC(_wrap_FXProgressBar_setTextAltColor), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "getTextAltColor", VALUEFUNC(_wrap_FXProgressBar_getTextAltColor), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "setFont", VALUEFUNC(_wrap_FXProgressBar_setFont), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "getFont", VALUEFUNC(_wrap_FXProgressBar_getFont), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "setBarStyle", VALUEFUNC(_wrap_FXProgressBar_setBarStyle), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "getBarStyle", VALUEFUNC(_wrap_FXProgressBar_getBarStyle), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "save", VALUEFUNC(_wrap_FXProgressBar_save), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "load", VALUEFUNC(_wrap_FXProgressBar_load), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "create", VALUEFUNC(_wrap_FXProgressBar_create), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "detach", VALUEFUNC(_wrap_FXProgressBar_detach), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "destroy", VALUEFUNC(_wrap_FXProgressBar_destroy), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "resize", VALUEFUNC(_wrap_FXProgressBar_resize), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXProgressBar_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXProgressBar_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXProgressBar_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXProgressBar_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "canFocus", VALUEFUNC(_wrap_FXProgressBar_canFocus), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "setFocus", VALUEFUNC(_wrap_FXProgressBar_setFocus), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "killFocus", VALUEFUNC(_wrap_FXProgressBar_killFocus), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "changeFocus", VALUEFUNC(_wrap_FXProgressBar_changeFocus), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "setDefault", VALUEFUNC(_wrap_FXProgressBar_setDefault), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "enable", VALUEFUNC(_wrap_FXProgressBar_enable), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "disable", VALUEFUNC(_wrap_FXProgressBar_disable), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "raiseWindow", VALUEFUNC(_wrap_FXProgressBar_raiseWindow), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "lower", VALUEFUNC(_wrap_FXProgressBar_lower), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "move", VALUEFUNC(_wrap_FXProgressBar_move), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "position", VALUEFUNC(_wrap_FXProgressBar_position), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "layout", VALUEFUNC(_wrap_FXProgressBar_layout), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "recalc", VALUEFUNC(_wrap_FXProgressBar_recalc), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "reparent", VALUEFUNC(_wrap_FXProgressBar_reparent), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "show", VALUEFUNC(_wrap_FXProgressBar_show), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "hide", VALUEFUNC(_wrap_FXProgressBar_hide), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "isComposite", VALUEFUNC(_wrap_FXProgressBar_isComposite), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "contains", VALUEFUNC(_wrap_FXProgressBar_contains), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXProgressBar_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "setBackColor", VALUEFUNC(_wrap_FXProgressBar_setBackColor), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "tr", VALUEFUNC(_wrap_FXProgressBar_tr), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "dropEnable", VALUEFUNC(_wrap_FXProgressBar_dropEnable), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "dropDisable", VALUEFUNC(_wrap_FXProgressBar_dropDisable), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "setShape", VALUEFUNC(_wrap_FXProgressBar_setShape), -1);
+  rb_define_method(SwigClassFXProgressBar.klass, "clearShape", VALUEFUNC(_wrap_FXProgressBar_clearShape), -1);
+  SwigClassFXProgressBar.mark = (void (*)(void *)) FXRbProgressBar::markfunc;
+  SwigClassFXProgressBar.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXProgressBar.trackObjects = 0;
+  rb_define_const(mFox, "RULER_NORMAL", SWIG_From_int(static_cast< int >(RULER_NORMAL)));
+  rb_define_const(mFox, "RULER_HORIZONTAL", SWIG_From_int(static_cast< int >(RULER_HORIZONTAL)));
+  rb_define_const(mFox, "RULER_VERTICAL", SWIG_From_int(static_cast< int >(RULER_VERTICAL)));
+  rb_define_const(mFox, "RULER_TICKS_OFF", SWIG_From_int(static_cast< int >(RULER_TICKS_OFF)));
+  rb_define_const(mFox, "RULER_TICKS_TOP", SWIG_From_int(static_cast< int >(RULER_TICKS_TOP)));
+  rb_define_const(mFox, "RULER_TICKS_BOTTOM", SWIG_From_int(static_cast< int >(RULER_TICKS_BOTTOM)));
+  rb_define_const(mFox, "RULER_TICKS_LEFT", SWIG_From_int(static_cast< int >(RULER_TICKS_LEFT)));
+  rb_define_const(mFox, "RULER_TICKS_RIGHT", SWIG_From_int(static_cast< int >(RULER_TICKS_RIGHT)));
+  rb_define_const(mFox, "RULER_TICKS_CENTER", SWIG_From_int(static_cast< int >(RULER_TICKS_CENTER)));
+  rb_define_const(mFox, "RULER_NUMBERS", SWIG_From_int(static_cast< int >(RULER_NUMBERS)));
+  rb_define_const(mFox, "RULER_ARROW", SWIG_From_int(static_cast< int >(RULER_ARROW)));
+  rb_define_const(mFox, "RULER_MARKERS", SWIG_From_int(static_cast< int >(RULER_MARKERS)));
+  rb_define_const(mFox, "RULER_METRIC", SWIG_From_int(static_cast< int >(RULER_METRIC)));
+  rb_define_const(mFox, "RULER_ENGLISH", SWIG_From_int(static_cast< int >(RULER_ENGLISH)));
+  rb_define_const(mFox, "RULER_MARGIN_ADJUST", SWIG_From_int(static_cast< int >(RULER_MARGIN_ADJUST)));
+  rb_define_const(mFox, "RULER_ALIGN_CENTER", SWIG_From_int(static_cast< int >(RULER_ALIGN_CENTER)));
+  rb_define_const(mFox, "RULER_ALIGN_LEFT", SWIG_From_int(static_cast< int >(RULER_ALIGN_LEFT)));
+  rb_define_const(mFox, "RULER_ALIGN_RIGHT", SWIG_From_int(static_cast< int >(RULER_ALIGN_RIGHT)));
+  rb_define_const(mFox, "RULER_ALIGN_TOP", SWIG_From_int(static_cast< int >(RULER_ALIGN_TOP)));
+  rb_define_const(mFox, "RULER_ALIGN_BOTTOM", SWIG_From_int(static_cast< int >(RULER_ALIGN_BOTTOM)));
+  rb_define_const(mFox, "RULER_ALIGN_STRETCH", SWIG_From_int(static_cast< int >(RULER_ALIGN_STRETCH)));
+  rb_define_const(mFox, "RULER_ALIGN_NORMAL", SWIG_From_int(static_cast< int >(RULER_ALIGN_NORMAL)));
+  
+  SwigClassFXRuler.klass = rb_define_class_under(mFox, "FXRuler", ((swig_class *) SWIGTYPE_p_FXFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXRuler, (void *) &SwigClassFXRuler);
+  rb_define_alloc_func(SwigClassFXRuler.klass, _wrap_FXRuler_allocate);
+  rb_define_method(SwigClassFXRuler.klass, "initialize", VALUEFUNC(_wrap_new_FXRuler), -1);
+  rb_define_method(SwigClassFXRuler.klass, "onPaint", VALUEFUNC(_wrap_FXRuler_onPaint), -1);
+  rb_define_method(SwigClassFXRuler.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXRuler_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXRuler.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXRuler_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXRuler.klass, "onMotion", VALUEFUNC(_wrap_FXRuler_onMotion), -1);
+  rb_define_method(SwigClassFXRuler.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXRuler_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXRuler.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXRuler_onCmdSetIntValue), -1);
+  rb_define_method(SwigClassFXRuler.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXRuler_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXRuler.klass, "onCmdSetHelp", VALUEFUNC(_wrap_FXRuler_onCmdSetHelp), -1);
+  rb_define_method(SwigClassFXRuler.klass, "onCmdGetHelp", VALUEFUNC(_wrap_FXRuler_onCmdGetHelp), -1);
+  rb_define_method(SwigClassFXRuler.klass, "onCmdSetTip", VALUEFUNC(_wrap_FXRuler_onCmdSetTip), -1);
+  rb_define_method(SwigClassFXRuler.klass, "onCmdGetTip", VALUEFUNC(_wrap_FXRuler_onCmdGetTip), -1);
+  rb_define_method(SwigClassFXRuler.klass, "onQueryHelp", VALUEFUNC(_wrap_FXRuler_onQueryHelp), -1);
+  rb_define_method(SwigClassFXRuler.klass, "onQueryTip", VALUEFUNC(_wrap_FXRuler_onQueryTip), -1);
+  rb_define_const(SwigClassFXRuler.klass, "ID_ARROW", SWIG_From_int(static_cast< int >(FXRuler::ID_ARROW)));
+  rb_define_const(SwigClassFXRuler.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXRuler::ID_LAST)));
+  rb_define_method(SwigClassFXRuler.klass, "setPosition", VALUEFUNC(_wrap_FXRuler_setPosition), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getPosition", VALUEFUNC(_wrap_FXRuler_getPosition), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setContentSize", VALUEFUNC(_wrap_FXRuler_setContentSize), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getContentSize", VALUEFUNC(_wrap_FXRuler_getContentSize), -1);
+  rb_define_method(SwigClassFXRuler.klass, "documentLower", VALUEFUNC(_wrap_FXRuler_documentLower), -1);
+  rb_define_method(SwigClassFXRuler.klass, "documentUpper", VALUEFUNC(_wrap_FXRuler_documentUpper), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setDocumentSize", VALUEFUNC(_wrap_FXRuler_setDocumentSize), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getDocumentSize", VALUEFUNC(_wrap_FXRuler_getDocumentSize), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setEdgeSpacing", VALUEFUNC(_wrap_FXRuler_setEdgeSpacing), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getEdgeSpacing", VALUEFUNC(_wrap_FXRuler_getEdgeSpacing), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setMarginLower", VALUEFUNC(_wrap_FXRuler_setMarginLower), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getMarginLower", VALUEFUNC(_wrap_FXRuler_getMarginLower), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setMarginUpper", VALUEFUNC(_wrap_FXRuler_setMarginUpper), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getMarginUpper", VALUEFUNC(_wrap_FXRuler_getMarginUpper), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setIndentFirst", VALUEFUNC(_wrap_FXRuler_setIndentFirst), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getIndentFirst", VALUEFUNC(_wrap_FXRuler_getIndentFirst), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setIndentLower", VALUEFUNC(_wrap_FXRuler_setIndentLower), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getIndentLower", VALUEFUNC(_wrap_FXRuler_getIndentLower), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setIndentUpper", VALUEFUNC(_wrap_FXRuler_setIndentUpper), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getIndentUpper", VALUEFUNC(_wrap_FXRuler_getIndentUpper), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setNumberTicks", VALUEFUNC(_wrap_FXRuler_setNumberTicks), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getNumberTicks", VALUEFUNC(_wrap_FXRuler_getNumberTicks), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setMajorTicks", VALUEFUNC(_wrap_FXRuler_setMajorTicks), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getMajorTicks", VALUEFUNC(_wrap_FXRuler_getMajorTicks), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setMediumTicks", VALUEFUNC(_wrap_FXRuler_setMediumTicks), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getMediumTicks", VALUEFUNC(_wrap_FXRuler_getMediumTicks), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setTinyTicks", VALUEFUNC(_wrap_FXRuler_setTinyTicks), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getTinyTicks", VALUEFUNC(_wrap_FXRuler_getTinyTicks), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setPixelPerTick", VALUEFUNC(_wrap_FXRuler_setPixelPerTick), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getPixelPerTick", VALUEFUNC(_wrap_FXRuler_getPixelPerTick), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setFont", VALUEFUNC(_wrap_FXRuler_setFont), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getFont", VALUEFUNC(_wrap_FXRuler_getFont), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setValue", VALUEFUNC(_wrap_FXRuler_setValue), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getValue", VALUEFUNC(_wrap_FXRuler_getValue), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setRulerStyle", VALUEFUNC(_wrap_FXRuler_setRulerStyle), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getRulerStyle", VALUEFUNC(_wrap_FXRuler_getRulerStyle), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setRulerAlignment", VALUEFUNC(_wrap_FXRuler_setRulerAlignment), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getRulerAlignment", VALUEFUNC(_wrap_FXRuler_getRulerAlignment), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getTextColor", VALUEFUNC(_wrap_FXRuler_getTextColor), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setTextColor", VALUEFUNC(_wrap_FXRuler_setTextColor), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setHelpText", VALUEFUNC(_wrap_FXRuler_setHelpText), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getHelpText", VALUEFUNC(_wrap_FXRuler_getHelpText), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setTipText", VALUEFUNC(_wrap_FXRuler_setTipText), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getTipText", VALUEFUNC(_wrap_FXRuler_getTipText), -1);
+  rb_define_method(SwigClassFXRuler.klass, "save", VALUEFUNC(_wrap_FXRuler_save), -1);
+  rb_define_method(SwigClassFXRuler.klass, "load", VALUEFUNC(_wrap_FXRuler_load), -1);
+  rb_define_method(SwigClassFXRuler.klass, "create", VALUEFUNC(_wrap_FXRuler_create), -1);
+  rb_define_method(SwigClassFXRuler.klass, "detach", VALUEFUNC(_wrap_FXRuler_detach), -1);
+  rb_define_method(SwigClassFXRuler.klass, "destroy", VALUEFUNC(_wrap_FXRuler_destroy), -1);
+  rb_define_method(SwigClassFXRuler.klass, "resize", VALUEFUNC(_wrap_FXRuler_resize), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXRuler_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXRuler_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXRuler_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXRuler.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXRuler_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXRuler.klass, "canFocus", VALUEFUNC(_wrap_FXRuler_canFocus), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setFocus", VALUEFUNC(_wrap_FXRuler_setFocus), -1);
+  rb_define_method(SwigClassFXRuler.klass, "killFocus", VALUEFUNC(_wrap_FXRuler_killFocus), -1);
+  rb_define_method(SwigClassFXRuler.klass, "changeFocus", VALUEFUNC(_wrap_FXRuler_changeFocus), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setDefault", VALUEFUNC(_wrap_FXRuler_setDefault), -1);
+  rb_define_method(SwigClassFXRuler.klass, "enable", VALUEFUNC(_wrap_FXRuler_enable), -1);
+  rb_define_method(SwigClassFXRuler.klass, "disable", VALUEFUNC(_wrap_FXRuler_disable), -1);
+  rb_define_method(SwigClassFXRuler.klass, "raiseWindow", VALUEFUNC(_wrap_FXRuler_raiseWindow), -1);
+  rb_define_method(SwigClassFXRuler.klass, "lower", VALUEFUNC(_wrap_FXRuler_lower), -1);
+  rb_define_method(SwigClassFXRuler.klass, "move", VALUEFUNC(_wrap_FXRuler_move), -1);
+  rb_define_method(SwigClassFXRuler.klass, "position", VALUEFUNC(_wrap_FXRuler_position), -1);
+  rb_define_method(SwigClassFXRuler.klass, "layout", VALUEFUNC(_wrap_FXRuler_layout), -1);
+  rb_define_method(SwigClassFXRuler.klass, "recalc", VALUEFUNC(_wrap_FXRuler_recalc), -1);
+  rb_define_method(SwigClassFXRuler.klass, "reparent", VALUEFUNC(_wrap_FXRuler_reparent), -1);
+  rb_define_method(SwigClassFXRuler.klass, "show", VALUEFUNC(_wrap_FXRuler_show), -1);
+  rb_define_method(SwigClassFXRuler.klass, "hide", VALUEFUNC(_wrap_FXRuler_hide), -1);
+  rb_define_method(SwigClassFXRuler.klass, "isComposite", VALUEFUNC(_wrap_FXRuler_isComposite), -1);
+  rb_define_method(SwigClassFXRuler.klass, "contains", VALUEFUNC(_wrap_FXRuler_contains), -1);
+  rb_define_method(SwigClassFXRuler.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXRuler_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setBackColor", VALUEFUNC(_wrap_FXRuler_setBackColor), -1);
+  rb_define_method(SwigClassFXRuler.klass, "tr", VALUEFUNC(_wrap_FXRuler_tr), -1);
+  rb_define_method(SwigClassFXRuler.klass, "dropEnable", VALUEFUNC(_wrap_FXRuler_dropEnable), -1);
+  rb_define_method(SwigClassFXRuler.klass, "dropDisable", VALUEFUNC(_wrap_FXRuler_dropDisable), -1);
+  rb_define_method(SwigClassFXRuler.klass, "setShape", VALUEFUNC(_wrap_FXRuler_setShape), -1);
+  rb_define_method(SwigClassFXRuler.klass, "clearShape", VALUEFUNC(_wrap_FXRuler_clearShape), -1);
+  SwigClassFXRuler.mark = (void (*)(void *)) FXRbRuler::markfunc;
+  SwigClassFXRuler.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXRuler.trackObjects = 0;
+  rb_define_const(mFox, "SEPARATOR_NONE", SWIG_From_int(static_cast< int >(SEPARATOR_NONE)));
+  rb_define_const(mFox, "SEPARATOR_GROOVE", SWIG_From_int(static_cast< int >(SEPARATOR_GROOVE)));
+  rb_define_const(mFox, "SEPARATOR_RIDGE", SWIG_From_int(static_cast< int >(SEPARATOR_RIDGE)));
+  rb_define_const(mFox, "SEPARATOR_LINE", SWIG_From_int(static_cast< int >(SEPARATOR_LINE)));
+  
+  SwigClassFXSeparator.klass = rb_define_class_under(mFox, "FXSeparator", ((swig_class *) SWIGTYPE_p_FXFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXSeparator, (void *) &SwigClassFXSeparator);
+  rb_define_alloc_func(SwigClassFXSeparator.klass, _wrap_FXSeparator_allocate);
+  rb_define_method(SwigClassFXSeparator.klass, "initialize", VALUEFUNC(_wrap_new_FXSeparator), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "onPaint", VALUEFUNC(_wrap_FXSeparator_onPaint), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "setSeparatorStyle", VALUEFUNC(_wrap_FXSeparator_setSeparatorStyle), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "getSeparatorStyle", VALUEFUNC(_wrap_FXSeparator_getSeparatorStyle), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "save", VALUEFUNC(_wrap_FXSeparator_save), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "load", VALUEFUNC(_wrap_FXSeparator_load), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "create", VALUEFUNC(_wrap_FXSeparator_create), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "detach", VALUEFUNC(_wrap_FXSeparator_detach), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "destroy", VALUEFUNC(_wrap_FXSeparator_destroy), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "resize", VALUEFUNC(_wrap_FXSeparator_resize), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXSeparator_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXSeparator_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXSeparator_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXSeparator_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "canFocus", VALUEFUNC(_wrap_FXSeparator_canFocus), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "setFocus", VALUEFUNC(_wrap_FXSeparator_setFocus), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "killFocus", VALUEFUNC(_wrap_FXSeparator_killFocus), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "changeFocus", VALUEFUNC(_wrap_FXSeparator_changeFocus), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "setDefault", VALUEFUNC(_wrap_FXSeparator_setDefault), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "enable", VALUEFUNC(_wrap_FXSeparator_enable), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "disable", VALUEFUNC(_wrap_FXSeparator_disable), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "raiseWindow", VALUEFUNC(_wrap_FXSeparator_raiseWindow), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "lower", VALUEFUNC(_wrap_FXSeparator_lower), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "move", VALUEFUNC(_wrap_FXSeparator_move), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "position", VALUEFUNC(_wrap_FXSeparator_position), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "layout", VALUEFUNC(_wrap_FXSeparator_layout), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "recalc", VALUEFUNC(_wrap_FXSeparator_recalc), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "reparent", VALUEFUNC(_wrap_FXSeparator_reparent), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "show", VALUEFUNC(_wrap_FXSeparator_show), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "hide", VALUEFUNC(_wrap_FXSeparator_hide), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "isComposite", VALUEFUNC(_wrap_FXSeparator_isComposite), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "contains", VALUEFUNC(_wrap_FXSeparator_contains), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXSeparator_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "setBackColor", VALUEFUNC(_wrap_FXSeparator_setBackColor), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "tr", VALUEFUNC(_wrap_FXSeparator_tr), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "dropEnable", VALUEFUNC(_wrap_FXSeparator_dropEnable), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "dropDisable", VALUEFUNC(_wrap_FXSeparator_dropDisable), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "setShape", VALUEFUNC(_wrap_FXSeparator_setShape), -1);
+  rb_define_method(SwigClassFXSeparator.klass, "clearShape", VALUEFUNC(_wrap_FXSeparator_clearShape), -1);
+  SwigClassFXSeparator.mark = (void (*)(void *)) FXRbSeparator::markfunc;
+  SwigClassFXSeparator.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXSeparator.trackObjects = 0;
+  
+  SWIGTYPE_p_FXSeparator->dcast = (swig_dycast_func) FXSeparator_dynamic_cast;
+  
+  
+  SwigClassFXHorizontalSeparator.klass = rb_define_class_under(mFox, "FXHorizontalSeparator", ((swig_class *) SWIGTYPE_p_FXSeparator->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXHorizontalSeparator, (void *) &SwigClassFXHorizontalSeparator);
+  rb_define_alloc_func(SwigClassFXHorizontalSeparator.klass, _wrap_FXHorizontalSeparator_allocate);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "initialize", VALUEFUNC(_wrap_new_FXHorizontalSeparator), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "save", VALUEFUNC(_wrap_FXHorizontalSeparator_save), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "load", VALUEFUNC(_wrap_FXHorizontalSeparator_load), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "create", VALUEFUNC(_wrap_FXHorizontalSeparator_create), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "detach", VALUEFUNC(_wrap_FXHorizontalSeparator_detach), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "destroy", VALUEFUNC(_wrap_FXHorizontalSeparator_destroy), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "resize", VALUEFUNC(_wrap_FXHorizontalSeparator_resize), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXHorizontalSeparator_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXHorizontalSeparator_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXHorizontalSeparator_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXHorizontalSeparator_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "canFocus", VALUEFUNC(_wrap_FXHorizontalSeparator_canFocus), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "setFocus", VALUEFUNC(_wrap_FXHorizontalSeparator_setFocus), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "killFocus", VALUEFUNC(_wrap_FXHorizontalSeparator_killFocus), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "changeFocus", VALUEFUNC(_wrap_FXHorizontalSeparator_changeFocus), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "setDefault", VALUEFUNC(_wrap_FXHorizontalSeparator_setDefault), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "enable", VALUEFUNC(_wrap_FXHorizontalSeparator_enable), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "disable", VALUEFUNC(_wrap_FXHorizontalSeparator_disable), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "raiseWindow", VALUEFUNC(_wrap_FXHorizontalSeparator_raiseWindow), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "lower", VALUEFUNC(_wrap_FXHorizontalSeparator_lower), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "move", VALUEFUNC(_wrap_FXHorizontalSeparator_move), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "position", VALUEFUNC(_wrap_FXHorizontalSeparator_position), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "layout", VALUEFUNC(_wrap_FXHorizontalSeparator_layout), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "recalc", VALUEFUNC(_wrap_FXHorizontalSeparator_recalc), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "reparent", VALUEFUNC(_wrap_FXHorizontalSeparator_reparent), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "show", VALUEFUNC(_wrap_FXHorizontalSeparator_show), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "hide", VALUEFUNC(_wrap_FXHorizontalSeparator_hide), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "isComposite", VALUEFUNC(_wrap_FXHorizontalSeparator_isComposite), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "contains", VALUEFUNC(_wrap_FXHorizontalSeparator_contains), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXHorizontalSeparator_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "setBackColor", VALUEFUNC(_wrap_FXHorizontalSeparator_setBackColor), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "tr", VALUEFUNC(_wrap_FXHorizontalSeparator_tr), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "dropEnable", VALUEFUNC(_wrap_FXHorizontalSeparator_dropEnable), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "dropDisable", VALUEFUNC(_wrap_FXHorizontalSeparator_dropDisable), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "setShape", VALUEFUNC(_wrap_FXHorizontalSeparator_setShape), -1);
+  rb_define_method(SwigClassFXHorizontalSeparator.klass, "clearShape", VALUEFUNC(_wrap_FXHorizontalSeparator_clearShape), -1);
+  SwigClassFXHorizontalSeparator.mark = (void (*)(void *)) FXRbHorizontalSeparator::markfunc;
+  SwigClassFXHorizontalSeparator.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXHorizontalSeparator.trackObjects = 0;
+  
+  SwigClassFXVerticalSeparator.klass = rb_define_class_under(mFox, "FXVerticalSeparator", ((swig_class *) SWIGTYPE_p_FXSeparator->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXVerticalSeparator, (void *) &SwigClassFXVerticalSeparator);
+  rb_define_alloc_func(SwigClassFXVerticalSeparator.klass, _wrap_FXVerticalSeparator_allocate);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "initialize", VALUEFUNC(_wrap_new_FXVerticalSeparator), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "save", VALUEFUNC(_wrap_FXVerticalSeparator_save), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "load", VALUEFUNC(_wrap_FXVerticalSeparator_load), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "create", VALUEFUNC(_wrap_FXVerticalSeparator_create), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "detach", VALUEFUNC(_wrap_FXVerticalSeparator_detach), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "destroy", VALUEFUNC(_wrap_FXVerticalSeparator_destroy), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "resize", VALUEFUNC(_wrap_FXVerticalSeparator_resize), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXVerticalSeparator_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXVerticalSeparator_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXVerticalSeparator_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXVerticalSeparator_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "canFocus", VALUEFUNC(_wrap_FXVerticalSeparator_canFocus), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "setFocus", VALUEFUNC(_wrap_FXVerticalSeparator_setFocus), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "killFocus", VALUEFUNC(_wrap_FXVerticalSeparator_killFocus), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "changeFocus", VALUEFUNC(_wrap_FXVerticalSeparator_changeFocus), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "setDefault", VALUEFUNC(_wrap_FXVerticalSeparator_setDefault), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "enable", VALUEFUNC(_wrap_FXVerticalSeparator_enable), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "disable", VALUEFUNC(_wrap_FXVerticalSeparator_disable), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "raiseWindow", VALUEFUNC(_wrap_FXVerticalSeparator_raiseWindow), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "lower", VALUEFUNC(_wrap_FXVerticalSeparator_lower), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "move", VALUEFUNC(_wrap_FXVerticalSeparator_move), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "position", VALUEFUNC(_wrap_FXVerticalSeparator_position), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "layout", VALUEFUNC(_wrap_FXVerticalSeparator_layout), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "recalc", VALUEFUNC(_wrap_FXVerticalSeparator_recalc), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "reparent", VALUEFUNC(_wrap_FXVerticalSeparator_reparent), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "show", VALUEFUNC(_wrap_FXVerticalSeparator_show), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "hide", VALUEFUNC(_wrap_FXVerticalSeparator_hide), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "isComposite", VALUEFUNC(_wrap_FXVerticalSeparator_isComposite), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "contains", VALUEFUNC(_wrap_FXVerticalSeparator_contains), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXVerticalSeparator_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "setBackColor", VALUEFUNC(_wrap_FXVerticalSeparator_setBackColor), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "tr", VALUEFUNC(_wrap_FXVerticalSeparator_tr), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "dropEnable", VALUEFUNC(_wrap_FXVerticalSeparator_dropEnable), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "dropDisable", VALUEFUNC(_wrap_FXVerticalSeparator_dropDisable), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "setShape", VALUEFUNC(_wrap_FXVerticalSeparator_setShape), -1);
+  rb_define_method(SwigClassFXVerticalSeparator.klass, "clearShape", VALUEFUNC(_wrap_FXVerticalSeparator_clearShape), -1);
+  SwigClassFXVerticalSeparator.mark = (void (*)(void *)) FXRbVerticalSeparator::markfunc;
+  SwigClassFXVerticalSeparator.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXVerticalSeparator.trackObjects = 0;
+  rb_define_const(mFox, "SLIDER_HORIZONTAL", SWIG_From_int(static_cast< int >(SLIDER_HORIZONTAL)));
+  rb_define_const(mFox, "SLIDER_VERTICAL", SWIG_From_int(static_cast< int >(SLIDER_VERTICAL)));
+  rb_define_const(mFox, "SLIDER_ARROW_UP", SWIG_From_int(static_cast< int >(SLIDER_ARROW_UP)));
+  rb_define_const(mFox, "SLIDER_ARROW_DOWN", SWIG_From_int(static_cast< int >(SLIDER_ARROW_DOWN)));
+  rb_define_const(mFox, "SLIDER_ARROW_LEFT", SWIG_From_int(static_cast< int >(SLIDER_ARROW_LEFT)));
+  rb_define_const(mFox, "SLIDER_ARROW_RIGHT", SWIG_From_int(static_cast< int >(SLIDER_ARROW_RIGHT)));
+  rb_define_const(mFox, "SLIDER_INSIDE_BAR", SWIG_From_int(static_cast< int >(SLIDER_INSIDE_BAR)));
+  rb_define_const(mFox, "SLIDER_TICKS_TOP", SWIG_From_int(static_cast< int >(SLIDER_TICKS_TOP)));
+  rb_define_const(mFox, "SLIDER_TICKS_BOTTOM", SWIG_From_int(static_cast< int >(SLIDER_TICKS_BOTTOM)));
+  rb_define_const(mFox, "SLIDER_TICKS_LEFT", SWIG_From_int(static_cast< int >(SLIDER_TICKS_LEFT)));
+  rb_define_const(mFox, "SLIDER_TICKS_RIGHT", SWIG_From_int(static_cast< int >(SLIDER_TICKS_RIGHT)));
+  rb_define_const(mFox, "SLIDER_NORMAL", SWIG_From_int(static_cast< int >(SLIDER_NORMAL)));
+  
+  SwigClassFXSlider.klass = rb_define_class_under(mFox, "FXSlider", ((swig_class *) SWIGTYPE_p_FXFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXSlider, (void *) &SwigClassFXSlider);
+  rb_define_alloc_func(SwigClassFXSlider.klass, _wrap_FXSlider_allocate);
+  rb_define_method(SwigClassFXSlider.klass, "initialize", VALUEFUNC(_wrap_new_FXSlider), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onPaint", VALUEFUNC(_wrap_FXSlider_onPaint), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onMotion", VALUEFUNC(_wrap_FXSlider_onMotion), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onMouseWheel", VALUEFUNC(_wrap_FXSlider_onMouseWheel), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXSlider_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXSlider_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onMiddleBtnPress", VALUEFUNC(_wrap_FXSlider_onMiddleBtnPress), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onMiddleBtnRelease", VALUEFUNC(_wrap_FXSlider_onMiddleBtnRelease), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onKeyPress", VALUEFUNC(_wrap_FXSlider_onKeyPress), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onKeyRelease", VALUEFUNC(_wrap_FXSlider_onKeyRelease), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onUngrabbed", VALUEFUNC(_wrap_FXSlider_onUngrabbed), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onAutoSlide", VALUEFUNC(_wrap_FXSlider_onAutoSlide), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXSlider_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXSlider_onCmdSetIntValue), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXSlider_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onCmdSetRealValue", VALUEFUNC(_wrap_FXSlider_onCmdSetRealValue), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onCmdGetRealValue", VALUEFUNC(_wrap_FXSlider_onCmdGetRealValue), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onCmdSetIntRange", VALUEFUNC(_wrap_FXSlider_onCmdSetIntRange), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onCmdGetIntRange", VALUEFUNC(_wrap_FXSlider_onCmdGetIntRange), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onCmdSetRealRange", VALUEFUNC(_wrap_FXSlider_onCmdSetRealRange), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onCmdGetRealRange", VALUEFUNC(_wrap_FXSlider_onCmdGetRealRange), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onCmdSetHelp", VALUEFUNC(_wrap_FXSlider_onCmdSetHelp), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onCmdGetHelp", VALUEFUNC(_wrap_FXSlider_onCmdGetHelp), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onCmdSetTip", VALUEFUNC(_wrap_FXSlider_onCmdSetTip), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onCmdGetTip", VALUEFUNC(_wrap_FXSlider_onCmdGetTip), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onQueryHelp", VALUEFUNC(_wrap_FXSlider_onQueryHelp), -1);
+  rb_define_method(SwigClassFXSlider.klass, "onQueryTip", VALUEFUNC(_wrap_FXSlider_onQueryTip), -1);
+  rb_define_const(SwigClassFXSlider.klass, "ID_AUTOSLIDE", SWIG_From_int(static_cast< int >(FXSlider::ID_AUTOSLIDE)));
+  rb_define_const(SwigClassFXSlider.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXSlider::ID_LAST)));
+  rb_define_method(SwigClassFXSlider.klass, "setValue", VALUEFUNC(_wrap_FXSlider_setValue), -1);
+  rb_define_method(SwigClassFXSlider.klass, "getValue", VALUEFUNC(_wrap_FXSlider_getValue), -1);
+  rb_define_method(SwigClassFXSlider.klass, "setRange", VALUEFUNC(_wrap_FXSlider_setRange), -1);
+  rb_define_method(SwigClassFXSlider.klass, "getRange", VALUEFUNC(_wrap_FXSlider_getRange), -1);
+  rb_define_method(SwigClassFXSlider.klass, "getSliderStyle", VALUEFUNC(_wrap_FXSlider_getSliderStyle), -1);
+  rb_define_method(SwigClassFXSlider.klass, "setSliderStyle", VALUEFUNC(_wrap_FXSlider_setSliderStyle), -1);
+  rb_define_method(SwigClassFXSlider.klass, "getHeadSize", VALUEFUNC(_wrap_FXSlider_getHeadSize), -1);
+  rb_define_method(SwigClassFXSlider.klass, "setHeadSize", VALUEFUNC(_wrap_FXSlider_setHeadSize), -1);
+  rb_define_method(SwigClassFXSlider.klass, "getSlotSize", VALUEFUNC(_wrap_FXSlider_getSlotSize), -1);
+  rb_define_method(SwigClassFXSlider.klass, "setSlotSize", VALUEFUNC(_wrap_FXSlider_setSlotSize), -1);
+  rb_define_method(SwigClassFXSlider.klass, "getIncrement", VALUEFUNC(_wrap_FXSlider_getIncrement), -1);
+  rb_define_method(SwigClassFXSlider.klass, "setIncrement", VALUEFUNC(_wrap_FXSlider_setIncrement), -1);
+  rb_define_method(SwigClassFXSlider.klass, "setTickDelta", VALUEFUNC(_wrap_FXSlider_setTickDelta), -1);
+  rb_define_method(SwigClassFXSlider.klass, "getTickDelta", VALUEFUNC(_wrap_FXSlider_getTickDelta), -1);
+  rb_define_method(SwigClassFXSlider.klass, "setSlotColor", VALUEFUNC(_wrap_FXSlider_setSlotColor), -1);
+  rb_define_method(SwigClassFXSlider.klass, "getSlotColor", VALUEFUNC(_wrap_FXSlider_getSlotColor), -1);
+  rb_define_method(SwigClassFXSlider.klass, "setHelpText", VALUEFUNC(_wrap_FXSlider_setHelpText), -1);
+  rb_define_method(SwigClassFXSlider.klass, "getHelpText", VALUEFUNC(_wrap_FXSlider_getHelpText), -1);
+  rb_define_method(SwigClassFXSlider.klass, "setTipText", VALUEFUNC(_wrap_FXSlider_setTipText), -1);
+  rb_define_method(SwigClassFXSlider.klass, "getTipText", VALUEFUNC(_wrap_FXSlider_getTipText), -1);
+  rb_define_method(SwigClassFXSlider.klass, "save", VALUEFUNC(_wrap_FXSlider_save), -1);
+  rb_define_method(SwigClassFXSlider.klass, "load", VALUEFUNC(_wrap_FXSlider_load), -1);
+  rb_define_method(SwigClassFXSlider.klass, "create", VALUEFUNC(_wrap_FXSlider_create), -1);
+  rb_define_method(SwigClassFXSlider.klass, "detach", VALUEFUNC(_wrap_FXSlider_detach), -1);
+  rb_define_method(SwigClassFXSlider.klass, "destroy", VALUEFUNC(_wrap_FXSlider_destroy), -1);
+  rb_define_method(SwigClassFXSlider.klass, "resize", VALUEFUNC(_wrap_FXSlider_resize), -1);
+  rb_define_method(SwigClassFXSlider.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXSlider_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXSlider.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXSlider_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXSlider.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXSlider_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXSlider.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXSlider_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXSlider.klass, "canFocus", VALUEFUNC(_wrap_FXSlider_canFocus), -1);
+  rb_define_method(SwigClassFXSlider.klass, "setFocus", VALUEFUNC(_wrap_FXSlider_setFocus), -1);
+  rb_define_method(SwigClassFXSlider.klass, "killFocus", VALUEFUNC(_wrap_FXSlider_killFocus), -1);
+  rb_define_method(SwigClassFXSlider.klass, "changeFocus", VALUEFUNC(_wrap_FXSlider_changeFocus), -1);
+  rb_define_method(SwigClassFXSlider.klass, "setDefault", VALUEFUNC(_wrap_FXSlider_setDefault), -1);
+  rb_define_method(SwigClassFXSlider.klass, "enable", VALUEFUNC(_wrap_FXSlider_enable), -1);
+  rb_define_method(SwigClassFXSlider.klass, "disable", VALUEFUNC(_wrap_FXSlider_disable), -1);
+  rb_define_method(SwigClassFXSlider.klass, "raiseWindow", VALUEFUNC(_wrap_FXSlider_raiseWindow), -1);
+  rb_define_method(SwigClassFXSlider.klass, "lower", VALUEFUNC(_wrap_FXSlider_lower), -1);
+  rb_define_method(SwigClassFXSlider.klass, "move", VALUEFUNC(_wrap_FXSlider_move), -1);
+  rb_define_method(SwigClassFXSlider.klass, "position", VALUEFUNC(_wrap_FXSlider_position), -1);
+  rb_define_method(SwigClassFXSlider.klass, "layout", VALUEFUNC(_wrap_FXSlider_layout), -1);
+  rb_define_method(SwigClassFXSlider.klass, "recalc", VALUEFUNC(_wrap_FXSlider_recalc), -1);
+  rb_define_method(SwigClassFXSlider.klass, "reparent", VALUEFUNC(_wrap_FXSlider_reparent), -1);
+  rb_define_method(SwigClassFXSlider.klass, "show", VALUEFUNC(_wrap_FXSlider_show), -1);
+  rb_define_method(SwigClassFXSlider.klass, "hide", VALUEFUNC(_wrap_FXSlider_hide), -1);
+  rb_define_method(SwigClassFXSlider.klass, "isComposite", VALUEFUNC(_wrap_FXSlider_isComposite), -1);
+  rb_define_method(SwigClassFXSlider.klass, "contains", VALUEFUNC(_wrap_FXSlider_contains), -1);
+  rb_define_method(SwigClassFXSlider.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXSlider_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXSlider.klass, "setBackColor", VALUEFUNC(_wrap_FXSlider_setBackColor), -1);
+  rb_define_method(SwigClassFXSlider.klass, "tr", VALUEFUNC(_wrap_FXSlider_tr), -1);
+  rb_define_method(SwigClassFXSlider.klass, "dropEnable", VALUEFUNC(_wrap_FXSlider_dropEnable), -1);
+  rb_define_method(SwigClassFXSlider.klass, "dropDisable", VALUEFUNC(_wrap_FXSlider_dropDisable), -1);
+  rb_define_method(SwigClassFXSlider.klass, "setShape", VALUEFUNC(_wrap_FXSlider_setShape), -1);
+  rb_define_method(SwigClassFXSlider.klass, "clearShape", VALUEFUNC(_wrap_FXSlider_clearShape), -1);
+  SwigClassFXSlider.mark = (void (*)(void *)) FXRbSlider::markfunc;
+  SwigClassFXSlider.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXSlider.trackObjects = 0;
+  rb_define_const(mFox, "REALSLIDER_HORIZONTAL", SWIG_From_int(static_cast< int >(REALSLIDER_HORIZONTAL)));
+  rb_define_const(mFox, "REALSLIDER_VERTICAL", SWIG_From_int(static_cast< int >(REALSLIDER_VERTICAL)));
+  rb_define_const(mFox, "REALSLIDER_ARROW_UP", SWIG_From_int(static_cast< int >(REALSLIDER_ARROW_UP)));
+  rb_define_const(mFox, "REALSLIDER_ARROW_DOWN", SWIG_From_int(static_cast< int >(REALSLIDER_ARROW_DOWN)));
+  rb_define_const(mFox, "REALSLIDER_ARROW_LEFT", SWIG_From_int(static_cast< int >(REALSLIDER_ARROW_LEFT)));
+  rb_define_const(mFox, "REALSLIDER_ARROW_RIGHT", SWIG_From_int(static_cast< int >(REALSLIDER_ARROW_RIGHT)));
+  rb_define_const(mFox, "REALSLIDER_INSIDE_BAR", SWIG_From_int(static_cast< int >(REALSLIDER_INSIDE_BAR)));
+  rb_define_const(mFox, "REALSLIDER_TICKS_TOP", SWIG_From_int(static_cast< int >(REALSLIDER_TICKS_TOP)));
+  rb_define_const(mFox, "REALSLIDER_TICKS_BOTTOM", SWIG_From_int(static_cast< int >(REALSLIDER_TICKS_BOTTOM)));
+  rb_define_const(mFox, "REALSLIDER_TICKS_LEFT", SWIG_From_int(static_cast< int >(REALSLIDER_TICKS_LEFT)));
+  rb_define_const(mFox, "REALSLIDER_TICKS_RIGHT", SWIG_From_int(static_cast< int >(REALSLIDER_TICKS_RIGHT)));
+  rb_define_const(mFox, "REALSLIDER_NORMAL", SWIG_From_int(static_cast< int >(REALSLIDER_NORMAL)));
+  
+  SwigClassFXRealSlider.klass = rb_define_class_under(mFox, "FXRealSlider", ((swig_class *) SWIGTYPE_p_FXFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXRealSlider, (void *) &SwigClassFXRealSlider);
+  rb_define_alloc_func(SwigClassFXRealSlider.klass, _wrap_FXRealSlider_allocate);
+  rb_define_method(SwigClassFXRealSlider.klass, "initialize", VALUEFUNC(_wrap_new_FXRealSlider), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onPaint", VALUEFUNC(_wrap_FXRealSlider_onPaint), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onMotion", VALUEFUNC(_wrap_FXRealSlider_onMotion), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onMouseWheel", VALUEFUNC(_wrap_FXRealSlider_onMouseWheel), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXRealSlider_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXRealSlider_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onMiddleBtnPress", VALUEFUNC(_wrap_FXRealSlider_onMiddleBtnPress), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onMiddleBtnRelease", VALUEFUNC(_wrap_FXRealSlider_onMiddleBtnRelease), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onKeyPress", VALUEFUNC(_wrap_FXRealSlider_onKeyPress), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onKeyRelease", VALUEFUNC(_wrap_FXRealSlider_onKeyRelease), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onUngrabbed", VALUEFUNC(_wrap_FXRealSlider_onUngrabbed), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onAutoSlide", VALUEFUNC(_wrap_FXRealSlider_onAutoSlide), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXRealSlider_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXRealSlider_onCmdSetIntValue), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXRealSlider_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onCmdSetRealValue", VALUEFUNC(_wrap_FXRealSlider_onCmdSetRealValue), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onCmdGetRealValue", VALUEFUNC(_wrap_FXRealSlider_onCmdGetRealValue), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onCmdSetIntRange", VALUEFUNC(_wrap_FXRealSlider_onCmdSetIntRange), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onCmdGetIntRange", VALUEFUNC(_wrap_FXRealSlider_onCmdGetIntRange), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onCmdSetRealRange", VALUEFUNC(_wrap_FXRealSlider_onCmdSetRealRange), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onCmdGetRealRange", VALUEFUNC(_wrap_FXRealSlider_onCmdGetRealRange), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onCmdSetHelp", VALUEFUNC(_wrap_FXRealSlider_onCmdSetHelp), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onCmdGetHelp", VALUEFUNC(_wrap_FXRealSlider_onCmdGetHelp), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onCmdSetTip", VALUEFUNC(_wrap_FXRealSlider_onCmdSetTip), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onCmdGetTip", VALUEFUNC(_wrap_FXRealSlider_onCmdGetTip), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onQueryHelp", VALUEFUNC(_wrap_FXRealSlider_onQueryHelp), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "onQueryTip", VALUEFUNC(_wrap_FXRealSlider_onQueryTip), -1);
+  rb_define_const(SwigClassFXRealSlider.klass, "ID_AUTOSLIDE", SWIG_From_int(static_cast< int >(FXRealSlider::ID_AUTOSLIDE)));
+  rb_define_const(SwigClassFXRealSlider.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXRealSlider::ID_LAST)));
+  rb_define_method(SwigClassFXRealSlider.klass, "setValue", VALUEFUNC(_wrap_FXRealSlider_setValue), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "getValue", VALUEFUNC(_wrap_FXRealSlider_getValue), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "setRange", VALUEFUNC(_wrap_FXRealSlider_setRange), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "getRange", VALUEFUNC(_wrap_FXRealSlider_getRange), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "getSliderStyle", VALUEFUNC(_wrap_FXRealSlider_getSliderStyle), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "setSliderStyle", VALUEFUNC(_wrap_FXRealSlider_setSliderStyle), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "getHeadSize", VALUEFUNC(_wrap_FXRealSlider_getHeadSize), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "setHeadSize", VALUEFUNC(_wrap_FXRealSlider_setHeadSize), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "getSlotSize", VALUEFUNC(_wrap_FXRealSlider_getSlotSize), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "setSlotSize", VALUEFUNC(_wrap_FXRealSlider_setSlotSize), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "getIncrement", VALUEFUNC(_wrap_FXRealSlider_getIncrement), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "setIncrement", VALUEFUNC(_wrap_FXRealSlider_setIncrement), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "setTickDelta", VALUEFUNC(_wrap_FXRealSlider_setTickDelta), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "getTickDelta", VALUEFUNC(_wrap_FXRealSlider_getTickDelta), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "setSlotColor", VALUEFUNC(_wrap_FXRealSlider_setSlotColor), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "getSlotColor", VALUEFUNC(_wrap_FXRealSlider_getSlotColor), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "setHelpText", VALUEFUNC(_wrap_FXRealSlider_setHelpText), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "getHelpText", VALUEFUNC(_wrap_FXRealSlider_getHelpText), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "setTipText", VALUEFUNC(_wrap_FXRealSlider_setTipText), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "getTipText", VALUEFUNC(_wrap_FXRealSlider_getTipText), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "save", VALUEFUNC(_wrap_FXRealSlider_save), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "load", VALUEFUNC(_wrap_FXRealSlider_load), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "create", VALUEFUNC(_wrap_FXRealSlider_create), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "detach", VALUEFUNC(_wrap_FXRealSlider_detach), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "destroy", VALUEFUNC(_wrap_FXRealSlider_destroy), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "resize", VALUEFUNC(_wrap_FXRealSlider_resize), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXRealSlider_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXRealSlider_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXRealSlider_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXRealSlider_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "canFocus", VALUEFUNC(_wrap_FXRealSlider_canFocus), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "setFocus", VALUEFUNC(_wrap_FXRealSlider_setFocus), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "killFocus", VALUEFUNC(_wrap_FXRealSlider_killFocus), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "changeFocus", VALUEFUNC(_wrap_FXRealSlider_changeFocus), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "setDefault", VALUEFUNC(_wrap_FXRealSlider_setDefault), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "enable", VALUEFUNC(_wrap_FXRealSlider_enable), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "disable", VALUEFUNC(_wrap_FXRealSlider_disable), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "raiseWindow", VALUEFUNC(_wrap_FXRealSlider_raiseWindow), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "lower", VALUEFUNC(_wrap_FXRealSlider_lower), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "move", VALUEFUNC(_wrap_FXRealSlider_move), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "position", VALUEFUNC(_wrap_FXRealSlider_position), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "layout", VALUEFUNC(_wrap_FXRealSlider_layout), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "recalc", VALUEFUNC(_wrap_FXRealSlider_recalc), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "reparent", VALUEFUNC(_wrap_FXRealSlider_reparent), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "show", VALUEFUNC(_wrap_FXRealSlider_show), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "hide", VALUEFUNC(_wrap_FXRealSlider_hide), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "isComposite", VALUEFUNC(_wrap_FXRealSlider_isComposite), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "contains", VALUEFUNC(_wrap_FXRealSlider_contains), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXRealSlider_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "setBackColor", VALUEFUNC(_wrap_FXRealSlider_setBackColor), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "tr", VALUEFUNC(_wrap_FXRealSlider_tr), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "dropEnable", VALUEFUNC(_wrap_FXRealSlider_dropEnable), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "dropDisable", VALUEFUNC(_wrap_FXRealSlider_dropDisable), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "setShape", VALUEFUNC(_wrap_FXRealSlider_setShape), -1);
+  rb_define_method(SwigClassFXRealSlider.klass, "clearShape", VALUEFUNC(_wrap_FXRealSlider_clearShape), -1);
+  SwigClassFXRealSlider.mark = (void (*)(void *)) FXRbRealSlider::markfunc;
+  SwigClassFXRealSlider.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXRealSlider.trackObjects = 0;
+  
+  SwigClassFXStatusLine.klass = rb_define_class_under(mFox, "FXStatusLine", ((swig_class *) SWIGTYPE_p_FXFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXStatusLine, (void *) &SwigClassFXStatusLine);
+  rb_define_alloc_func(SwigClassFXStatusLine.klass, _wrap_FXStatusLine_allocate);
+  rb_define_method(SwigClassFXStatusLine.klass, "initialize", VALUEFUNC(_wrap_new_FXStatusLine), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "onPaint", VALUEFUNC(_wrap_FXStatusLine_onPaint), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "onUpdate", VALUEFUNC(_wrap_FXStatusLine_onUpdate), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "onCmdGetStringValue", VALUEFUNC(_wrap_FXStatusLine_onCmdGetStringValue), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "onCmdSetStringValue", VALUEFUNC(_wrap_FXStatusLine_onCmdSetStringValue), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "setText", VALUEFUNC(_wrap_FXStatusLine_setText), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "getText", VALUEFUNC(_wrap_FXStatusLine_getText), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "setNormalText", VALUEFUNC(_wrap_FXStatusLine_setNormalText), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "getNormalText", VALUEFUNC(_wrap_FXStatusLine_getNormalText), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "setFont", VALUEFUNC(_wrap_FXStatusLine_setFont), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "getFont", VALUEFUNC(_wrap_FXStatusLine_getFont), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "getTextColor", VALUEFUNC(_wrap_FXStatusLine_getTextColor), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "setTextColor", VALUEFUNC(_wrap_FXStatusLine_setTextColor), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "getTextHighlightColor", VALUEFUNC(_wrap_FXStatusLine_getTextHighlightColor), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "setTextHighlightColor", VALUEFUNC(_wrap_FXStatusLine_setTextHighlightColor), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "save", VALUEFUNC(_wrap_FXStatusLine_save), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "load", VALUEFUNC(_wrap_FXStatusLine_load), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "create", VALUEFUNC(_wrap_FXStatusLine_create), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "detach", VALUEFUNC(_wrap_FXStatusLine_detach), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "destroy", VALUEFUNC(_wrap_FXStatusLine_destroy), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "resize", VALUEFUNC(_wrap_FXStatusLine_resize), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXStatusLine_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXStatusLine_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXStatusLine_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXStatusLine_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "canFocus", VALUEFUNC(_wrap_FXStatusLine_canFocus), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "setFocus", VALUEFUNC(_wrap_FXStatusLine_setFocus), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "killFocus", VALUEFUNC(_wrap_FXStatusLine_killFocus), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "changeFocus", VALUEFUNC(_wrap_FXStatusLine_changeFocus), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "setDefault", VALUEFUNC(_wrap_FXStatusLine_setDefault), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "enable", VALUEFUNC(_wrap_FXStatusLine_enable), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "disable", VALUEFUNC(_wrap_FXStatusLine_disable), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "raiseWindow", VALUEFUNC(_wrap_FXStatusLine_raiseWindow), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "lower", VALUEFUNC(_wrap_FXStatusLine_lower), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "move", VALUEFUNC(_wrap_FXStatusLine_move), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "position", VALUEFUNC(_wrap_FXStatusLine_position), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "layout", VALUEFUNC(_wrap_FXStatusLine_layout), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "recalc", VALUEFUNC(_wrap_FXStatusLine_recalc), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "reparent", VALUEFUNC(_wrap_FXStatusLine_reparent), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "show", VALUEFUNC(_wrap_FXStatusLine_show), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "hide", VALUEFUNC(_wrap_FXStatusLine_hide), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "isComposite", VALUEFUNC(_wrap_FXStatusLine_isComposite), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "contains", VALUEFUNC(_wrap_FXStatusLine_contains), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXStatusLine_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "setBackColor", VALUEFUNC(_wrap_FXStatusLine_setBackColor), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "tr", VALUEFUNC(_wrap_FXStatusLine_tr), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "dropEnable", VALUEFUNC(_wrap_FXStatusLine_dropEnable), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "dropDisable", VALUEFUNC(_wrap_FXStatusLine_dropDisable), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "setShape", VALUEFUNC(_wrap_FXStatusLine_setShape), -1);
+  rb_define_method(SwigClassFXStatusLine.klass, "clearShape", VALUEFUNC(_wrap_FXStatusLine_clearShape), -1);
+  SwigClassFXStatusLine.mark = (void (*)(void *)) FXRbStatusLine::markfunc;
+  SwigClassFXStatusLine.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXStatusLine.trackObjects = 0;
+  rb_define_const(mFox, "TEXTFIELD_PASSWD", SWIG_From_int(static_cast< int >(TEXTFIELD_PASSWD)));
+  rb_define_const(mFox, "TEXTFIELD_INTEGER", SWIG_From_int(static_cast< int >(TEXTFIELD_INTEGER)));
+  rb_define_const(mFox, "TEXTFIELD_REAL", SWIG_From_int(static_cast< int >(TEXTFIELD_REAL)));
+  rb_define_const(mFox, "TEXTFIELD_READONLY", SWIG_From_int(static_cast< int >(TEXTFIELD_READONLY)));
+  rb_define_const(mFox, "TEXTFIELD_ENTER_ONLY", SWIG_From_int(static_cast< int >(TEXTFIELD_ENTER_ONLY)));
+  rb_define_const(mFox, "TEXTFIELD_LIMITED", SWIG_From_int(static_cast< int >(TEXTFIELD_LIMITED)));
+  rb_define_const(mFox, "TEXTFIELD_OVERSTRIKE", SWIG_From_int(static_cast< int >(TEXTFIELD_OVERSTRIKE)));
+  rb_define_const(mFox, "TEXTFIELD_AUTOGRAY", SWIG_From_int(static_cast< int >(TEXTFIELD_AUTOGRAY)));
+  rb_define_const(mFox, "TEXTFIELD_AUTOHIDE", SWIG_From_int(static_cast< int >(TEXTFIELD_AUTOHIDE)));
+  rb_define_const(mFox, "TEXTFIELD_NORMAL", SWIG_From_int(static_cast< int >(TEXTFIELD_NORMAL)));
+  
+  SwigClassFXTextField.klass = rb_define_class_under(mFox, "FXTextField", ((swig_class *) SWIGTYPE_p_FXFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXTextField, (void *) &SwigClassFXTextField);
+  rb_define_alloc_func(SwigClassFXTextField.klass, _wrap_FXTextField_allocate);
+  rb_define_method(SwigClassFXTextField.klass, "initialize", VALUEFUNC(_wrap_new_FXTextField), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onPaint", VALUEFUNC(_wrap_FXTextField_onPaint), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onUpdate", VALUEFUNC(_wrap_FXTextField_onUpdate), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onKeyPress", VALUEFUNC(_wrap_FXTextField_onKeyPress), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onKeyRelease", VALUEFUNC(_wrap_FXTextField_onKeyRelease), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXTextField_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXTextField_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onMiddleBtnPress", VALUEFUNC(_wrap_FXTextField_onMiddleBtnPress), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onMiddleBtnRelease", VALUEFUNC(_wrap_FXTextField_onMiddleBtnRelease), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onVerify", VALUEFUNC(_wrap_FXTextField_onVerify), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onMotion", VALUEFUNC(_wrap_FXTextField_onMotion), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onSelectionLost", VALUEFUNC(_wrap_FXTextField_onSelectionLost), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onSelectionGained", VALUEFUNC(_wrap_FXTextField_onSelectionGained), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onSelectionRequest", VALUEFUNC(_wrap_FXTextField_onSelectionRequest), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onClipboardLost", VALUEFUNC(_wrap_FXTextField_onClipboardLost), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onClipboardGained", VALUEFUNC(_wrap_FXTextField_onClipboardGained), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onClipboardRequest", VALUEFUNC(_wrap_FXTextField_onClipboardRequest), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onFocusSelf", VALUEFUNC(_wrap_FXTextField_onFocusSelf), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onFocusIn", VALUEFUNC(_wrap_FXTextField_onFocusIn), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onFocusOut", VALUEFUNC(_wrap_FXTextField_onFocusOut), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onBlink", VALUEFUNC(_wrap_FXTextField_onBlink), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onAutoScroll", VALUEFUNC(_wrap_FXTextField_onAutoScroll), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXTextField_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXTextField_onCmdSetIntValue), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdSetRealValue", VALUEFUNC(_wrap_FXTextField_onCmdSetRealValue), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdSetStringValue", VALUEFUNC(_wrap_FXTextField_onCmdSetStringValue), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXTextField_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdGetRealValue", VALUEFUNC(_wrap_FXTextField_onCmdGetRealValue), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdGetStringValue", VALUEFUNC(_wrap_FXTextField_onCmdGetStringValue), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdCursorHome", VALUEFUNC(_wrap_FXTextField_onCmdCursorHome), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdCursorEnd", VALUEFUNC(_wrap_FXTextField_onCmdCursorEnd), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdCursorRight", VALUEFUNC(_wrap_FXTextField_onCmdCursorRight), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdCursorLeft", VALUEFUNC(_wrap_FXTextField_onCmdCursorLeft), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdCursorWordLeft", VALUEFUNC(_wrap_FXTextField_onCmdCursorWordLeft), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdCursorWordRight", VALUEFUNC(_wrap_FXTextField_onCmdCursorWordRight), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdCursorWordStart", VALUEFUNC(_wrap_FXTextField_onCmdCursorWordStart), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdCursorWordEnd", VALUEFUNC(_wrap_FXTextField_onCmdCursorWordEnd), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdMark", VALUEFUNC(_wrap_FXTextField_onCmdMark), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdExtend", VALUEFUNC(_wrap_FXTextField_onCmdExtend), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdSelectAll", VALUEFUNC(_wrap_FXTextField_onCmdSelectAll), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdDeselectAll", VALUEFUNC(_wrap_FXTextField_onCmdDeselectAll), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdCutSel", VALUEFUNC(_wrap_FXTextField_onCmdCutSel), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdCopySel", VALUEFUNC(_wrap_FXTextField_onCmdCopySel), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdPasteSel", VALUEFUNC(_wrap_FXTextField_onCmdPasteSel), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdPasteMiddle", VALUEFUNC(_wrap_FXTextField_onCmdPasteMiddle), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdDeleteSel", VALUEFUNC(_wrap_FXTextField_onCmdDeleteSel), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdDeleteAll", VALUEFUNC(_wrap_FXTextField_onCmdDeleteAll), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdOverstString", VALUEFUNC(_wrap_FXTextField_onCmdOverstString), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdInsertString", VALUEFUNC(_wrap_FXTextField_onCmdInsertString), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdBackspace", VALUEFUNC(_wrap_FXTextField_onCmdBackspace), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdDelete", VALUEFUNC(_wrap_FXTextField_onCmdDelete), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdToggleEditable", VALUEFUNC(_wrap_FXTextField_onCmdToggleEditable), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onUpdToggleEditable", VALUEFUNC(_wrap_FXTextField_onUpdToggleEditable), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdToggleOverstrike", VALUEFUNC(_wrap_FXTextField_onCmdToggleOverstrike), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onUpdToggleOverstrike", VALUEFUNC(_wrap_FXTextField_onUpdToggleOverstrike), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onUpdHaveSelection", VALUEFUNC(_wrap_FXTextField_onUpdHaveSelection), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onUpdSelectAll", VALUEFUNC(_wrap_FXTextField_onUpdSelectAll), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdSetHelp", VALUEFUNC(_wrap_FXTextField_onCmdSetHelp), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdGetHelp", VALUEFUNC(_wrap_FXTextField_onCmdGetHelp), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdSetTip", VALUEFUNC(_wrap_FXTextField_onCmdSetTip), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onCmdGetTip", VALUEFUNC(_wrap_FXTextField_onCmdGetTip), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onQueryHelp", VALUEFUNC(_wrap_FXTextField_onQueryHelp), -1);
+  rb_define_method(SwigClassFXTextField.klass, "onQueryTip", VALUEFUNC(_wrap_FXTextField_onQueryTip), -1);
+  rb_define_singleton_method(SwigClassFXTextField.klass, "textDelimiters", VALUEFUNC(_wrap_FXTextField_textDelimiters_get), 0);
+  rb_define_const(SwigClassFXTextField.klass, "ID_CURSOR_HOME", SWIG_From_int(static_cast< int >(FXTextField::ID_CURSOR_HOME)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_CURSOR_END", SWIG_From_int(static_cast< int >(FXTextField::ID_CURSOR_END)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_CURSOR_RIGHT", SWIG_From_int(static_cast< int >(FXTextField::ID_CURSOR_RIGHT)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_CURSOR_LEFT", SWIG_From_int(static_cast< int >(FXTextField::ID_CURSOR_LEFT)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_CURSOR_WORD_LEFT", SWIG_From_int(static_cast< int >(FXTextField::ID_CURSOR_WORD_LEFT)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_CURSOR_WORD_RIGHT", SWIG_From_int(static_cast< int >(FXTextField::ID_CURSOR_WORD_RIGHT)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_CURSOR_WORD_START", SWIG_From_int(static_cast< int >(FXTextField::ID_CURSOR_WORD_START)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_CURSOR_WORD_END", SWIG_From_int(static_cast< int >(FXTextField::ID_CURSOR_WORD_END)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_MARK", SWIG_From_int(static_cast< int >(FXTextField::ID_MARK)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_EXTEND", SWIG_From_int(static_cast< int >(FXTextField::ID_EXTEND)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_SELECT_ALL", SWIG_From_int(static_cast< int >(FXTextField::ID_SELECT_ALL)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_DESELECT_ALL", SWIG_From_int(static_cast< int >(FXTextField::ID_DESELECT_ALL)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_CUT_SEL", SWIG_From_int(static_cast< int >(FXTextField::ID_CUT_SEL)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_COPY_SEL", SWIG_From_int(static_cast< int >(FXTextField::ID_COPY_SEL)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_PASTE_SEL", SWIG_From_int(static_cast< int >(FXTextField::ID_PASTE_SEL)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_DELETE_SEL", SWIG_From_int(static_cast< int >(FXTextField::ID_DELETE_SEL)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_DELETE_ALL", SWIG_From_int(static_cast< int >(FXTextField::ID_DELETE_ALL)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_OVERST_STRING", SWIG_From_int(static_cast< int >(FXTextField::ID_OVERST_STRING)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_INSERT_STRING", SWIG_From_int(static_cast< int >(FXTextField::ID_INSERT_STRING)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_BACKSPACE", SWIG_From_int(static_cast< int >(FXTextField::ID_BACKSPACE)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_DELETE", SWIG_From_int(static_cast< int >(FXTextField::ID_DELETE)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_TOGGLE_EDITABLE", SWIG_From_int(static_cast< int >(FXTextField::ID_TOGGLE_EDITABLE)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_TOGGLE_OVERSTRIKE", SWIG_From_int(static_cast< int >(FXTextField::ID_TOGGLE_OVERSTRIKE)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_BLINK", SWIG_From_int(static_cast< int >(FXTextField::ID_BLINK)));
+  rb_define_const(SwigClassFXTextField.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXTextField::ID_LAST)));
+  rb_define_method(SwigClassFXTextField.klass, "setEditable", VALUEFUNC(_wrap_FXTextField_setEditable), -1);
+  rb_define_method(SwigClassFXTextField.klass, "isEditable", VALUEFUNC(_wrap_FXTextField_isEditable), -1);
+  rb_define_method(SwigClassFXTextField.klass, "overstrike=", VALUEFUNC(_wrap_FXTextField_overstrikee___), -1);
+  rb_define_method(SwigClassFXTextField.klass, "overstrike?", VALUEFUNC(_wrap_FXTextField_overstrikeq___), -1);
+  rb_define_method(SwigClassFXTextField.klass, "setCursorPos", VALUEFUNC(_wrap_FXTextField_setCursorPos), -1);
+  rb_define_method(SwigClassFXTextField.klass, "getCursorPos", VALUEFUNC(_wrap_FXTextField_getCursorPos), -1);
+  rb_define_method(SwigClassFXTextField.klass, "setAnchorPos", VALUEFUNC(_wrap_FXTextField_setAnchorPos), -1);
+  rb_define_method(SwigClassFXTextField.klass, "getAnchorPos", VALUEFUNC(_wrap_FXTextField_getAnchorPos), -1);
+  rb_define_method(SwigClassFXTextField.klass, "setText", VALUEFUNC(_wrap_FXTextField_setText), -1);
+  rb_define_method(SwigClassFXTextField.klass, "getText", VALUEFUNC(_wrap_FXTextField_getText), -1);
+  rb_define_method(SwigClassFXTextField.klass, "setFont", VALUEFUNC(_wrap_FXTextField_setFont), -1);
+  rb_define_method(SwigClassFXTextField.klass, "getFont", VALUEFUNC(_wrap_FXTextField_getFont), -1);
+  rb_define_method(SwigClassFXTextField.klass, "setTextColor", VALUEFUNC(_wrap_FXTextField_setTextColor), -1);
+  rb_define_method(SwigClassFXTextField.klass, "getTextColor", VALUEFUNC(_wrap_FXTextField_getTextColor), -1);
+  rb_define_method(SwigClassFXTextField.klass, "setSelBackColor", VALUEFUNC(_wrap_FXTextField_setSelBackColor), -1);
+  rb_define_method(SwigClassFXTextField.klass, "getSelBackColor", VALUEFUNC(_wrap_FXTextField_getSelBackColor), -1);
+  rb_define_method(SwigClassFXTextField.klass, "setSelTextColor", VALUEFUNC(_wrap_FXTextField_setSelTextColor), -1);
+  rb_define_method(SwigClassFXTextField.klass, "getSelTextColor", VALUEFUNC(_wrap_FXTextField_getSelTextColor), -1);
+  rb_define_method(SwigClassFXTextField.klass, "setCursorColor", VALUEFUNC(_wrap_FXTextField_setCursorColor), -1);
+  rb_define_method(SwigClassFXTextField.klass, "getCursorColor", VALUEFUNC(_wrap_FXTextField_getCursorColor), -1);
+  rb_define_method(SwigClassFXTextField.klass, "setNumColumns", VALUEFUNC(_wrap_FXTextField_setNumColumns), -1);
+  rb_define_method(SwigClassFXTextField.klass, "getNumColumns", VALUEFUNC(_wrap_FXTextField_getNumColumns), -1);
+  rb_define_method(SwigClassFXTextField.klass, "setJustify", VALUEFUNC(_wrap_FXTextField_setJustify), -1);
+  rb_define_method(SwigClassFXTextField.klass, "getJustify", VALUEFUNC(_wrap_FXTextField_getJustify), -1);
+  rb_define_method(SwigClassFXTextField.klass, "setDelimiters", VALUEFUNC(_wrap_FXTextField_setDelimiters), -1);
+  rb_define_method(SwigClassFXTextField.klass, "getDelimiters", VALUEFUNC(_wrap_FXTextField_getDelimiters), -1);
+  rb_define_method(SwigClassFXTextField.klass, "setHelpText", VALUEFUNC(_wrap_FXTextField_setHelpText), -1);
+  rb_define_method(SwigClassFXTextField.klass, "getHelpText", VALUEFUNC(_wrap_FXTextField_getHelpText), -1);
+  rb_define_method(SwigClassFXTextField.klass, "setTipText", VALUEFUNC(_wrap_FXTextField_setTipText), -1);
+  rb_define_method(SwigClassFXTextField.klass, "getTipText", VALUEFUNC(_wrap_FXTextField_getTipText), -1);
+  rb_define_method(SwigClassFXTextField.klass, "setTextStyle", VALUEFUNC(_wrap_FXTextField_setTextStyle), -1);
+  rb_define_method(SwigClassFXTextField.klass, "getTextStyle", VALUEFUNC(_wrap_FXTextField_getTextStyle), -1);
+  rb_define_method(SwigClassFXTextField.klass, "selectAll", VALUEFUNC(_wrap_FXTextField_selectAll), -1);
+  rb_define_method(SwigClassFXTextField.klass, "setSelection", VALUEFUNC(_wrap_FXTextField_setSelection), -1);
+  rb_define_method(SwigClassFXTextField.klass, "extendSelection", VALUEFUNC(_wrap_FXTextField_extendSelection), -1);
+  rb_define_method(SwigClassFXTextField.klass, "killSelection", VALUEFUNC(_wrap_FXTextField_killSelection), -1);
+  rb_define_method(SwigClassFXTextField.klass, "isPosSelected", VALUEFUNC(_wrap_FXTextField_isPosSelected), -1);
+  rb_define_method(SwigClassFXTextField.klass, "isPosVisible", VALUEFUNC(_wrap_FXTextField_isPosVisible), -1);
+  rb_define_method(SwigClassFXTextField.klass, "makePositionVisible", VALUEFUNC(_wrap_FXTextField_makePositionVisible), -1);
+  rb_define_method(SwigClassFXTextField.klass, "save", VALUEFUNC(_wrap_FXTextField_save), -1);
+  rb_define_method(SwigClassFXTextField.klass, "load", VALUEFUNC(_wrap_FXTextField_load), -1);
+  rb_define_method(SwigClassFXTextField.klass, "create", VALUEFUNC(_wrap_FXTextField_create), -1);
+  rb_define_method(SwigClassFXTextField.klass, "detach", VALUEFUNC(_wrap_FXTextField_detach), -1);
+  rb_define_method(SwigClassFXTextField.klass, "destroy", VALUEFUNC(_wrap_FXTextField_destroy), -1);
+  rb_define_method(SwigClassFXTextField.klass, "resize", VALUEFUNC(_wrap_FXTextField_resize), -1);
+  rb_define_method(SwigClassFXTextField.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXTextField_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXTextField.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXTextField_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXTextField.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXTextField_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXTextField.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXTextField_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXTextField.klass, "canFocus", VALUEFUNC(_wrap_FXTextField_canFocus), -1);
+  rb_define_method(SwigClassFXTextField.klass, "setFocus", VALUEFUNC(_wrap_FXTextField_setFocus), -1);
+  rb_define_method(SwigClassFXTextField.klass, "killFocus", VALUEFUNC(_wrap_FXTextField_killFocus), -1);
+  rb_define_method(SwigClassFXTextField.klass, "changeFocus", VALUEFUNC(_wrap_FXTextField_changeFocus), -1);
+  rb_define_method(SwigClassFXTextField.klass, "setDefault", VALUEFUNC(_wrap_FXTextField_setDefault), -1);
+  rb_define_method(SwigClassFXTextField.klass, "enable", VALUEFUNC(_wrap_FXTextField_enable), -1);
+  rb_define_method(SwigClassFXTextField.klass, "disable", VALUEFUNC(_wrap_FXTextField_disable), -1);
+  rb_define_method(SwigClassFXTextField.klass, "raiseWindow", VALUEFUNC(_wrap_FXTextField_raiseWindow), -1);
+  rb_define_method(SwigClassFXTextField.klass, "lower", VALUEFUNC(_wrap_FXTextField_lower), -1);
+  rb_define_method(SwigClassFXTextField.klass, "move", VALUEFUNC(_wrap_FXTextField_move), -1);
+  rb_define_method(SwigClassFXTextField.klass, "position", VALUEFUNC(_wrap_FXTextField_position), -1);
+  rb_define_method(SwigClassFXTextField.klass, "layout", VALUEFUNC(_wrap_FXTextField_layout), -1);
+  rb_define_method(SwigClassFXTextField.klass, "recalc", VALUEFUNC(_wrap_FXTextField_recalc), -1);
+  rb_define_method(SwigClassFXTextField.klass, "reparent", VALUEFUNC(_wrap_FXTextField_reparent), -1);
+  rb_define_method(SwigClassFXTextField.klass, "show", VALUEFUNC(_wrap_FXTextField_show), -1);
+  rb_define_method(SwigClassFXTextField.klass, "hide", VALUEFUNC(_wrap_FXTextField_hide), -1);
+  rb_define_method(SwigClassFXTextField.klass, "isComposite", VALUEFUNC(_wrap_FXTextField_isComposite), -1);
+  rb_define_method(SwigClassFXTextField.klass, "contains", VALUEFUNC(_wrap_FXTextField_contains), -1);
+  rb_define_method(SwigClassFXTextField.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXTextField_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXTextField.klass, "setBackColor", VALUEFUNC(_wrap_FXTextField_setBackColor), -1);
+  rb_define_method(SwigClassFXTextField.klass, "tr", VALUEFUNC(_wrap_FXTextField_tr), -1);
+  rb_define_method(SwigClassFXTextField.klass, "dropEnable", VALUEFUNC(_wrap_FXTextField_dropEnable), -1);
+  rb_define_method(SwigClassFXTextField.klass, "dropDisable", VALUEFUNC(_wrap_FXTextField_dropDisable), -1);
+  rb_define_method(SwigClassFXTextField.klass, "setShape", VALUEFUNC(_wrap_FXTextField_setShape), -1);
+  rb_define_method(SwigClassFXTextField.klass, "clearShape", VALUEFUNC(_wrap_FXTextField_clearShape), -1);
+  SwigClassFXTextField.mark = (void (*)(void *)) FXRbTextField::markfunc;
+  SwigClassFXTextField.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXTextField.trackObjects = 0;
+  rb_define_const(mFox, "TOOLBARTAB_HORIZONTAL", SWIG_From_int(static_cast< int >(TOOLBARTAB_HORIZONTAL)));
+  rb_define_const(mFox, "TOOLBARTAB_VERTICAL", SWIG_From_int(static_cast< int >(TOOLBARTAB_VERTICAL)));
+  
+  SwigClassFXToolBarTab.klass = rb_define_class_under(mFox, "FXToolBarTab", ((swig_class *) SWIGTYPE_p_FXFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXToolBarTab, (void *) &SwigClassFXToolBarTab);
+  rb_define_alloc_func(SwigClassFXToolBarTab.klass, _wrap_FXToolBarTab_allocate);
+  rb_define_method(SwigClassFXToolBarTab.klass, "initialize", VALUEFUNC(_wrap_new_FXToolBarTab), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "onPaint", VALUEFUNC(_wrap_FXToolBarTab_onPaint), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "onUpdate", VALUEFUNC(_wrap_FXToolBarTab_onUpdate), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "onEnter", VALUEFUNC(_wrap_FXToolBarTab_onEnter), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "onLeave", VALUEFUNC(_wrap_FXToolBarTab_onLeave), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "onUngrabbed", VALUEFUNC(_wrap_FXToolBarTab_onUngrabbed), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXToolBarTab_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXToolBarTab_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "onKeyPress", VALUEFUNC(_wrap_FXToolBarTab_onKeyPress), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "onKeyRelease", VALUEFUNC(_wrap_FXToolBarTab_onKeyRelease), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "onCmdCollapse", VALUEFUNC(_wrap_FXToolBarTab_onCmdCollapse), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "onUpdCollapse", VALUEFUNC(_wrap_FXToolBarTab_onUpdCollapse), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "onCmdUncollapse", VALUEFUNC(_wrap_FXToolBarTab_onCmdUncollapse), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "onUpdUncollapse", VALUEFUNC(_wrap_FXToolBarTab_onUpdUncollapse), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "onCmdSetTip", VALUEFUNC(_wrap_FXToolBarTab_onCmdSetTip), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "onCmdGetTip", VALUEFUNC(_wrap_FXToolBarTab_onCmdGetTip), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "onQueryTip", VALUEFUNC(_wrap_FXToolBarTab_onQueryTip), -1);
+  rb_define_const(SwigClassFXToolBarTab.klass, "ID_COLLAPSE", SWIG_From_int(static_cast< int >(FXToolBarTab::ID_COLLAPSE)));
+  rb_define_const(SwigClassFXToolBarTab.klass, "ID_UNCOLLAPSE", SWIG_From_int(static_cast< int >(FXToolBarTab::ID_UNCOLLAPSE)));
+  rb_define_const(SwigClassFXToolBarTab.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXToolBarTab::ID_LAST)));
+  rb_define_method(SwigClassFXToolBarTab.klass, "collapse", VALUEFUNC(_wrap_FXToolBarTab_collapse), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "isCollapsed", VALUEFUNC(_wrap_FXToolBarTab_isCollapsed), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "setTabStyle", VALUEFUNC(_wrap_FXToolBarTab_setTabStyle), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "getTabStyle", VALUEFUNC(_wrap_FXToolBarTab_getTabStyle), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "getActiveColor", VALUEFUNC(_wrap_FXToolBarTab_getActiveColor), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "setActiveColor", VALUEFUNC(_wrap_FXToolBarTab_setActiveColor), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "setTipText", VALUEFUNC(_wrap_FXToolBarTab_setTipText), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "getTipText", VALUEFUNC(_wrap_FXToolBarTab_getTipText), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "save", VALUEFUNC(_wrap_FXToolBarTab_save), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "load", VALUEFUNC(_wrap_FXToolBarTab_load), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "create", VALUEFUNC(_wrap_FXToolBarTab_create), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "detach", VALUEFUNC(_wrap_FXToolBarTab_detach), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "destroy", VALUEFUNC(_wrap_FXToolBarTab_destroy), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "resize", VALUEFUNC(_wrap_FXToolBarTab_resize), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXToolBarTab_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXToolBarTab_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXToolBarTab_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXToolBarTab_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "canFocus", VALUEFUNC(_wrap_FXToolBarTab_canFocus), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "setFocus", VALUEFUNC(_wrap_FXToolBarTab_setFocus), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "killFocus", VALUEFUNC(_wrap_FXToolBarTab_killFocus), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "changeFocus", VALUEFUNC(_wrap_FXToolBarTab_changeFocus), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "setDefault", VALUEFUNC(_wrap_FXToolBarTab_setDefault), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "enable", VALUEFUNC(_wrap_FXToolBarTab_enable), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "disable", VALUEFUNC(_wrap_FXToolBarTab_disable), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "raiseWindow", VALUEFUNC(_wrap_FXToolBarTab_raiseWindow), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "lower", VALUEFUNC(_wrap_FXToolBarTab_lower), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "move", VALUEFUNC(_wrap_FXToolBarTab_move), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "position", VALUEFUNC(_wrap_FXToolBarTab_position), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "layout", VALUEFUNC(_wrap_FXToolBarTab_layout), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "recalc", VALUEFUNC(_wrap_FXToolBarTab_recalc), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "reparent", VALUEFUNC(_wrap_FXToolBarTab_reparent), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "show", VALUEFUNC(_wrap_FXToolBarTab_show), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "hide", VALUEFUNC(_wrap_FXToolBarTab_hide), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "isComposite", VALUEFUNC(_wrap_FXToolBarTab_isComposite), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "contains", VALUEFUNC(_wrap_FXToolBarTab_contains), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXToolBarTab_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "setBackColor", VALUEFUNC(_wrap_FXToolBarTab_setBackColor), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "tr", VALUEFUNC(_wrap_FXToolBarTab_tr), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "dropEnable", VALUEFUNC(_wrap_FXToolBarTab_dropEnable), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "dropDisable", VALUEFUNC(_wrap_FXToolBarTab_dropDisable), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "setShape", VALUEFUNC(_wrap_FXToolBarTab_setShape), -1);
+  rb_define_method(SwigClassFXToolBarTab.klass, "clearShape", VALUEFUNC(_wrap_FXToolBarTab_clearShape), -1);
+  SwigClassFXToolBarTab.mark = (void (*)(void *)) FXRbToolBarTab::markfunc;
+  SwigClassFXToolBarTab.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXToolBarTab.trackObjects = 0;
+  rb_define_const(mFox, "GRADIENTBAR_HORIZONTAL", SWIG_From_int(static_cast< int >(GRADIENTBAR_HORIZONTAL)));
+  rb_define_const(mFox, "GRADIENTBAR_VERTICAL", SWIG_From_int(static_cast< int >(GRADIENTBAR_VERTICAL)));
+  rb_define_const(mFox, "GRADIENTBAR_NO_CONTROLS", SWIG_From_int(static_cast< int >(GRADIENTBAR_NO_CONTROLS)));
+  rb_define_const(mFox, "GRADIENTBAR_CONTROLS_TOP", SWIG_From_int(static_cast< int >(GRADIENTBAR_CONTROLS_TOP)));
+  rb_define_const(mFox, "GRADIENTBAR_CONTROLS_BOTTOM", SWIG_From_int(static_cast< int >(GRADIENTBAR_CONTROLS_BOTTOM)));
+  rb_define_const(mFox, "GRADIENTBAR_CONTROLS_LEFT", SWIG_From_int(static_cast< int >(GRADIENTBAR_CONTROLS_LEFT)));
+  rb_define_const(mFox, "GRADIENTBAR_CONTROLS_RIGHT", SWIG_From_int(static_cast< int >(GRADIENTBAR_CONTROLS_RIGHT)));
+  rb_define_const(mFox, "GRADIENT_BLEND_LINEAR", SWIG_From_int(static_cast< int >(GRADIENT_BLEND_LINEAR)));
+  rb_define_const(mFox, "GRADIENT_BLEND_POWER", SWIG_From_int(static_cast< int >(GRADIENT_BLEND_POWER)));
+  rb_define_const(mFox, "GRADIENT_BLEND_SINE", SWIG_From_int(static_cast< int >(GRADIENT_BLEND_SINE)));
+  rb_define_const(mFox, "GRADIENT_BLEND_INCREASING", SWIG_From_int(static_cast< int >(GRADIENT_BLEND_INCREASING)));
+  rb_define_const(mFox, "GRADIENT_BLEND_DECREASING", SWIG_From_int(static_cast< int >(GRADIENT_BLEND_DECREASING)));
+  
+  SwigClassFXGradient.klass = rb_define_class_under(mFox, "FXGradient", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXGradient, (void *) &SwigClassFXGradient);
+  rb_undef_alloc_func(SwigClassFXGradient.klass);
+  rb_define_method(SwigClassFXGradient.klass, "lower=", VALUEFUNC(_wrap_FXGradient_lower_set), -1);
+  rb_define_method(SwigClassFXGradient.klass, "lower", VALUEFUNC(_wrap_FXGradient_lower_get), -1);
+  rb_define_method(SwigClassFXGradient.klass, "middle=", VALUEFUNC(_wrap_FXGradient_middle_set), -1);
+  rb_define_method(SwigClassFXGradient.klass, "middle", VALUEFUNC(_wrap_FXGradient_middle_get), -1);
+  rb_define_method(SwigClassFXGradient.klass, "upper=", VALUEFUNC(_wrap_FXGradient_upper_set), -1);
+  rb_define_method(SwigClassFXGradient.klass, "upper", VALUEFUNC(_wrap_FXGradient_upper_get), -1);
+  rb_define_method(SwigClassFXGradient.klass, "lowerColor=", VALUEFUNC(_wrap_FXGradient_lowerColor_set), -1);
+  rb_define_method(SwigClassFXGradient.klass, "lowerColor", VALUEFUNC(_wrap_FXGradient_lowerColor_get), -1);
+  rb_define_method(SwigClassFXGradient.klass, "upperColor=", VALUEFUNC(_wrap_FXGradient_upperColor_set), -1);
+  rb_define_method(SwigClassFXGradient.klass, "upperColor", VALUEFUNC(_wrap_FXGradient_upperColor_get), -1);
+  rb_define_method(SwigClassFXGradient.klass, "blend=", VALUEFUNC(_wrap_FXGradient_blend_set), -1);
+  rb_define_method(SwigClassFXGradient.klass, "blend", VALUEFUNC(_wrap_FXGradient_blend_get), -1);
+  SwigClassFXGradient.mark = 0;
+  SwigClassFXGradient.trackObjects = 0;
+  
+  SwigClassFXGradientBar.klass = rb_define_class_under(mFox, "FXGradientBar", ((swig_class *) SWIGTYPE_p_FXFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXGradientBar, (void *) &SwigClassFXGradientBar);
+  rb_define_alloc_func(SwigClassFXGradientBar.klass, _wrap_FXGradientBar_allocate);
+  rb_define_method(SwigClassFXGradientBar.klass, "initialize", VALUEFUNC(_wrap_new_FXGradientBar), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onPaint", VALUEFUNC(_wrap_FXGradientBar_onPaint), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXGradientBar_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXGradientBar_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onMotion", VALUEFUNC(_wrap_FXGradientBar_onMotion), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onDNDEnter", VALUEFUNC(_wrap_FXGradientBar_onDNDEnter), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onDNDLeave", VALUEFUNC(_wrap_FXGradientBar_onDNDLeave), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onDNDMotion", VALUEFUNC(_wrap_FXGradientBar_onDNDMotion), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onDNDDrop", VALUEFUNC(_wrap_FXGradientBar_onDNDDrop), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onCmdBlending", VALUEFUNC(_wrap_FXGradientBar_onCmdBlending), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onUpdBlending", VALUEFUNC(_wrap_FXGradientBar_onUpdBlending), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onUpdSegColor", VALUEFUNC(_wrap_FXGradientBar_onUpdSegColor), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onCmdSegColor", VALUEFUNC(_wrap_FXGradientBar_onCmdSegColor), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onUpdRecenter", VALUEFUNC(_wrap_FXGradientBar_onUpdRecenter), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onCmdRecenter", VALUEFUNC(_wrap_FXGradientBar_onCmdRecenter), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onUpdSplit", VALUEFUNC(_wrap_FXGradientBar_onUpdSplit), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onCmdSplit", VALUEFUNC(_wrap_FXGradientBar_onCmdSplit), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onUpdMerge", VALUEFUNC(_wrap_FXGradientBar_onUpdMerge), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onCmdMerge", VALUEFUNC(_wrap_FXGradientBar_onCmdMerge), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onUpdUniform", VALUEFUNC(_wrap_FXGradientBar_onUpdUniform), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onCmdUniform", VALUEFUNC(_wrap_FXGradientBar_onCmdUniform), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onCmdSetHelp", VALUEFUNC(_wrap_FXGradientBar_onCmdSetHelp), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onCmdGetHelp", VALUEFUNC(_wrap_FXGradientBar_onCmdGetHelp), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onCmdSetTip", VALUEFUNC(_wrap_FXGradientBar_onCmdSetTip), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onCmdGetTip", VALUEFUNC(_wrap_FXGradientBar_onCmdGetTip), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onQueryHelp", VALUEFUNC(_wrap_FXGradientBar_onQueryHelp), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "onQueryTip", VALUEFUNC(_wrap_FXGradientBar_onQueryTip), -1);
+  rb_define_const(SwigClassFXGradientBar.klass, "ID_LOWER_COLOR", SWIG_From_int(static_cast< int >(FXGradientBar::ID_LOWER_COLOR)));
+  rb_define_const(SwigClassFXGradientBar.klass, "ID_UPPER_COLOR", SWIG_From_int(static_cast< int >(FXGradientBar::ID_UPPER_COLOR)));
+  rb_define_const(SwigClassFXGradientBar.klass, "ID_BLEND_LINEAR", SWIG_From_int(static_cast< int >(FXGradientBar::ID_BLEND_LINEAR)));
+  rb_define_const(SwigClassFXGradientBar.klass, "ID_BLEND_POWER", SWIG_From_int(static_cast< int >(FXGradientBar::ID_BLEND_POWER)));
+  rb_define_const(SwigClassFXGradientBar.klass, "ID_BLEND_SINE", SWIG_From_int(static_cast< int >(FXGradientBar::ID_BLEND_SINE)));
+  rb_define_const(SwigClassFXGradientBar.klass, "ID_BLEND_INCREASING", SWIG_From_int(static_cast< int >(FXGradientBar::ID_BLEND_INCREASING)));
+  rb_define_const(SwigClassFXGradientBar.klass, "ID_BLEND_DECREASING", SWIG_From_int(static_cast< int >(FXGradientBar::ID_BLEND_DECREASING)));
+  rb_define_const(SwigClassFXGradientBar.klass, "ID_RECENTER", SWIG_From_int(static_cast< int >(FXGradientBar::ID_RECENTER)));
+  rb_define_const(SwigClassFXGradientBar.klass, "ID_SPLIT", SWIG_From_int(static_cast< int >(FXGradientBar::ID_SPLIT)));
+  rb_define_const(SwigClassFXGradientBar.klass, "ID_MERGE", SWIG_From_int(static_cast< int >(FXGradientBar::ID_MERGE)));
+  rb_define_const(SwigClassFXGradientBar.klass, "ID_UNIFORM", SWIG_From_int(static_cast< int >(FXGradientBar::ID_UNIFORM)));
+  rb_define_const(SwigClassFXGradientBar.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXGradientBar::ID_LAST)));
+  rb_define_method(SwigClassFXGradientBar.klass, "getSegment", VALUEFUNC(_wrap_FXGradientBar_getSegment), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "getGrip", VALUEFUNC(_wrap_FXGradientBar_getGrip), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "getNumSegments", VALUEFUNC(_wrap_FXGradientBar_getNumSegments), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "setGradients", VALUEFUNC(_wrap_FXGradientBar_setGradients), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "getGradients", VALUEFUNC(_wrap_FXGradientBar_getGradients), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "setCurrentSegment", VALUEFUNC(_wrap_FXGradientBar_setCurrentSegment), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "getCurrentSegment", VALUEFUNC(_wrap_FXGradientBar_getCurrentSegment), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "setAnchorSegment", VALUEFUNC(_wrap_FXGradientBar_setAnchorSegment), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "getAnchorSegment", VALUEFUNC(_wrap_FXGradientBar_getAnchorSegment), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "selectSegments", VALUEFUNC(_wrap_FXGradientBar_selectSegments), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "deselectSegments", VALUEFUNC(_wrap_FXGradientBar_deselectSegments), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "isSegmentSelected", VALUEFUNC(_wrap_FXGradientBar_isSegmentSelected), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "setSegmentLowerColor", VALUEFUNC(_wrap_FXGradientBar_setSegmentLowerColor), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "setSegmentUpperColor", VALUEFUNC(_wrap_FXGradientBar_setSegmentUpperColor), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "getSegmentLowerColor", VALUEFUNC(_wrap_FXGradientBar_getSegmentLowerColor), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "getSegmentUpperColor", VALUEFUNC(_wrap_FXGradientBar_getSegmentUpperColor), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "moveSegmentLower", VALUEFUNC(_wrap_FXGradientBar_moveSegmentLower), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "moveSegmentMiddle", VALUEFUNC(_wrap_FXGradientBar_moveSegmentMiddle), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "moveSegmentUpper", VALUEFUNC(_wrap_FXGradientBar_moveSegmentUpper), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "moveSegments", VALUEFUNC(_wrap_FXGradientBar_moveSegments), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "getSegmentLower", VALUEFUNC(_wrap_FXGradientBar_getSegmentLower), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "getSegmentMiddle", VALUEFUNC(_wrap_FXGradientBar_getSegmentMiddle), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "getSegmentUpper", VALUEFUNC(_wrap_FXGradientBar_getSegmentUpper), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "gradient", VALUEFUNC(_wrap_FXGradientBar_gradient), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "getSegmentBlend", VALUEFUNC(_wrap_FXGradientBar_getSegmentBlend), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "splitSegments", VALUEFUNC(_wrap_FXGradientBar_splitSegments), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "mergeSegments", VALUEFUNC(_wrap_FXGradientBar_mergeSegments), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "uniformSegments", VALUEFUNC(_wrap_FXGradientBar_uniformSegments), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "blendSegments", VALUEFUNC(_wrap_FXGradientBar_blendSegments), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "getBarStyle", VALUEFUNC(_wrap_FXGradientBar_getBarStyle), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "setBarStyle", VALUEFUNC(_wrap_FXGradientBar_setBarStyle), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "setSelectColor", VALUEFUNC(_wrap_FXGradientBar_setSelectColor), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "getSelectColor", VALUEFUNC(_wrap_FXGradientBar_getSelectColor), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "setHelpText", VALUEFUNC(_wrap_FXGradientBar_setHelpText), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "getHelpText", VALUEFUNC(_wrap_FXGradientBar_getHelpText), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "setTipText", VALUEFUNC(_wrap_FXGradientBar_setTipText), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "getTipText", VALUEFUNC(_wrap_FXGradientBar_getTipText), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "save", VALUEFUNC(_wrap_FXGradientBar_save), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "load", VALUEFUNC(_wrap_FXGradientBar_load), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "create", VALUEFUNC(_wrap_FXGradientBar_create), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "detach", VALUEFUNC(_wrap_FXGradientBar_detach), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "destroy", VALUEFUNC(_wrap_FXGradientBar_destroy), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "resize", VALUEFUNC(_wrap_FXGradientBar_resize), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXGradientBar_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXGradientBar_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXGradientBar_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXGradientBar_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "canFocus", VALUEFUNC(_wrap_FXGradientBar_canFocus), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "setFocus", VALUEFUNC(_wrap_FXGradientBar_setFocus), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "killFocus", VALUEFUNC(_wrap_FXGradientBar_killFocus), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "changeFocus", VALUEFUNC(_wrap_FXGradientBar_changeFocus), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "setDefault", VALUEFUNC(_wrap_FXGradientBar_setDefault), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "enable", VALUEFUNC(_wrap_FXGradientBar_enable), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "disable", VALUEFUNC(_wrap_FXGradientBar_disable), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "raiseWindow", VALUEFUNC(_wrap_FXGradientBar_raiseWindow), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "lower", VALUEFUNC(_wrap_FXGradientBar_lower), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "move", VALUEFUNC(_wrap_FXGradientBar_move), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "position", VALUEFUNC(_wrap_FXGradientBar_position), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "layout", VALUEFUNC(_wrap_FXGradientBar_layout), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "recalc", VALUEFUNC(_wrap_FXGradientBar_recalc), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "reparent", VALUEFUNC(_wrap_FXGradientBar_reparent), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "show", VALUEFUNC(_wrap_FXGradientBar_show), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "hide", VALUEFUNC(_wrap_FXGradientBar_hide), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "isComposite", VALUEFUNC(_wrap_FXGradientBar_isComposite), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "contains", VALUEFUNC(_wrap_FXGradientBar_contains), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXGradientBar_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "setBackColor", VALUEFUNC(_wrap_FXGradientBar_setBackColor), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "tr", VALUEFUNC(_wrap_FXGradientBar_tr), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "dropEnable", VALUEFUNC(_wrap_FXGradientBar_dropEnable), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "dropDisable", VALUEFUNC(_wrap_FXGradientBar_dropDisable), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "setShape", VALUEFUNC(_wrap_FXGradientBar_setShape), -1);
+  rb_define_method(SwigClassFXGradientBar.klass, "clearShape", VALUEFUNC(_wrap_FXGradientBar_clearShape), -1);
+  SwigClassFXGradientBar.mark = (void (*)(void *)) FXRbGradientBar::markfunc;
+  SwigClassFXGradientBar.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXGradientBar.trackObjects = 0;
+}
+
diff --git a/ext/fox16_c/fx3d_wrap.cpp b/ext/fox16_c/fx3d_wrap.cpp
new file mode 100644
index 00000000..f8e413cb
--- /dev/null
+++ b/ext/fox16_c/fx3d_wrap.cpp
@@ -0,0 +1,42709 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 3.0.12
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+
+#ifndef SWIGRUBY
+#define SWIGRUBY
+#endif
+
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
+};
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic C API SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "4"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/*  Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN           0x1
+
+
+/*
+   Flags/methods for returning states.
+
+   The SWIG conversion methods, as ConvertPtr, return an integer
+   that tells if the conversion was successful or not. And if not,
+   an error code can be returned (see swigerrors.swg for the codes).
+
+   Use the following macros/flags to set or process the returning
+   states.
+
+   In old versions of SWIG, code such as the following was usually written:
+
+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+       // success code
+     } else {
+       //fail code
+     }
+
+   Now you can be more explicit:
+
+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+    } else {
+      // fail code
+    }
+
+   which is the same really, but now you can also do
+
+    Type *ptr;
+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+      if (SWIG_IsNewObj(res) {
+        ...
+	delete *ptr;
+      } else {
+        ...
+      }
+    } else {
+      // fail code
+    }
+
+   I.e., now SWIG_ConvertPtr can return new objects and you can
+   identify the case and take care of the deallocation. Of course that
+   also requires SWIG_ConvertPtr to return new result values, such as
+
+      int SWIG_ConvertPtr(obj, ptr,...) {
+        if (<obj is ok>) {
+          if (<need new object>) {
+            *ptr = <ptr to new allocated object>;
+            return SWIG_NEWOBJ;
+          } else {
+            *ptr = <ptr to old object>;
+            return SWIG_OLDOBJ;
+          }
+        } else {
+          return SWIG_BADOBJ;
+        }
+      }
+
+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+   SWIG errors code.
+
+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+   allows to return the 'cast rank', for example, if you have this
+
+       int food(double)
+       int fooi(int);
+
+   and you call
+
+      food(1)   // cast rank '1'  (1 -> 1.0)
+      fooi(1)   // cast rank '0'
+
+   just use the SWIG_AddCast()/SWIG_CheckState()
+*/
+
+#define SWIG_OK                    (0)
+#define SWIG_ERROR                 (-1)
+#define SWIG_IsOK(r)               (r >= 0)
+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT         (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ                (SWIG_ERROR)
+#define SWIG_OLDOBJ                (SWIG_OK)
+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+#  ifndef SWIG_TypeRank
+#    define SWIG_TypeRank             unsigned long
+#  endif
+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
+#    define SWIG_MAXCASTRANK          (2)
+#  endif
+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+#  define SWIG_AddCast(r) (r)
+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *, int *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store information on one type */
+typedef struct swig_type_info {
+  const char             *name;			/* mangled name of this type */
+  const char             *str;			/* human readable name of this type */
+  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
+  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
+  void                   *clientdata;		/* language specific type data */
+  int                    owndata;		/* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
+  swig_converter_func     converter;		/* function to cast the void pointers */
+  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
+  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
+  size_t                 size;		        /* Number of types in this module */
+  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
+  swig_type_info         **type_initial;	/* Array of initially generated type structures */
+  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
+  void                    *clientdata;		/* Language specific module data */
+} swig_module_info;
+
+/*
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+  }
+  return (int)((l1 - f1) - (l2 - f2));
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCmp(const char *nb, const char *tb) {
+  int equiv = 1;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (equiv != 0 && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
+}
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
+}
+
+/*
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+  swig_type_info *lastty = ty;
+  if (!ty || !ty->dcast) return ty;
+  while (ty && (ty->dcast)) {
+    ty = (*ty->dcast)(ptr);
+    if (ty) lastty = ty;
+  }
+  return lastty;
+}
+
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+  return ty->name;
+}
+
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (!type) return NULL;
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
+  }
+  else
+    return type->name;
+}
+
+/*
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+  swig_cast_info *cast = ti->cast;
+  /* if (ti->clientdata == clientdata) return; */
+  ti->clientdata = clientdata;
+
+  while (cast) {
+    if (!cast->converter) {
+      swig_type_info *tc = cast->type;
+      if (!tc->clientdata) {
+	SWIG_TypeClientData(tc, clientdata);
+      }
+    }
+    cast = cast->next;
+  }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientData(ti, clientdata);
+  ti->owndata = 1;
+}
+
+/*
+  Search for a swig_type_info structure only by mangled name
+  Search is a O(log #types)
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+                            swig_module_info *end,
+		            const char *name) {
+  swig_module_info *iter = start;
+  do {
+    if (iter->size) {
+      size_t l = 0;
+      size_t r = iter->size - 1;
+      do {
+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
+	size_t i = (l + r) >> 1;
+	const char *iname = iter->types[i]->name;
+	if (iname) {
+	  int compare = strcmp(name, iname);
+	  if (compare == 0) {
+	    return iter->types[i];
+	  } else if (compare < 0) {
+	    if (i) {
+	      r = i - 1;
+	    } else {
+	      break;
+	    }
+	  } else if (compare > 0) {
+	    l = i + 1;
+	  }
+	} else {
+	  break; /* should never happen */
+	}
+      } while (l <= r);
+    }
+    iter = iter->next;
+  } while (iter != end);
+  return 0;
+}
+
+/*
+  Search for a swig_type_info structure for either a mangled name or a human readable name.
+  It first searches the mangled names of the types, which is a O(log #types)
+  If a type is not found it then searches the human readable names, which is O(#types).
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+                     swig_module_info *end,
+		     const char *name) {
+  /* STEP 1: Search the name field using binary search */
+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+  if (ret) {
+    return ret;
+  } else {
+    /* STEP 2: If the type hasn't been found, do a complete search
+       of the str field (the human readable name) */
+    swig_module_info *iter = start;
+    do {
+      size_t i = 0;
+      for (; i < iter->size; ++i) {
+	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+	  return iter->types[i];
+      }
+      iter = iter->next;
+    } while (iter != end);
+  }
+
+  /* neither found a match */
+  return 0;
+}
+
+/*
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+
+/*
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = (unsigned char)((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = (unsigned char)((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (unsigned char)(d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (unsigned char)(d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/*
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/*  Errors in SWIG */
+#define  SWIG_UnknownError    	   -1
+#define  SWIG_IOError        	   -2
+#define  SWIG_RuntimeError   	   -3
+#define  SWIG_IndexError     	   -4
+#define  SWIG_TypeError      	   -5
+#define  SWIG_DivisionByZero 	   -6
+#define  SWIG_OverflowError  	   -7
+#define  SWIG_SyntaxError    	   -8
+#define  SWIG_ValueError     	   -9
+#define  SWIG_SystemError    	   -10
+#define  SWIG_AttributeError 	   -11
+#define  SWIG_MemoryError    	   -12
+#define  SWIG_NullReferenceError   -13
+
+
+
+      #include <ruby.h>
+
+      #if defined(RB_METHOD_DEFINITION_DECL)
+      # define RUBY_VALUE_METHOD_FUNC(func) (func)
+      # define RUBY_INT_METHOD_FUNC(func) (func)
+      # define RUBY_VOID_METHOD_FUNC(func) (func)
+      # define RUBY_VOIDP_METHOD_FUNC(func) (func)
+      #else
+      # define RUBY_VALUE_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
+      # define RUBY_INT_METHOD_FUNC(func) ((int (*)(ANYARGS))(func))
+      # define RUBY_VOID_METHOD_FUNC(func) ((void (*)(ANYARGS))(func))
+      # define RUBY_VOIDP_METHOD_FUNC(func) ((void *(*)(ANYARGS))(func))
+      #endif
+
+
+/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
+ * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
+ * issue for now by disabling this.
+ * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
+ */
+#ifdef rb_intern
+# undef rb_intern
+#endif
+
+/* Remove global macros defined in Ruby's win32.h */
+#ifdef write
+# undef write
+#endif
+#ifdef read
+# undef read
+#endif
+#ifdef bind
+# undef bind
+#endif
+#ifdef close
+# undef close
+#endif
+#ifdef connect
+# undef connect
+#endif
+
+
+/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
+#ifndef NUM2LL
+#define NUM2LL(x) NUM2LONG((x))
+#endif
+#ifndef LL2NUM
+#define LL2NUM(x) INT2NUM((long) (x))
+#endif
+#ifndef ULL2NUM
+#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
+#endif
+
+/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
+#ifndef NUM2ULL
+#ifdef HAVE_LONG_LONG
+#define NUM2ULL(x) rb_num2ull((x))
+#else
+#define NUM2ULL(x) NUM2ULONG(x)
+#endif
+#endif
+
+/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
+/* Define these for older versions so we can just write code the new way */
+#ifndef RSTRING_LEN
+# define RSTRING_LEN(x) RSTRING(x)->len
+#endif
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(x) RSTRING(x)->ptr
+#endif
+#ifndef RSTRING_END
+# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
+#endif
+#ifndef RARRAY_LEN
+# define RARRAY_LEN(x) RARRAY(x)->len
+#endif
+#ifndef RARRAY_PTR
+# define RARRAY_PTR(x) RARRAY(x)->ptr
+#endif
+#ifndef RFLOAT_VALUE
+# define RFLOAT_VALUE(x) RFLOAT(x)->value
+#endif
+#ifndef DOUBLE2NUM
+# define DOUBLE2NUM(x) rb_float_new(x)
+#endif
+#ifndef RHASH_TBL
+# define RHASH_TBL(x) (RHASH(x)->tbl)
+#endif
+#ifndef RHASH_ITER_LEV
+# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
+#endif
+#ifndef RHASH_IFNONE
+# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
+#endif
+#ifndef RHASH_SIZE
+# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
+#endif
+#ifndef RHASH_EMPTY_P
+# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
+#endif
+#ifndef RSTRUCT_LEN
+# define RSTRUCT_LEN(x) RSTRUCT(x)->len
+#endif
+#ifndef RSTRUCT_PTR
+# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
+#endif
+
+
+
+/*
+ * Need to be very careful about how these macros are defined, especially
+ * when compiling C++ code or C code with an ANSI C compiler.
+ *
+ * VALUEFUNC(f) is a macro used to typecast a C function that implements
+ * a Ruby method so that it can be passed as an argument to API functions
+ * like rb_define_method() and rb_define_singleton_method().
+ *
+ * VOIDFUNC(f) is a macro used to typecast a C function that implements
+ * either the "mark" or "free" stuff for a Ruby Data object, so that it
+ * can be passed as an argument to API functions like Data_Wrap_Struct()
+ * and Data_Make_Struct().
+ */
+ 
+#ifdef __cplusplus
+#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
+#    define PROTECTFUNC(f) ((VALUE (*)()) f)
+#    define VALUEFUNC(f) ((VALUE (*)()) f)
+#    define VOIDFUNC(f)  ((void (*)()) f)
+#  else
+#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
+#      define PROTECTFUNC(f) ((VALUE (*)()) f)
+#      define VALUEFUNC(f) ((VALUE (*)()) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    else /* These definitions should work for Ruby 1.7+ */
+#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
+#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    endif
+#  endif
+#else
+#  define VALUEFUNC(f) (f)
+#  define VOIDFUNC(f) (f)
+#endif
+
+/* Don't use for expressions have side effect */
+#ifndef RB_STRING_VALUE
+#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
+#endif
+#ifndef StringValue
+#define StringValue(s) RB_STRING_VALUE(s)
+#endif
+#ifndef StringValuePtr
+#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
+#endif
+#ifndef StringValueLen
+#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
+#endif
+#ifndef SafeStringValue
+#define SafeStringValue(v) do {\
+    StringValue(v);\
+    rb_check_safe_str(v);\
+} while (0)
+#endif
+
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
+#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
+#endif
+
+static VALUE _mSWIG = Qnil;
+
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+
+/* Define some additional error types */
+#define SWIG_ObjectPreviouslyDeletedError  -100
+
+
+/* Define custom exceptions for errors that do not map to existing Ruby
+   exceptions.  Note this only works for C++ since a global cannot be
+   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/
+
+SWIGINTERN VALUE 
+getNullReferenceError(void) {
+  static int init = 0;
+  static VALUE rb_eNullReferenceError ;
+  if (!init) {
+    init = 1;
+    rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
+  }
+  return rb_eNullReferenceError;
+} 
+
+SWIGINTERN VALUE 
+getObjectPreviouslyDeletedError(void) {
+  static int init = 0;
+  static VALUE rb_eObjectPreviouslyDeleted ;
+  if (!init) {
+    init = 1;
+    rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
+  }
+  return rb_eObjectPreviouslyDeleted;
+} 
+
+
+SWIGINTERN VALUE
+SWIG_Ruby_ErrorType(int SWIG_code) {
+  VALUE type;
+  switch (SWIG_code) {
+  case SWIG_MemoryError:
+    type = rb_eNoMemError;
+    break;
+  case SWIG_IOError:
+    type = rb_eIOError;
+    break;
+  case SWIG_RuntimeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_IndexError:
+    type = rb_eIndexError;
+    break;
+  case SWIG_TypeError:
+    type = rb_eTypeError;
+    break;
+  case SWIG_DivisionByZero:
+    type = rb_eZeroDivError;
+    break;
+  case SWIG_OverflowError:
+    type = rb_eRangeError;
+    break;
+  case SWIG_SyntaxError:
+    type = rb_eSyntaxError;
+    break;
+  case SWIG_ValueError:
+    type = rb_eArgError;
+    break;
+  case SWIG_SystemError:
+    type = rb_eFatal;
+    break;
+  case SWIG_AttributeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_NullReferenceError:
+    type = getNullReferenceError();
+    break;
+  case SWIG_ObjectPreviouslyDeletedError:
+    type = getObjectPreviouslyDeletedError();
+    break;
+  case SWIG_UnknownError:
+    type = rb_eRuntimeError;
+    break;
+  default:
+    type = rb_eRuntimeError;
+  }
+  return type;
+}
+
+
+/* This function is called when a user inputs a wrong argument to
+   a method.
+ */
+SWIGINTERN 
+const char* Ruby_Format_TypeError( const char* msg,
+				   const char* type, 
+				   const char* name, 
+				   const int argn,
+				   VALUE input )
+{
+  char buf[128];
+  VALUE str;
+  VALUE asStr;
+  if ( msg && *msg )
+    {
+      str = rb_str_new2(msg);
+    }
+  else
+    {
+      str = rb_str_new(NULL, 0);
+    }
+
+  str = rb_str_cat2( str, "Expected argument " );
+  sprintf( buf, "%d of type ", argn-1 );
+  str = rb_str_cat2( str, buf );
+  str = rb_str_cat2( str, type );
+  str = rb_str_cat2( str, ", but got " );
+  str = rb_str_cat2( str, rb_obj_classname(input) );
+  str = rb_str_cat2( str, " " );
+  asStr = rb_inspect(input);
+  if ( RSTRING_LEN(asStr) > 30 )
+    {
+      str = rb_str_cat( str, StringValuePtr(asStr), 30 );
+      str = rb_str_cat2( str, "..." );
+    }
+  else
+    {
+      str = rb_str_append( str, asStr );
+    }
+
+  if ( name )
+    {
+      str = rb_str_cat2( str, "\n\tin SWIG method '" );
+      str = rb_str_cat2( str, name );
+      str = rb_str_cat2( str, "'" );
+    }
+
+  return StringValuePtr( str );
+}
+
+/* This function is called when an overloaded method fails */
+SWIGINTERN 
+void Ruby_Format_OverloadedError(
+				 const int argc,
+				 const int maxargs,
+				 const char* method, 
+				 const char* prototypes 
+				 )
+{
+  const char* msg = "Wrong # of arguments";
+  if ( argc <= maxargs ) msg = "Wrong arguments";
+  rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
+	   "Possible C/C++ prototypes are:\n%s",
+	   msg, method, prototypes);
+}
+
+/* -----------------------------------------------------------------------------
+ * rubytracking.swg
+ *
+ * This file contains support for tracking mappings from 
+ * Ruby objects to C++ objects.  This functionality is needed
+ * to implement mark functions for Ruby's mark and sweep
+ * garbage collector.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(ST_DATA_T_DEFINED)
+/* Needs to be explicitly included for Ruby 1.8 and earlier */
+#include <st.h>
+#endif
+
+/* Ruby 1.8 actually assumes the first case. */
+#if SIZEOF_VOIDP == SIZEOF_LONG
+#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
+#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
+#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
+#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
+#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
+#else
+#  error sizeof(void*) is not the same as long or long long
+#endif
+
+/* Global hash table to store Trackings from C/C++
+   structs to Ruby Objects. 
+*/
+static st_table* swig_ruby_trackings = NULL;
+
+static VALUE swig_ruby_trackings_count(ID id, VALUE *var) {
+  return SWIG2NUM(swig_ruby_trackings->num_entries);
+}
+
+
+/* Setup a hash table to store Trackings */
+SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
+  /* Create a hash table to store Trackings from C++
+     objects to Ruby objects. */
+
+  /* Try to see if some other .so has already created a 
+     tracking hash table, which we keep hidden in an instance var
+     in the SWIG module.
+     This is done to allow multiple DSOs to share the same
+     tracking table.
+  */
+  VALUE trackings_value = Qnil;
+  /* change the variable name so that we can mix modules
+     compiled with older SWIG's - this used to be called "@__trackings__" */
+  ID trackings_id = rb_intern( "@__safetrackings__" );
+  VALUE verbose = rb_gv_get("VERBOSE");
+  rb_gv_set("VERBOSE", Qfalse);
+  trackings_value = rb_ivar_get( _mSWIG, trackings_id );
+  rb_gv_set("VERBOSE", verbose);
+
+  /* The trick here is that we have to store the hash table
+  pointer in a Ruby variable. We do not want Ruby's GC to
+  treat this pointer as a Ruby object, so we convert it to
+  a Ruby numeric value. */
+  if (trackings_value == Qnil) {
+    /* No, it hasn't.  Create one ourselves */
+    swig_ruby_trackings = st_init_numtable();
+    rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
+  } else {
+    swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
+  }
+
+        rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", RUBY_VALUE_METHOD_FUNC(swig_ruby_trackings_count), RUBY_VOID_METHOD_FUNC((rb_gvar_setter_t*)NULL))
+;
+}
+
+/* Add a Tracking from a C/C++ struct to a Ruby object */
+SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
+  /* Store the mapping to the global hash table. */
+  st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
+}
+
+/* Get the Ruby object that owns the specified C/C++ struct */
+SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
+  /* Now lookup the value stored in the global hash table */
+  VALUE value;
+
+  if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
+    return value;
+  } else {
+    return Qnil;
+  }
+}
+
+/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
+   is very important to remove objects once they are destroyed
+   since the same memory address may be reused later to create
+   a new object. */
+SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
+  /* Delete the object from the hash table */
+  st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
+}
+
+/* This is a helper method that unlinks a Ruby object from its
+   underlying C++ object.  This is needed if the lifetime of the
+   Ruby object is longer than the C++ object */
+SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
+  VALUE object = SWIG_RubyInstanceFor(ptr);
+
+  if (object != Qnil) {
+    if (TYPE(object) != T_DATA)
+      abort();
+    DATA_PTR(object) = 0;
+  }
+}
+
+/* This is a helper method that iterates over all the trackings
+   passing the C++ object pointer and its related Ruby object
+   to the passed callback function. */
+
+/* Proxy method to abstract the internal trackings datatype */
+      static int swig_ruby_internal_iterate_callback(st_data_t ptr, st_data_t obj, st_data_t meth) {
+        ((void(*)(void*, VALUE))meth)((void*)ptr, (VALUE)obj);
+
+  return ST_CONTINUE;
+}
+
+SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
+  st_foreach(swig_ruby_trackings, RUBY_INT_METHOD_FUNC(swig_ruby_internal_iterate_callback), (st_data_t)meth);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Ruby API portion that goes into the runtime
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGINTERN VALUE
+SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
+  if (NIL_P(target)) {
+    target = o;
+  } else {
+    if (TYPE(target) != T_ARRAY) {
+      VALUE o2 = target;
+      target = rb_ary_new();
+      rb_ary_push(target, o2);
+    }
+    rb_ary_push(target, o);
+  }
+  return target;
+}
+
+/* For ruby1.8.4 and earlier. */
+#ifndef RUBY_INIT_STACK
+   RUBY_EXTERN void Init_stack(VALUE* addr);
+#  define RUBY_INIT_STACK \
+   VALUE variable_in_this_stack_frame; \
+   Init_stack(&variable_in_this_stack_frame);
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* -----------------------------------------------------------------------------
+ * rubyrun.swg
+ *
+ * This file contains the runtime support for Ruby modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
+#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
+#define swig_owntype                                    swig_ruby_owntype
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) 		SWIG_Ruby_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
+#define SWIG_Error(code, msg)            		rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
+#define SWIG_fail                        		goto fail				 
+
+
+/* Ruby-specific SWIG API */
+
+#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
+#define SWIG_define_class(ty)                        	SWIG_Ruby_define_class(ty)
+#define SWIG_NewClassInstance(value, ty)             	SWIG_Ruby_NewClassInstance(value, ty)
+#define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
+#define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  
+
+#include "assert.h"
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  VALUE klass;
+  VALUE mImpl;
+  void  (*mark)(void *);
+  void  (*destroy)(void *);
+  int trackObjects;
+} swig_class;
+
+
+/* Global pointer used to keep some internal SWIG stuff */
+static VALUE _cSWIG_Pointer = Qnil;
+static VALUE swig_runtime_data_type_pointer = Qnil;
+
+/* Global IDs used to keep some internal SWIG stuff */
+static ID swig_arity_id = 0;
+static ID swig_call_id  = 0;
+
+/*
+  If your swig extension is to be run within an embedded ruby and has
+  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
+  This will reset ruby's stack frame on each entry point from the main 
+  program the first time a virtual director function is invoked (in a 
+  non-recursive way).
+  If this is not done, you run the risk of Ruby trashing the stack.
+*/
+
+#ifdef RUBY_EMBEDDED
+
+#  define SWIG_INIT_STACK                            \
+      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
+      ++swig_virtual_calls;
+#  define SWIG_RELEASE_STACK --swig_virtual_calls;
+#  define Ruby_DirectorTypeMismatchException(x) \
+          rb_raise( rb_eTypeError, "%s", x ); return c_result;
+
+      static unsigned int swig_virtual_calls = 0;
+
+#else  /* normal non-embedded extension */
+
+#  define SWIG_INIT_STACK
+#  define SWIG_RELEASE_STACK
+#  define Ruby_DirectorTypeMismatchException(x) \
+          throw Swig::DirectorTypeMismatchException( x );
+
+#endif  /* RUBY_EMBEDDED */
+
+
+SWIGRUNTIME VALUE 
+getExceptionClass(void) {
+  static int init = 0;
+  static VALUE rubyExceptionClass ;
+  if (!init) {
+    init = 1;
+    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
+  }
+  return rubyExceptionClass;
+} 
+
+/* This code checks to see if the Ruby object being raised as part
+   of an exception inherits from the Ruby class Exception.  If so,
+   the object is simply returned.  If not, then a new Ruby exception
+   object is created and that will be returned to Ruby.*/
+SWIGRUNTIME VALUE
+SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
+  VALUE exceptionClass = getExceptionClass();
+  if (rb_obj_is_kind_of(obj, exceptionClass)) {
+    return obj;
+  }  else {
+    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
+  }
+}
+
+/* Initialize Ruby runtime support */
+SWIGRUNTIME void
+SWIG_Ruby_InitRuntime(void)
+{
+  if (_mSWIG == Qnil) {
+    _mSWIG = rb_define_module("SWIG");
+    swig_call_id  = rb_intern("call");
+    swig_arity_id = rb_intern("arity");
+  }
+}
+
+/* Define Ruby class for C type */
+SWIGRUNTIME void
+SWIG_Ruby_define_class(swig_type_info *type)
+{
+  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+  sprintf(klass_name, "TYPE%s", type->name);
+  if (NIL_P(_cSWIG_Pointer)) {
+    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
+    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
+  }
+  rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
+  free((void *) klass_name);
+}
+
+/* Create a new pointer object */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
+{
+  int own =  flags & SWIG_POINTER_OWN; 
+  int track;
+  char *klass_name;
+  swig_class *sklass;
+  VALUE klass;
+  VALUE obj;
+  
+  if (!ptr)
+    return Qnil;
+  
+  if (type->clientdata) {
+    sklass = (swig_class *) type->clientdata;
+		
+    /* Are we tracking this class and have we already returned this Ruby object? */
+    track = sklass->trackObjects;
+    if (track) {
+      obj = SWIG_RubyInstanceFor(ptr);
+      
+      /* Check the object's type and make sure it has the correct type.
+        It might not in cases where methods do things like 
+        downcast methods. */
+      if (obj != Qnil) {
+        VALUE value = rb_iv_get(obj, "@__swigtype__");
+        const char* type_name = RSTRING_PTR(value);
+				
+        if (strcmp(type->name, type_name) == 0) {
+          return obj;
+        }
+      }
+    }
+
+    /* Create a new Ruby object */
+    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
+			   ( own ? VOIDFUNC(sklass->destroy) : 
+			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
+			     ), ptr);
+
+    /* If tracking is on for this class then track this object. */
+    if (track) {
+      SWIG_RubyAddTracking(ptr, obj);
+    }
+  } else {
+    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+    sprintf(klass_name, "TYPE%s", type->name);
+    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
+    free((void *) klass_name);
+    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
+  }
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  
+  return obj;
+}
+
+/* Create a new class instance (always owned) */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
+{
+  VALUE obj;
+  swig_class *sklass = (swig_class *) type->clientdata;
+  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  return obj;
+}
+
+/* Get type mangle from class name */
+SWIGRUNTIMEINLINE char *
+SWIG_Ruby_MangleStr(VALUE obj)
+{
+  VALUE stype = rb_iv_get(obj, "@__swigtype__");
+  return StringValuePtr(stype);
+}
+
+/* Acquire a pointer value */
+typedef struct {
+  void (*datafree)(void *);
+  int own;
+} swig_ruby_owntype;
+
+SWIGRUNTIME swig_ruby_owntype
+SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
+  swig_ruby_owntype oldown = {0, 0};
+  if (obj) {
+    oldown.datafree = RDATA(obj)->dfree;
+    RDATA(obj)->dfree = own.datafree;
+  }
+  return oldown;
+}
+
+/* Convert a pointer value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
+{
+  char *c;
+  swig_cast_info *tc;
+  void *vptr = 0;
+
+  /* Grab the pointer */
+  if (NIL_P(obj)) {
+    if (ptr)
+      *ptr = 0;
+    return SWIG_OK;
+  } else {
+    if (TYPE(obj) != T_DATA) {
+      return SWIG_ERROR;
+    }
+    Data_Get_Struct(obj, void, vptr);
+  }
+  
+  if (own) {
+    own->datafree = RDATA(obj)->dfree;
+    own->own = 0;
+  }
+    
+  /* Check to see if the input object is giving up ownership
+     of the underlying C struct or C++ object.  If so then we
+     need to reset the destructor since the Ruby object no 
+     longer owns the underlying C++ object.*/ 
+  if (flags & SWIG_POINTER_DISOWN) {
+    /* Is tracking on for this class? */
+    int track = 0;
+    if (ty && ty->clientdata) {
+      swig_class *sklass = (swig_class *) ty->clientdata;
+      track = sklass->trackObjects;
+    }
+		
+    if (track) {
+      /* We are tracking objects for this class.  Thus we change the destructor
+       * to SWIG_RubyRemoveTracking.  This allows us to
+       * remove the mapping from the C++ to Ruby object
+       * when the Ruby object is garbage collected.  If we don't
+       * do this, then it is possible we will return a reference 
+       * to a Ruby object that no longer exists thereby crashing Ruby. */
+      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
+    } else {    
+      RDATA(obj)->dfree = 0;
+    }
+  }
+
+  /* Do type-checking if type info was provided */
+  if (ty) {
+    if (ty->clientdata) {
+      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
+        if (vptr == 0) {
+          /* The object has already been deleted */
+          return SWIG_ObjectPreviouslyDeletedError;
+        }
+      }
+    }
+    if ((c = SWIG_MangleStr(obj)) == NULL) {
+      return SWIG_ERROR;
+    }
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) {
+      return SWIG_ERROR;
+    } else {
+      if (ptr) {
+        if (tc->type == ty) {
+          *ptr = vptr;
+        } else {
+          int newmemory = 0;
+          *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
+          if (newmemory == SWIG_CAST_NEW_MEMORY) {
+            assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+            if (own)
+              own->own = own->own | SWIG_CAST_NEW_MEMORY;
+          }
+        }
+      }
+    }
+  } else {
+    if (ptr)
+      *ptr = vptr;
+  }
+  
+  return SWIG_OK;
+}
+
+/* Check convert */
+SWIGRUNTIMEINLINE int
+SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
+{
+  char *c = SWIG_MangleStr(obj);
+  if (!c) return 0;
+  return SWIG_TypeCheck(c,ty) != 0;
+}
+
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r, ptr, sz);
+  strcpy(r, type->name);
+  return rb_str_new2(result);
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c;
+
+  if (TYPE(obj) != T_STRING) goto type_error;
+  c = StringValuePtr(obj);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') goto type_error;
+  c++;
+  c = SWIG_UnpackData(c, ptr, sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) goto type_error;
+  }
+  return SWIG_OK;
+
+ type_error:
+  return SWIG_ERROR;
+}
+
+SWIGRUNTIME swig_module_info *
+SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
+{
+  VALUE pointer;
+  swig_module_info *ret = 0;
+  VALUE verbose = rb_gv_get("VERBOSE");
+
+ /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
+  rb_gv_set("VERBOSE", Qfalse);
+  
+  /* first check if pointer already created */
+  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  if (pointer != Qnil) {
+    Data_Get_Struct(pointer, swig_module_info, ret);
+  }
+
+  /* reinstate warnings */
+  rb_gv_set("VERBOSE", verbose);
+  return ret;
+}
+
+SWIGRUNTIME void 
+SWIG_Ruby_SetModule(swig_module_info *pointer)
+{
+  /* register a new class */
+  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
+  /* create and store the structure pointer to a global variable */
+  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
+  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
+}
+
+/* This function can be used to check whether a proc or method or similarly
+   callable function has been passed.  Usually used in a %typecheck, like:
+
+   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
+        $result = SWIG_Ruby_isCallable( $input );
+   }
+ */
+SWIGINTERN
+int SWIG_Ruby_isCallable( VALUE proc )
+{
+  if ( rb_respond_to( proc, swig_call_id ) )
+    return 1;
+  return 0;
+}
+
+/* This function can be used to check the arity (number of arguments)
+   a proc or method can take.  Usually used in a %typecheck.
+   Valid arities will be that equal to minimal or those < 0
+   which indicate a variable number of parameters at the end.
+ */
+SWIGINTERN
+int SWIG_Ruby_arity( VALUE proc, int minimal )
+{
+  if ( rb_respond_to( proc, swig_arity_id ) )
+    {
+      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
+      int arity = NUM2INT(num);
+      if ( arity < 0 && (arity+1) < -minimal ) return 1;
+      if ( arity == minimal ) return 1;
+      return 1;
+    }
+  return 0;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
+
+
+
+  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) 
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_p_FX4Splitter swig_types[0]
+#define SWIGTYPE_p_FX7Segment swig_types[1]
+#define SWIGTYPE_p_FXAccelTable swig_types[2]
+#define SWIGTYPE_p_FXApp swig_types[3]
+#define SWIGTYPE_p_FXArrowButton swig_types[4]
+#define SWIGTYPE_p_FXBitmap swig_types[5]
+#define SWIGTYPE_p_FXBitmapFrame swig_types[6]
+#define SWIGTYPE_p_FXCURCursor swig_types[7]
+#define SWIGTYPE_p_FXCanvas swig_types[8]
+#define SWIGTYPE_p_FXColorBar swig_types[9]
+#define SWIGTYPE_p_FXColorRing swig_types[10]
+#define SWIGTYPE_p_FXColorSelector swig_types[11]
+#define SWIGTYPE_p_FXColorWell swig_types[12]
+#define SWIGTYPE_p_FXColorWheel swig_types[13]
+#define SWIGTYPE_p_FXComboBox swig_types[14]
+#define SWIGTYPE_p_FXComposite swig_types[15]
+#define SWIGTYPE_p_FXCursor swig_types[16]
+#define SWIGTYPE_p_FXDataTarget swig_types[17]
+#define SWIGTYPE_p_FXDebugTarget swig_types[18]
+#define SWIGTYPE_p_FXDelegator swig_types[19]
+#define SWIGTYPE_p_FXDial swig_types[20]
+#define SWIGTYPE_p_FXDict swig_types[21]
+#define SWIGTYPE_p_FXDirBox swig_types[22]
+#define SWIGTYPE_p_FXDirSelector swig_types[23]
+#define SWIGTYPE_p_FXDockBar swig_types[24]
+#define SWIGTYPE_p_FXDockHandler swig_types[25]
+#define SWIGTYPE_p_FXDockSite swig_types[26]
+#define SWIGTYPE_p_FXDockTitle swig_types[27]
+#define SWIGTYPE_p_FXDocument swig_types[28]
+#define SWIGTYPE_p_FXDragCorner swig_types[29]
+#define SWIGTYPE_p_FXDrawable swig_types[30]
+#define SWIGTYPE_p_FXDriveBox swig_types[31]
+#define SWIGTYPE_p_FXExtentd swig_types[32]
+#define SWIGTYPE_p_FXExtentf swig_types[33]
+#define SWIGTYPE_p_FXFileDict swig_types[34]
+#define SWIGTYPE_p_FXFileSelector swig_types[35]
+#define SWIGTYPE_p_FXFileStream swig_types[36]
+#define SWIGTYPE_p_FXFont swig_types[37]
+#define SWIGTYPE_p_FXFontSelector swig_types[38]
+#define SWIGTYPE_p_FXFrame swig_types[39]
+#define SWIGTYPE_p_FXGIFCursor swig_types[40]
+#define SWIGTYPE_p_FXGLCanvas swig_types[41]
+#define SWIGTYPE_p_FXGLContext swig_types[42]
+#define SWIGTYPE_p_FXGLObject swig_types[43]
+#define SWIGTYPE_p_FXGLShape swig_types[44]
+#define SWIGTYPE_p_FXGLViewer swig_types[45]
+#define SWIGTYPE_p_FXGLVisual swig_types[46]
+#define SWIGTYPE_p_FXGradientBar swig_types[47]
+#define SWIGTYPE_p_FXGroupBox swig_types[48]
+#define SWIGTYPE_p_FXHeader swig_types[49]
+#define SWIGTYPE_p_FXHeaderItem swig_types[50]
+#define SWIGTYPE_p_FXHorizontalFrame swig_types[51]
+#define SWIGTYPE_p_FXHorizontalSeparator swig_types[52]
+#define SWIGTYPE_p_FXIcon swig_types[53]
+#define SWIGTYPE_p_FXIconDict swig_types[54]
+#define SWIGTYPE_p_FXId swig_types[55]
+#define SWIGTYPE_p_FXImageFrame swig_types[56]
+#define SWIGTYPE_p_FXImageView swig_types[57]
+#define SWIGTYPE_p_FXKnob swig_types[58]
+#define SWIGTYPE_p_FXLight swig_types[59]
+#define SWIGTYPE_p_FXListBox swig_types[60]
+#define SWIGTYPE_p_FXMainWindow swig_types[61]
+#define SWIGTYPE_p_FXMat3d swig_types[62]
+#define SWIGTYPE_p_FXMat3f swig_types[63]
+#define SWIGTYPE_p_FXMat4d swig_types[64]
+#define SWIGTYPE_p_FXMat4f swig_types[65]
+#define SWIGTYPE_p_FXMaterial swig_types[66]
+#define SWIGTYPE_p_FXMatrix swig_types[67]
+#define SWIGTYPE_p_FXMemoryStream swig_types[68]
+#define SWIGTYPE_p_FXObject swig_types[69]
+#define SWIGTYPE_p_FXPacker swig_types[70]
+#define SWIGTYPE_p_FXPopup swig_types[71]
+#define SWIGTYPE_p_FXProgressBar swig_types[72]
+#define SWIGTYPE_p_FXQuatd swig_types[73]
+#define SWIGTYPE_p_FXQuatf swig_types[74]
+#define SWIGTYPE_p_FXRanged swig_types[75]
+#define SWIGTYPE_p_FXRangef swig_types[76]
+#define SWIGTYPE_p_FXRealSlider swig_types[77]
+#define SWIGTYPE_p_FXRealSpinner swig_types[78]
+#define SWIGTYPE_p_FXRecentFiles swig_types[79]
+#define SWIGTYPE_p_FXRegion swig_types[80]
+#define SWIGTYPE_p_FXRegistry swig_types[81]
+#define SWIGTYPE_p_FXRootWindow swig_types[82]
+#define SWIGTYPE_p_FXRuler swig_types[83]
+#define SWIGTYPE_p_FXRulerView swig_types[84]
+#define SWIGTYPE_p_FXScrollArea swig_types[85]
+#define SWIGTYPE_p_FXScrollBar swig_types[86]
+#define SWIGTYPE_p_FXScrollCorner swig_types[87]
+#define SWIGTYPE_p_FXScrollWindow swig_types[88]
+#define SWIGTYPE_p_FXSeparator swig_types[89]
+#define SWIGTYPE_p_FXSettings swig_types[90]
+#define SWIGTYPE_p_FXShell swig_types[91]
+#define SWIGTYPE_p_FXShutter swig_types[92]
+#define SWIGTYPE_p_FXShutterItem swig_types[93]
+#define SWIGTYPE_p_FXSlider swig_types[94]
+#define SWIGTYPE_p_FXSphered swig_types[95]
+#define SWIGTYPE_p_FXSpheref swig_types[96]
+#define SWIGTYPE_p_FXSpinner swig_types[97]
+#define SWIGTYPE_p_FXSplashWindow swig_types[98]
+#define SWIGTYPE_p_FXSplitter swig_types[99]
+#define SWIGTYPE_p_FXSpring swig_types[100]
+#define SWIGTYPE_p_FXStatusBar swig_types[101]
+#define SWIGTYPE_p_FXStatusLine swig_types[102]
+#define SWIGTYPE_p_FXStream swig_types[103]
+#define SWIGTYPE_p_FXStringDict swig_types[104]
+#define SWIGTYPE_p_FXSwitcher swig_types[105]
+#define SWIGTYPE_p_FXTabBar swig_types[106]
+#define SWIGTYPE_p_FXTabBook swig_types[107]
+#define SWIGTYPE_p_FXTextField swig_types[108]
+#define SWIGTYPE_p_FXToolBar swig_types[109]
+#define SWIGTYPE_p_FXToolBarGrip swig_types[110]
+#define SWIGTYPE_p_FXToolBarShell swig_types[111]
+#define SWIGTYPE_p_FXToolBarTab swig_types[112]
+#define SWIGTYPE_p_FXToolTip swig_types[113]
+#define SWIGTYPE_p_FXTopWindow swig_types[114]
+#define SWIGTYPE_p_FXTranslator swig_types[115]
+#define SWIGTYPE_p_FXTreeListBox swig_types[116]
+#define SWIGTYPE_p_FXVec2d swig_types[117]
+#define SWIGTYPE_p_FXVec2f swig_types[118]
+#define SWIGTYPE_p_FXVec3d swig_types[119]
+#define SWIGTYPE_p_FXVec3f swig_types[120]
+#define SWIGTYPE_p_FXVec4d swig_types[121]
+#define SWIGTYPE_p_FXVec4f swig_types[122]
+#define SWIGTYPE_p_FXVerticalFrame swig_types[123]
+#define SWIGTYPE_p_FXVerticalSeparator swig_types[124]
+#define SWIGTYPE_p_FXViewport swig_types[125]
+#define SWIGTYPE_p_FXVisual swig_types[126]
+#define SWIGTYPE_p_FXWindow swig_types[127]
+#define SWIGTYPE_p_char swig_types[128]
+#define SWIGTYPE_p_double swig_types[129]
+#define SWIGTYPE_p_float swig_types[130]
+#define SWIGTYPE_p_int swig_types[131]
+#define SWIGTYPE_p_long swig_types[132]
+#define SWIGTYPE_p_short swig_types[133]
+#define SWIGTYPE_p_unsigned_char swig_types[134]
+#define SWIGTYPE_p_unsigned_int swig_types[135]
+#define SWIGTYPE_p_unsigned_long swig_types[136]
+#define SWIGTYPE_p_unsigned_short swig_types[137]
+static swig_type_info *swig_types[139];
+static swig_module_info swig_module = {swig_types, 138, 0, 0, 0, 0};
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
+
+/* -------- TYPES TABLE (END) -------- */
+
+#define SWIG_init    Init_fx3d
+#define SWIG_name    "Fx3d"
+
+
+
+#define SWIG_RUBY_THREAD_BEGIN_BLOCK
+#define SWIG_RUBY_THREAD_END_BLOCK
+
+
+#define SWIGVERSION 0x030012 
+#define SWIG_VERSION SWIGVERSION
+
+
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
+
+
+#include <stdexcept>
+
+
+#include "FXRbCommon.h"
+
+
+inline FXColor to_FXColor(VALUE obj){
+  if(TYPE(obj)==T_STRING){
+    return fxcolorfromname(StringValuePtr(obj));
+    }
+  else if(TYPE(obj)==T_SYMBOL){
+    return fxcolorfromname(rb_id2name(SYM2ID(obj)));
+    }
+  else{
+    return NUM2ULONG(obj);
+    }
+  }
+
+
+inline FXString to_FXString(VALUE obj){
+  if(!NIL_P(obj)){
+    Check_Type(obj,T_STRING);
+    return FXString(StringValuePtr(obj));
+    }
+  else{
+    return FXString::null;
+    }
+  }
+
+
+inline FXbool to_FXbool(VALUE obj){
+  if (obj == Qtrue || obj == Qfalse){
+    return (obj == Qtrue) ? TRUE : FALSE;
+    }
+  else{
+    return static_cast<FXbool>(NUM2UINT(obj));
+    }
+  }
+
+
+static swig_type_info* FXEventTypeInfo=0;
+
+inline void* to_FXEvent(VALUE obj){
+  void* ptr;
+  if(!FXEventTypeInfo){
+    FXEventTypeInfo=SWIG_TypeQuery("FXEvent *");
+    FXASSERT(FXEventTypeInfo!=0);
+    }
+  SWIG_ConvertPtr(obj,&ptr,FXEventTypeInfo,1);
+  return ptr;
+  }
+
+
+#include <float.h>
+
+
+#include <math.h>
+
+
+/* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */
+#ifndef SWIG_isfinite
+/* isfinite() is a macro for C99 */
+# if defined(isfinite)
+#  define SWIG_isfinite(X) (isfinite(X))
+# elif defined __cplusplus && __cplusplus >= 201103L
+/* Use a template so that this works whether isfinite() is std::isfinite() or
+ * in the global namespace.  The reality seems to vary between compiler
+ * versions.
+ *
+ * Make sure namespace std exists to avoid compiler warnings.
+ *
+ * extern "C++" is required as this fragment can end up inside an extern "C" { } block
+ */
+namespace std { }
+extern "C++" template<typename T>
+inline int SWIG_isfinite_func(T x) {
+  using namespace std;
+  return isfinite(x);
+}
+#  define SWIG_isfinite(X) (SWIG_isfinite_func(X))
+# elif defined(_MSC_VER)
+#  define SWIG_isfinite(X) (_finite(X))
+# elif defined(__sun) && defined(__SVR4)
+#  include <ieeefp.h>
+#  define SWIG_isfinite(X) (finite(X))
+# endif
+#endif
+
+
+/* Accept infinite as a valid float value unless we are unable to check if a value is finite */
+#ifdef SWIG_isfinite
+# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX) && SWIG_isfinite(X))
+#else
+# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX))
+#endif
+
+
+SWIGINTERN VALUE
+SWIG_ruby_failed(VALUE, VALUE)
+{
+  return Qnil;
+} 
+
+
+/*@SWIG:/usr/share/swig3.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE pargs){VALUE *args=(VALUE *)pargs;
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  double *res = (double *)(args[1]);
+  *res = NUM2DBL(obj); (void)type;
+  return obj;
+}
+/*@SWIG@*/
+
+SWIGINTERN int
+SWIG_AsVal_double (VALUE obj, double *val)
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FLOAT) || (type == T_FIXNUM) || (type == T_BIGNUM)) {
+    double v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_VALUE_METHOD_FUNC(SWIG_AUX_NUM2DBL), (VALUE)a, RUBY_VALUE_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_float (VALUE obj, float *val)
+{
+  double v;
+  int res = SWIG_AsVal_double (obj, &v);
+  if (SWIG_IsOK(res)) {
+    if (SWIG_Float_Overflow_Check(v)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = static_cast< float >(v);
+    }
+  }  
+  return res;
+}
+
+
+  #define SWIG_From_double   rb_float_new 
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_float  (float value)
+{    
+  return SWIG_From_double  (value);
+}
+
+SWIGINTERN FXfloat FXVec2f___getitem__(FXVec2f const *self,FXint i){
+      if(i<0||i>1) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      return (*self)[i];
+      }
+SWIGINTERN FXfloat FXVec2f___setitem__(FXVec2f *self,FXint i,FXfloat f){
+      if(i<0||i>1) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      (*self)[i]=f;
+      return f;
+      }
+SWIGINTERN FXVec2f FXVec2f_operator_Ss_(FXVec2f const *self){ return -(*self); }
+SWIGINTERN FXVec2f FXVec2f_operator_Sa_(FXVec2f const *self,FXVec2f const &other){ return (*self)+other; }
+SWIGINTERN FXVec2f FXVec2f_operator_Ss_(FXVec2f const *self,FXVec2f const &other){ return (*self)-other; }
+SWIGINTERN FXVec2f FXVec2f_operator_Sm___SWIG_0(FXVec2f const *self,FXfloat n){ return (*self)*n; }
+SWIGINTERN FXVec2f FXVec2f_operator_Sd_(FXVec2f const *self,FXfloat n){
+      if(n==0.0f) rb_raise(rb_eZeroDivError,"divided by 0");
+      return (*self)/n;
+      }
+SWIGINTERN FXfloat FXVec2f_operator_Sm___SWIG_1(FXVec2f const *self,FXVec2f const &other){ return (*self)*other; }
+SWIGINTERN FXfloat FXVec2f_dot(FXVec2f const *self,FXVec2f const &other){ return (*self)*other; }
+SWIGINTERN bool FXVec2f_operator_Se__Se_(FXVec2f const *self,FXVec2f const &other){ return (*self)==other; }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_bool  (bool value)
+{
+  return value ? Qtrue : Qfalse;
+}
+
+SWIGINTERN FXVec2f FXVec2f_normalize(FXVec2f const *self){ return normalize(*self); }
+SWIGINTERN FXVec2f FXVec2f_lo(FXVec2f const *self,FXVec2f const &other){ return lo(*self,other); }
+SWIGINTERN FXVec2f FXVec2f_hi(FXVec2f const *self,FXVec2f const &other){ return hi(*self,other); }
+SWIGINTERN FXdouble FXVec2d___getitem__(FXVec2d const *self,FXint i){
+      if(i<0||i>1) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      return (*self)[i];
+      }
+SWIGINTERN FXdouble FXVec2d___setitem__(FXVec2d *self,FXint i,FXdouble d){
+      if(i<0||i>1) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      (*self)[i]=d;
+      return d;
+      }
+SWIGINTERN FXVec2d FXVec2d_operator_Ss_(FXVec2d const *self){ return -(*self); }
+SWIGINTERN FXVec2d FXVec2d_operator_Sa_(FXVec2d const *self,FXVec2d const &other){ return (*self)+other; }
+SWIGINTERN FXVec2d FXVec2d_operator_Ss_(FXVec2d const *self,FXVec2d const &other){ return (*self)-other; }
+SWIGINTERN FXVec2d FXVec2d_operator_Sm___SWIG_0(FXVec2d const *self,FXdouble n){ return (*self)*n; }
+SWIGINTERN FXVec2d FXVec2d_operator_Sd_(FXVec2d const *self,FXdouble n){
+      if(n==0.0) rb_raise(rb_eZeroDivError,"divided by 0");
+      return (*self)/n;
+      }
+SWIGINTERN FXdouble FXVec2d_operator_Sm___SWIG_1(FXVec2d const *self,FXVec2d const &other){ return (*self)*other; }
+SWIGINTERN FXdouble FXVec2d_dot(FXVec2d const *self,FXVec2d const &other){ return (*self)*other; }
+SWIGINTERN bool FXVec2d_operator_Se__Se_(FXVec2d const *self,FXVec2d const &other){ return (*self)==other; }
+SWIGINTERN FXVec2d FXVec2d_normalize(FXVec2d const *self){ return normalize(*self); }
+SWIGINTERN FXVec2d FXVec2d_lo(FXVec2d const *self,FXVec2d const &other){ return lo(*self,other); }
+SWIGINTERN FXVec2d FXVec2d_hi(FXVec2d const *self,FXVec2d const &other){ return hi(*self,other); }
+SWIGINTERN FXVec3f *new_FXVec3f__SWIG_0(){
+			return new FXVec3f(0.0f, 0.0f, 0.0f);
+		}
+SWIGINTERN FXfloat FXVec3f___getitem__(FXVec3f const *self,FXint i){
+      if(i<0||i>2) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      return (*self)[i];
+      }
+SWIGINTERN FXfloat FXVec3f___setitem__(FXVec3f *self,FXint i,FXfloat f){
+      if(i<0||i>2) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      (*self)[i]=f;
+      return f;
+      }
+SWIGINTERN FXVec3f FXVec3f_operator_Ss_(FXVec3f const *self){ return -(*self); }
+SWIGINTERN FXVec3f FXVec3f_operator_Sa_(FXVec3f const *self,FXVec3f const &other){ return (*self)+other; }
+SWIGINTERN FXVec3f FXVec3f_operator_Ss_(FXVec3f const *self,FXVec3f const &other){ return (*self)-other; }
+SWIGINTERN FXVec3f FXVec3f_operator_Sm___SWIG_0(FXVec3f const *self,FXfloat n){ return (*self)*n; }
+SWIGINTERN FXVec3f FXVec3f_operator_Sd_(FXVec3f const *self,FXfloat n){
+      if(n==0.0f) rb_raise(rb_eZeroDivError,"divided by 0");
+      return (*self)/n;
+      }
+SWIGINTERN FXfloat FXVec3f_operator_Sm___SWIG_1(FXVec3f const *self,FXVec3f const &other){ return (*self)*other; }
+SWIGINTERN FXfloat FXVec3f_dot(FXVec3f const *self,FXVec3f const &other){ return (*self)*other; }
+SWIGINTERN FXVec3f FXVec3f_operator_Sx_(FXVec3f const *self,FXVec3f const &other){ return (*self)^other; }
+SWIGINTERN FXVec3f FXVec3f_cross(FXVec3f const *self,FXVec3f const &other){ return (*self)^other; }
+SWIGINTERN bool FXVec3f_operator_Se__Se_(FXVec3f const *self,FXVec3f const &other){ return (*self)==other; }
+SWIGINTERN FXVec3f FXVec3f_normalize(FXVec3f const *self){ return normalize(*self); }
+SWIGINTERN FXVec3f FXVec3f_lo(FXVec3f const *self,FXVec3f const &other){ return lo(*self,other); }
+SWIGINTERN FXVec3f FXVec3f_hi(FXVec3f const *self,FXVec3f const &other){ return hi(*self,other); }
+SWIGINTERN FXVec3f FXVec3f_normal__SWIG_0(FXVec3f const &a,FXVec3f const &b,FXVec3f const &c){
+      return FX::normal(a,b,c);
+      }
+SWIGINTERN FXVec3f FXVec3f_normal__SWIG_1(FXVec3f const &a,FXVec3f const &b,FXVec3f const &c,FXVec3f const &d){
+      return FX::normal(a,b,c,d);
+      }
+SWIGINTERN FXVec3d *new_FXVec3d__SWIG_0(){
+			return new FXVec3d(0.0, 0.0, 0.0);
+		}
+SWIGINTERN FXdouble FXVec3d___getitem__(FXVec3d const *self,FXint i){
+      if(i<0||i>2) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      return (*self)[i];
+      }
+SWIGINTERN FXdouble FXVec3d___setitem__(FXVec3d *self,FXint i,FXdouble d){
+      if(i<0||i>2) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      (*self)[i]=d;
+      return d;
+      }
+SWIGINTERN FXVec3d FXVec3d_operator_Ss_(FXVec3d const *self){ return -(*self); }
+SWIGINTERN FXVec3d FXVec3d_operator_Sa_(FXVec3d const *self,FXVec3d const &other){ return (*self)+other; }
+SWIGINTERN FXVec3d FXVec3d_operator_Ss_(FXVec3d const *self,FXVec3d const &other){ return (*self)-other; }
+SWIGINTERN FXVec3d FXVec3d_operator_Sm___SWIG_0(FXVec3d const *self,FXdouble n){ return (*self)*n; }
+SWIGINTERN FXVec3d FXVec3d_operator_Sd_(FXVec3d const *self,FXdouble n){
+      if(n==0.0) rb_raise(rb_eZeroDivError,"divided by 0");
+      return (*self)/n;
+      }
+SWIGINTERN FXdouble FXVec3d_operator_Sm___SWIG_1(FXVec3d const *self,FXVec3d const &other){ return (*self)*other; }
+SWIGINTERN FXdouble FXVec3d_dot(FXVec3d const *self,FXVec3d const &other){ return (*self)*other; }
+SWIGINTERN FXVec3d FXVec3d_operator_Sx_(FXVec3d const *self,FXVec3d const &other){ return (*self)^other; }
+SWIGINTERN FXVec3d FXVec3d_cross(FXVec3d const *self,FXVec3d const &other){ return (*self)^other; }
+SWIGINTERN bool FXVec3d_operator_Se__Se_(FXVec3d const *self,FXVec3d const &other){ return (*self)==other; }
+SWIGINTERN FXVec3d FXVec3d_normalize(FXVec3d const *self){ return normalize(*self); }
+SWIGINTERN FXVec3d FXVec3d_lo(FXVec3d const *self,FXVec3d const &other){ return lo(*self,other); }
+SWIGINTERN FXVec3d FXVec3d_hi(FXVec3d const *self,FXVec3d const &other){ return hi(*self,other); }
+SWIGINTERN FXVec3d FXVec3d_normal__SWIG_0(FXVec3d const &a,FXVec3d const &b,FXVec3d const &c){
+      return FX::normal(a,b,c);
+      }
+SWIGINTERN FXVec3d FXVec3d_normal__SWIG_1(FXVec3d const &a,FXVec3d const &b,FXVec3d const &c,FXVec3d const &d){
+      return FX::normal(a,b,c,d);
+      }
+SWIGINTERN FXVec4f *new_FXVec4f__SWIG_0(){
+			return new FXVec4f(0.0f, 0.0f, 0.0f, 0.0f);
+		}
+SWIGINTERN FXfloat FXVec4f___getitem__(FXVec4f const *self,FXint i){
+      if(i<0||i>3) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      return (*self)[i];
+      }
+SWIGINTERN FXfloat FXVec4f___setitem__(FXVec4f *self,FXint i,FXfloat f){
+      if(i<0||i>3) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      (*self)[i]=f;
+      return f;
+      }
+SWIGINTERN FXVec4f FXVec4f_operator_Ss_(FXVec4f const *self){ return -(*self); }
+SWIGINTERN FXVec4f FXVec4f_operator_Sa_(FXVec4f const *self,FXVec4f const &b){ return (*self)+b; }
+SWIGINTERN FXVec4f FXVec4f_operator_Ss_(FXVec4f const *self,FXVec4f const &b){ return (*self)-b; }
+SWIGINTERN FXVec4f FXVec4f_operator_Sm___SWIG_0(FXVec4f const *self,FXfloat n){ return (*self)*n; }
+SWIGINTERN FXVec4f FXVec4f_operator_Sd_(FXVec4f const *self,FXfloat n){
+      if(n==0.0f) rb_raise(rb_eZeroDivError,"divided by 0");
+      return (*self)/n;
+      }
+SWIGINTERN FXfloat FXVec4f_operator_Sm___SWIG_1(FXVec4f const *self,FXVec4f const &a){ return (*self)*a; }
+SWIGINTERN FXfloat FXVec4f_dot(FXVec4f const *self,FXVec4f const &a){ return (*self)*a; }
+SWIGINTERN bool FXVec4f_operator_Se__Se___SWIG_0(FXVec4f const *self,FXVec4f const &b){ return (*self == b); }
+SWIGINTERN bool FXVec4f_operator_Se__Se___SWIG_1(FXVec4f const *self,FXfloat n){ return (*self == n); }
+SWIGINTERN FXVec4f FXVec4f_normalize(FXVec4f const *self){ return normalize(*self); }
+SWIGINTERN FXVec4f FXVec4f_lo(FXVec4f const *self,FXVec4f const &other){ return lo(*self,other); }
+SWIGINTERN FXVec4f FXVec4f_hi(FXVec4f const *self,FXVec4f const &other){ return hi(*self,other); }
+SWIGINTERN FXVec4f FXVec4f_plane__SWIG_0(FXVec4f const &vec){ return FX::plane(vec); }
+SWIGINTERN FXVec4f FXVec4f_plane__SWIG_1(FXVec3f const &vec,FXfloat dist){ return FX::plane(vec,dist); }
+SWIGINTERN FXVec4f FXVec4f_plane__SWIG_2(FXVec3f const &vec,FXVec3f const &p){ return FX::plane(vec,p); }
+SWIGINTERN FXVec4f FXVec4f_plane__SWIG_3(FXVec3f const &a,FXVec3f const &b,FXVec3f const &c){ return FX::plane(a,b,c); }
+SWIGINTERN FXVec4d *new_FXVec4d__SWIG_0(){
+			return new FXVec4d(0.0, 0.0, 0.0, 0.0);
+		}
+SWIGINTERN FXdouble FXVec4d___getitem__(FXVec4d const *self,FXint i){
+      if(i<0||i>3) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      return (*self)[i];
+      }
+SWIGINTERN FXdouble FXVec4d___setitem__(FXVec4d *self,FXint i,FXdouble d){
+      if(i<0||i>3) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      (*self)[i]=d;
+      return d;
+      }
+SWIGINTERN FXVec4d FXVec4d_operator_Ss_(FXVec4d const *self){ return -(*self); }
+SWIGINTERN FXVec4d FXVec4d_operator_Sa_(FXVec4d const *self,FXVec4d const &other){ return (*self)+other; }
+SWIGINTERN FXVec4d FXVec4d_operator_Ss_(FXVec4d const *self,FXVec4d const &other){ return (*self)-other; }
+SWIGINTERN FXVec4d FXVec4d_operator_Sm___SWIG_0(FXVec4d const *self,FXdouble n){ return (*self)*n; }
+SWIGINTERN FXVec4d FXVec4d_operator_Sd_(FXVec4d const *self,FXdouble n){
+      if(n==0.0) rb_raise(rb_eZeroDivError,"divided by 0");
+      return (*self)/n;
+      }
+SWIGINTERN FXdouble FXVec4d_operator_Sm___SWIG_1(FXVec4d const *self,FXVec4d const &other){ return (*self)*other; }
+SWIGINTERN FXdouble FXVec4d_dot(FXVec4d const *self,FXVec4d const &other){ return (*self)*other; }
+SWIGINTERN bool FXVec4d_operator_Se__Se_(FXVec4d const *self,FXVec4d const &other){ return (*self)==other; }
+SWIGINTERN FXVec4d FXVec4d_normalize(FXVec4d const *self){ return normalize(*self); }
+SWIGINTERN FXVec4d FXVec4d_lo(FXVec4d const *self,FXVec4d const &other){ return lo(*self,other); }
+SWIGINTERN FXVec4d FXVec4d_hi(FXVec4d const *self,FXVec4d const &other){ return hi(*self,other); }
+SWIGINTERN FXVec4d FXVec4d_plane__SWIG_0(FXVec4d const &vec){ return FX::plane(vec); }
+SWIGINTERN FXVec4d FXVec4d_plane__SWIG_1(FXVec3d const &vec,FXdouble dist){ return FX::plane(vec,dist); }
+SWIGINTERN FXVec4d FXVec4d_plane__SWIG_2(FXVec3d const &vec,FXVec3d const &p){ return FX::plane(vec,p); }
+SWIGINTERN FXVec4d FXVec4d_plane__SWIG_3(FXVec3d const &a,FXVec3d const &b,FXVec3d const &c){ return FX::plane(a,b,c); }
+SWIGINTERN VALUE FXQuatf_getAxisAngle(FXQuatf const *self){
+      FXVec3f axis;
+      FXfloat phi;
+      self->getAxisAngle(axis,phi);
+      return rb_ary_new3(2,rb_ary_new3(3,rb_float_new(axis.x),rb_float_new(axis.y),rb_float_new(axis.z)),rb_float_new(phi));
+      }
+SWIGINTERN VALUE FXQuatf_getRollPitchYaw(FXQuatf const *self){
+      FXfloat roll,pitch,yaw;
+      self->getRollPitchYaw(roll,pitch,yaw);
+      return rb_ary_new3(3,rb_float_new(roll),rb_float_new(pitch),rb_float_new(yaw));
+      }
+SWIGINTERN VALUE FXQuatf_getAxes(FXQuatf const *self){
+      FXVec3f ex,ey,ez;
+      self->getAxes(ex,ey,ez);
+      return rb_ary_new3(3,Qnil,Qnil,Qnil); // FIXME
+      }
+SWIGINTERN FXQuatf FXQuatf_operator_Sm___SWIG_0(FXQuatf const *self,FXQuatf const &other){ return (*self)*other; }
+SWIGINTERN FXVec3f FXQuatf_operator_Sm___SWIG_1(FXQuatf const *self,FXVec3f const &vec){ return (*self)*vec; }
+SWIGINTERN VALUE FXQuatd_getAxisAngle(FXQuatd const *self){
+      FXVec3d axis;
+      FXdouble phi;
+      self->getAxisAngle(axis,phi);
+      return rb_ary_new3(2,rb_ary_new3(3,rb_float_new(axis.x),rb_float_new(axis.y),rb_float_new(axis.z)),rb_float_new(phi));
+      }
+SWIGINTERN VALUE FXQuatd_getRollPitchYaw(FXQuatd const *self){
+      FXdouble roll,pitch,yaw;
+      self->getRollPitchYaw(roll,pitch,yaw);
+      return rb_ary_new3(3,rb_float_new(roll),rb_float_new(pitch),rb_float_new(yaw));
+      }
+SWIGINTERN FXQuatd FXQuatd_operator_Sm___SWIG_0(FXQuatd const *self,FXQuatd const &other){ return (*self)*other; }
+SWIGINTERN FXVec3d FXQuatd_operator_Sm___SWIG_1(FXQuatd const *self,FXVec3d const &vec){ return (*self)*vec; }
+SWIGINTERN VALUE FXQuatd_getAxes(FXQuatd const *self){
+      FXVec3d ex,ey,ez;
+      self->getAxes(ex,ey,ez);
+      return rb_ary_new3(3,Qnil,Qnil,Qnil);
+    }
+SWIGINTERN FXVec3f const &FXMat3f___getitem__(FXMat3f const *self,FXint i){
+      if(i<0 || i>2) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      return (*self)[i];
+      }
+SWIGINTERN FXVec3f &FXMat3f___setitem__(FXMat3f *self,FXint i,FXVec3d const &other){
+      if(i<0 || i>2) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      (*self)[i]=other;
+      return (*self)[i];
+      }
+SWIGINTERN FXMat3f FXMat3f_operator_Sa_(FXMat3f const *self,FXMat3f const &other){ return (*self)+other; }
+SWIGINTERN FXMat3f FXMat3f_operator_Ss_(FXMat3f const *self,FXMat3f const &other){ return (*self)-other; }
+SWIGINTERN FXMat3f FXMat3f_operator_Ss_(FXMat3f const *self){ return -(*self); }
+SWIGINTERN FXMat3f FXMat3f_operator_Sm___SWIG_0(FXMat3f const *self,FXMat3f const &other){ return (*self)*other; }
+SWIGINTERN FXMat3f FXMat3f_operator_Sm___SWIG_1(FXMat3f const *self,FXfloat x){ return (*self)*x; }
+SWIGINTERN FXMat3f FXMat3f_operator_Sd_(FXMat3f const *self,FXfloat x){
+      if(x==0.0f) rb_raise(rb_eZeroDivError,"divided by 0");
+      return (*self)/x;
+      }
+SWIGINTERN FXVec3f FXMat3f_operator_Sm___SWIG_2(FXMat3f const *self,FXVec3f const &other){ return (*self)*other; }
+SWIGINTERN FXVec2f FXMat3f_operator_Sm___SWIG_3(FXMat3f const *self,FXVec2f const &other){ return (*self)*other; }
+SWIGINTERN FXVec3d const &FXMat3d___getitem__(FXMat3d const *self,FXint i){
+      if(i<0 || i>2) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      return (*self)[i];
+      }
+SWIGINTERN FXVec3d &FXMat3d___setitem__(FXMat3d *self,FXint i,FXVec3d const &other){
+      if(i<0 || i>2) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      (*self)[i]=other;
+      return (*self)[i];
+      }
+SWIGINTERN FXMat3d FXMat3d_operator_Sa_(FXMat3d const *self,FXMat3d const &other){ return (*self)+other; }
+SWIGINTERN FXMat3d FXMat3d_operator_Ss_(FXMat3d const *self,FXMat3d const &other){ return (*self)-other; }
+SWIGINTERN FXMat3d FXMat3d_operator_Ss_(FXMat3d const *self){ return -(*self); }
+SWIGINTERN FXMat3d FXMat3d_operator_Sm___SWIG_0(FXMat3d const *self,FXMat3d const &other){ return (*self)*other; }
+SWIGINTERN FXMat3d FXMat3d_operator_Sm___SWIG_1(FXMat3d const *self,FXdouble x){ return (*self)*x; }
+SWIGINTERN FXMat3d FXMat3d_operator_Sd_(FXMat3d const *self,FXdouble x){
+      if(x==0.0) rb_raise(rb_eZeroDivError,"divided by 0");
+      return (*self)/x;
+      }
+SWIGINTERN FXVec3d FXMat3d_operator_Sm___SWIG_2(FXMat3d const *self,FXVec3d const &other){ return (*self)*other; }
+SWIGINTERN FXVec2d FXMat3d_operator_Sm___SWIG_3(FXMat3d const *self,FXVec2d const &other){ return (*self)*other; }
+SWIGINTERN FXVec4f const &FXMat4f___getitem__(FXMat4f const *self,FXint i){
+      if(i<0 || i>3) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      return (*self)[i];
+      }
+SWIGINTERN FXVec4f &FXMat4f___setitem__(FXMat4f *self,FXint i,FXVec3d const &other){
+      if(i<0 || i>3) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      (*self)[i]=other;
+      return (*self)[i];
+      }
+SWIGINTERN FXMat4f FXMat4f_operator_Sa_(FXMat4f const *self,FXMat4f const &other){ return (*self)+other; }
+SWIGINTERN FXMat4f FXMat4f_operator_Ss_(FXMat4f const *self,FXMat4f const &other){ return (*self)-other; }
+SWIGINTERN FXMat4f FXMat4f_operator_Sm___SWIG_0(FXMat4f const *self,FXMat4f const &other){ return (*self)*other; }
+SWIGINTERN FXMat4f FXMat4f_operator_Sm___SWIG_1(FXMat4f const *self,FXfloat x){ return (*self)*x; }
+SWIGINTERN FXVec4f FXMat4f_operator_Sm___SWIG_2(FXMat4f const *self,FXVec4f const &other){ return (*self)*other; }
+SWIGINTERN FXVec3f FXMat4f_operator_Sm___SWIG_3(FXMat4f const *self,FXVec3f const &other){ return (*self)*other; }
+SWIGINTERN FXMat4f FXMat4f_operator_Sd_(FXMat4f const *self,FXfloat x){
+      if(x==0.0f) rb_raise(rb_eZeroDivError,"divided by 0");
+      return (*self)/x;
+      }
+SWIGINTERN FXMat4f FXMat4f_operator_Ss_(FXMat4f const *self){ return -(*self); }
+SWIGINTERN FXString FXMat4f_to_s(FXMat4f const *self){
+      const FXMat4f& m = *self;
+      return FXStringFormat("[[%g, %g, %g, %g], [%g, %g, %g, %g], [%g, %g, %g, %g], [%g, %g, %g, %g]]",m[0][0],m[0][1],m[0][2],m[0][3],m[1][0],m[1][1],m[1][2],m[1][3],m[2][0],m[2][1],m[2][2],m[2][3],m[3][0],m[3][1],m[3][2],m[3][3]);
+      }
+SWIGINTERN FXVec4d const &FXMat4d___getitem__(FXMat4d const *self,FXint i){
+      if(i<0 || i>3) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      return (*self)[i];
+      }
+SWIGINTERN FXVec4d &FXMat4d___setitem__(FXMat4d *self,FXint i,FXVec3d const &other){
+      if(i<0 || i>3) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      (*self)[i]=other;
+      return (*self)[i];
+      }
+SWIGINTERN FXMat4d FXMat4d_operator_Sa_(FXMat4d const *self,FXMat4d const &other){ return (*self)+other; }
+SWIGINTERN FXMat4d FXMat4d_operator_Ss_(FXMat4d const *self,FXMat4d const &other){ return (*self)-other; }
+SWIGINTERN FXMat4d FXMat4d_operator_Ss_(FXMat4d const *self){ return -(*self); }
+SWIGINTERN FXMat4d FXMat4d_operator_Sm___SWIG_0(FXMat4d const *self,FXMat4d const &other){ return (*self)*other; }
+SWIGINTERN FXMat4d FXMat4d_operator_Sm___SWIG_1(FXMat4d const *self,FXdouble x){ return (*self)*x; }
+SWIGINTERN FXMat4d FXMat4d_operator_Sd_(FXMat4d const *self,FXdouble x){
+      if(x==0.0) rb_raise(rb_eZeroDivError,"divided by 0");
+      return (*self)/x;
+      }
+SWIGINTERN FXVec4d FXMat4d_operator_Sm___SWIG_2(FXMat4d const *self,FXVec4d const &other){ return (*self)*other; }
+SWIGINTERN FXVec3d FXMat4d_operator_Sm___SWIG_3(FXMat4d const *self,FXVec3d const &v){ return (*self)*v; }
+SWIGINTERN FXVec3f &FXRangef___getitem__(FXRangef *self,FXint i){
+      if(i<0||1<i){
+        rb_raise(rb_eIndexError,"index %d out of bounds",i);
+        }
+      return (*self)[i];
+      }
+SWIGINTERN void FXRangef___setitem__(FXRangef *self,FXint i,FXVec3f &slice){
+      if(i<0||1<i){
+        rb_raise(rb_eIndexError,"index %d out of bounds",i);
+        }
+      (*self)[i]=slice;
+      }
+SWIGINTERN FXVec3f FXRangef_upper(FXRangef const *self){
+      return self->upper;
+      }
+SWIGINTERN FXVec3f FXRangef_lower(FXRangef const *self){
+      return self->lower;
+      }
+
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
+
+
+  #define SWIG_From_long   LONG2NUM 
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_int  (int value)
+{    
+  return SWIG_From_long  (value);
+}
+
+SWIGINTERN bool FXRangef_overlaps(FXRangef const *self,FXRangef const &other){
+      return FX::overlap(*self,other);
+      }
+SWIGINTERN FXVec3f FXRangef_corner(FXRangef const *self,FXint c){
+      if(c<0||7<c){
+        rb_raise(rb_eIndexError,"corner index %d out of bounds",c);
+        }
+      return self->corner(c);
+      }
+SWIGINTERN FXRangef FXRangef_onion(FXRangef const *self,FXRangef const &other){
+      return FX::unite(*self,other);
+      }
+SWIGINTERN FXRangef FXRangef_intersection(FXRangef const *self,FXRangef const &other){
+      return FX::intersect(*self,other);
+      }
+SWIGINTERN FXVec3d &FXRanged___getitem__(FXRanged *self,FXint i){
+      if(i<0||1<i){
+        rb_raise(rb_eIndexError,"index %d out of bounds",i);
+        }
+      return (*self)[i];
+      }
+SWIGINTERN void FXRanged___setitem__(FXRanged *self,FXint i,FXVec3d &slice){
+      if(i<0||1<i){
+        rb_raise(rb_eIndexError,"index %d out of bounds",i);
+        }
+      (*self)[i]=slice;
+      }
+SWIGINTERN bool FXRanged_overlaps(FXRanged const *self,FXRanged const &other){
+      return FX::overlap(*self,other);
+      }
+SWIGINTERN FXVec3d FXRanged_corner(FXRanged const *self,FXint c){
+      if(c<0||7<c){
+        rb_raise(rb_eIndexError,"corner index %d out of bounds",c);
+        }
+      return self->corner(c);
+      }
+SWIGINTERN FXRanged FXRanged_onion(FXRanged const *self,FXRanged const &other){
+      return FX::unite(*self,other);
+      }
+SWIGINTERN FXRanged FXRanged_intersection(FXRanged const *self,FXRanged const &other){
+      return FX::intersect(*self,other);
+      }
+SWIGINTERN bool FXSpheref_overlap__SWIG_0(FXSpheref const *self,FXRangef const &other){
+      return overlap(*self,other);
+      }
+SWIGINTERN bool FXSpheref_overlap__SWIG_1(FXSpheref const *self,FXSpheref const &other){
+      return overlap(*self,other);
+      }
+SWIGINTERN bool FXSphered_overlap__SWIG_0(FXSphered const *self,FXRanged const &other){
+      return overlap(*self,other);
+      }
+SWIGINTERN bool FXSphered_overlap__SWIG_1(FXSphered const *self,FXSphered const &other){
+      return overlap(*self,other);
+      }
+SWIGINTERN FXGLVisual *new_FXGLVisual(FXApp *a,FXuint flags){
+      return new FXRbGLVisual(a,flags);
+      }
+SWIGINTERN VALUE FXGLVisual_supported(FXApp *application){
+      int major,minor;
+      FXbool answer=FXGLVisual::supported(application,major,minor);
+      return rb_ary_new3(3,answer?Qtrue:Qfalse,INT2NUM(major),INT2NUM(minor));
+      }
+
+/*@SWIG:/usr/share/swig3.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE pargs){VALUE *args=(VALUE *)pargs;
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  long *res = (long *)(args[1]);
+  *res = type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj);
+  return obj;
+}
+/*@SWIG@*/
+
+SWIGINTERN int
+SWIG_AsVal_long (VALUE obj, long* val)
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
+    long v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_VALUE_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_VALUE_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_int (VALUE obj, int *val)
+{
+  long v;
+  int res = SWIG_AsVal_long (obj, &v);
+  if (SWIG_IsOK(res)) {
+    if ((v < INT_MIN || v > INT_MAX)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = static_cast< int >(v);
+    }
+  }  
+  return res;
+}
+
+SWIGINTERN FXGLContext *new_FXGLContext__SWIG_0(FXApp *a,FXGLVisual *vis){
+      return new FXRbGLContext(a,vis);
+      }
+SWIGINTERN FXGLContext *new_FXGLContext__SWIG_1(FXApp *a,FXGLVisual *vis,FXGLContext *shared){
+      return new FXRbGLContext(a,vis,shared);
+      }
+SWIGINTERN FXGLCanvas *new_FXGLCanvas__SWIG_0(FXComposite *p,FXGLVisual *vis,FXObject *tgt=0,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbGLCanvas(p,vis,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN FXGLCanvas *new_FXGLCanvas__SWIG_1(FXComposite *p,FXGLVisual *vis,FXGLCanvas *sharegroup,FXObject *tgt=0,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbGLCanvas(p,vis,sharegroup,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN FXuval FXGLCanvas_getCurrentContext(){
+      return reinterpret_cast<FXuval>(FXGLCanvas::getCurrentContext());
+      }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_long  (unsigned long value)
+{
+  return ULONG2NUM(value); 
+}
+
+SWIGINTERN FXuval FXGLCanvas_getContext(FXGLCanvas const *self){
+      return reinterpret_cast<FXuval>(self->getContext());
+      }
+
+SWIGINTERN swig_type_info*
+SWIG_pchar_descriptor(void)
+{
+  static int init = 0;
+  static swig_type_info* info = 0;
+  if (!init) {
+    info = SWIG_TypeQuery("_p_char");
+    init = 1;
+  }
+  return info;
+}
+
+
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
+{
+  if (TYPE(obj) == T_STRING) {
+    char *cstr = StringValuePtr(obj); 
+    size_t size = RSTRING_LEN(obj) + 1;
+    if (cptr)  {
+      if (alloc) {
+	if (*alloc == SWIG_NEWOBJ) {
+	  *cptr = reinterpret_cast< char* >(memcpy(new char[size], cstr, sizeof(char)*(size)));
+	} else {
+	  *cptr = cstr;
+	  *alloc = SWIG_OLDOBJ;
+	}
+      }
+    }
+    if (psize) *psize = size;
+    return SWIG_OK;
+  } else {
+    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+    if (pchar_descriptor) {
+      void* vptr = 0;
+      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
+	if (cptr) *cptr = (char *)vptr;
+	if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
+	if (alloc) *alloc = SWIG_OLDOBJ;
+	return SWIG_OK;
+      }
+    }
+  }  
+  return SWIG_TypeError;
+}
+
+
+
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+  if (carray) {
+    if (size > LONG_MAX) {
+      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+      return pchar_descriptor ? 
+	SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : Qnil;
+    } else {
+      return rb_str_new(carray, static_cast< long >(size));
+    }
+  } else {
+    return Qnil;
+  }
+}
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtr(const char *cptr)
+{ 
+  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
+}
+
+
+static swig_type_info *FXGLCanvas_dynamic_cast(void **ptr) {
+    FXGLCanvas **ppGLCanvas = reinterpret_cast<FXGLCanvas **>(ptr);
+    FXGLViewer *pGLViewer=dynamic_cast<FXGLViewer*>(*ppGLCanvas);
+    if(pGLViewer){
+      *ptr=reinterpret_cast<void*>(pGLViewer);
+      return SWIG_TypeQuery("FXGLViewer *");
+      }
+    return 0;
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_int  (unsigned int value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+
+/*@SWIG:/usr/share/swig3.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE pargs){VALUE *args=(VALUE *)pargs;
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  unsigned long *res = (unsigned long *)(args[1]);
+  *res = type == T_FIXNUM ? NUM2ULONG(obj) : rb_big2ulong(obj);
+  return obj;
+}
+/*@SWIG@*/
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_long (VALUE obj, unsigned long *val) 
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
+    unsigned long v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_VALUE_METHOD_FUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, RUBY_VALUE_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_int (VALUE obj, unsigned int *val)
+{
+  unsigned long v;
+  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
+  if (SWIG_IsOK(res)) {
+    if ((v > UINT_MAX)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = static_cast< unsigned int >(v);
+    }
+  }  
+  return res;
+}
+
+SWIGINTERN VALUE FXGLViewer_objectTypeName(){
+      return to_ruby(FXGLViewer::objectTypeName);
+      }
+SWIGINTERN FXGLViewer *new_FXGLViewer__SWIG_0(FXComposite *p,FXGLVisual *vis,FXObject *tgt=0,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbGLViewer(p,vis,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN FXGLViewer *new_FXGLViewer__SWIG_1(FXComposite *p,FXGLVisual *vis,FXGLViewer *sharegroup,FXObject *tgt=0,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbGLViewer(p,vis,sharegroup,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN VALUE FXGLViewer_lasso(FXGLViewer *self,FXint x1,FXint y1,FXint x2,FXint y2){
+      VALUE objects = rb_ary_new();
+      FXGLObject** items = self->lasso(x1, y1, x2, y2);
+      if (items) {
+        register FXGLObject** p = items;
+        while (*p) {
+          rb_ary_push(objects, to_ruby(*p));
+          p++;
+        }
+        FXFREE(&items);
+      }
+      return objects;
+    }
+SWIGINTERN FXViewport FXGLViewer_getViewport(FXGLViewer const *self){
+      FXViewport v;
+      self->getViewport(v);
+      return v;
+    }
+SWIGINTERN VALUE FXGLViewer_eyeToScreen(FXGLViewer *self,FXVec3f e){
+      FXint sx, sy;
+      self->eyeToScreen(sx, sy, e);
+      VALUE point = rb_ary_new();
+      rb_ary_push(point, INT2NUM(sx));
+      rb_ary_push(point, INT2NUM(sy));
+      return point;
+    }
+SWIGINTERN FXMaterial FXGLViewer_getMaterial(FXGLViewer const *self){
+      FXMaterial mtl;
+      self->getMaterial(mtl);
+      return mtl;
+    }
+SWIGINTERN VALUE FXGLViewer_getBoreVector(FXGLViewer *self,FXint sx,FXint sy){
+      FXVec3f point, dir;
+      self->getBoreVector(sx, sy, point, dir);
+
+      VALUE pointArray = rb_ary_new();
+      rb_ary_push(pointArray, rb_float_new(point[0]));
+      rb_ary_push(pointArray, rb_float_new(point[1]));
+      rb_ary_push(pointArray, rb_float_new(point[2]));
+
+      VALUE dirArray = rb_ary_new();
+      rb_ary_push(dirArray, rb_float_new(dir[0]));
+      rb_ary_push(dirArray, rb_float_new(dir[1]));
+      rb_ary_push(dirArray, rb_float_new(dir[2]));
+
+      VALUE results = rb_ary_new();
+      rb_ary_push(results, pointArray);
+      rb_ary_push(results, dirArray);
+
+      return results;
+    }
+SWIGINTERN VALUE FXGLViewer_readPixels(FXGLViewer *self,FXint x,FXint y,FXint w,FXint h){
+      FXColor *buffer;
+      VALUE pixels=Qnil;
+      if(self->readPixels(buffer,x,y,w,h)){
+	pixels=FXRbMakeColorArray(buffer,w,h);
+	FXFREE(&buffer);
+	}
+      return pixels;
+      }
+SWIGINTERN VALUE FXGLViewer_readFeedback(FXGLViewer *self,FXint x,FXint y,FXint w,FXint h){
+      FXfloat *buffer;
+      FXint used, size;
+      if (self->readFeedback(buffer,used,size,x,y,w,h)){
+	VALUE results=rb_ary_new();
+	for(FXint i=0;i<used;i++) rb_ary_push(results,rb_float_new(buffer[i]));
+	FXFREE(&buffer);
+	return results;
+        }
+      else{
+	return Qnil;
+        }
+      }
+SWIGINTERN void FXGLViewer_setZSortFunc(FXGLViewer *self,VALUE proc){
+      }
+SWIGINTERN VALUE FXGLViewer_getZSortFunc(FXGLViewer const *self){
+      return Qnil;
+      }
+SWIGINTERN FXLight FXGLViewer_getLight(FXGLViewer const *self){
+      FXLight lite;
+      self->getLight(lite);
+      return lite;
+    }
+SWIGINTERN FXGLObject *new_FXGLObject(){
+      return new FXRbGLObject();
+      }
+SWIGINTERN FXGLObject *FXGLObject_identify(FXGLObject *self,FXuint *path,FXint n){
+      return self->identify(path);
+      }
+
+static swig_type_info *FXGLObject_dynamic_cast(void **ptr) {
+    FXGLObject **ppGLObject = reinterpret_cast<FXGLObject **>(ptr);
+    FXGLShape *pGLShape=dynamic_cast<FXGLShape*>(*ppGLObject);
+    if(pGLShape){
+      *ptr=reinterpret_cast<void*>(pGLShape);
+      return SWIG_TypeQuery("FXGLShape *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXGLShape *new_FXGLShape__SWIG_0(FXfloat x,FXfloat y,FXfloat z,FXuint opts){
+      return new FXRbGLShape(x,y,z,opts);
+      }
+SWIGINTERN FXGLShape *new_FXGLShape__SWIG_1(FXfloat x,FXfloat y,FXfloat z,FXuint opts,FXMaterial const &front,FXMaterial const &back){
+      return new FXRbGLShape(x,y,z,opts,front,back);
+      }
+SWIGINTERN FXGLObject *FXGLShape_identify(FXGLShape *self,FXuint *path,FXint n){
+      return self->identify(path);
+      }
+SWIGINTERN FXVec3f FXGLShape_getPosition(FXGLShape const *self){
+      FXASSERT(self->isMemberOf(FXMETACLASS(FXRbGLShape)));
+      return dynamic_cast<const FXRbGLShape*>(self)->getPosition();
+      }
+SWIGINTERN void FXGLShape_setPosition(FXGLShape *self,FXVec3f const &pos){
+      FXASSERT(self->isMemberOf(FXMETACLASS(FXRbGLShape)));
+      dynamic_cast<FXRbGLShape*>(self)->setPosition(pos);
+      }
+SWIGINTERN FXMaterial FXGLShape_getMaterial(FXGLShape const *self,FXint side){
+      FXMaterial mtl;
+      self->getMaterial(side, mtl);
+      return mtl;
+      }
+SWIGINTERN void FXGLShape_setRange(FXGLShape *self,FXRangef const &box){
+      FXASSERT(self->isMemberOf(FXMETACLASS(FXRbGLShape)));
+      dynamic_cast<FXRbGLShape*>(self)->setRange(box);
+      }
+SWIGINTERN FXVec2f &FXExtentf___setitem__(FXExtentf *self,FXint i,FXVec2f &v){
+      if(i<0||i>1) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      (*self)[i]=v;
+      return v;
+      }
+SWIGINTERN FXVec2f const &FXExtentf___getitem__(FXExtentf const *self,FXint i){
+      if(i<0||i>1) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      return (*self)[i];
+      }
+SWIGINTERN bool FXExtentf_overlap(FXExtentf const *self,FXExtentf const &other){
+      return overlap(*self,other);
+      }
+SWIGINTERN FXExtentf FXExtentf_unite_with(FXExtentf const *self,FXExtentf const &other){
+      return unite(*self,other);
+      }
+SWIGINTERN FXExtentf FXExtentf_intersect_with(FXExtentf const *self,FXExtentf const &other){
+      return intersect(*self,other);
+      }
+SWIGINTERN FXVec2d &FXExtentd___setitem__(FXExtentd *self,FXint i,FXVec2d &v){
+      if(i<0||i>1) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      (*self)[i]=v;
+      return v;
+      }
+SWIGINTERN FXVec2d const &FXExtentd___getitem__(FXExtentd const *self,FXint i){
+      if(i<0||i>1) rb_raise(rb_eIndexError,"index %d out of bounds",i);
+      return (*self)[i];
+      }
+SWIGINTERN bool FXExtentd_overlap(FXExtentd const *self,FXExtentd const &other){
+      return overlap(*self,other);
+      }
+SWIGINTERN FXExtentd FXExtentd_unite_with(FXExtentd const *self,FXExtentd const &other){
+      return unite(*self,other);
+      }
+SWIGINTERN FXExtentd FXExtentd_intersect_with(FXExtentd const *self,FXExtentd const &other){
+      return intersect(*self,other);
+      }
+static swig_class SwigClassFXVec2f;
+
+SWIGINTERN VALUE
+_wrap_FXVec2f_x_set(int argc, VALUE *argv, VALUE self) {
+  FXVec2f *arg1 = (FXVec2f *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2f *","x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","x", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  if (arg1) (arg1)->x = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2f_x_get(int argc, VALUE *argv, VALUE self) {
+  FXVec2f *arg1 = (FXVec2f *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2f *","x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2f * >(argp1);
+  result = (FXfloat) ((arg1)->x);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2f_y_set(int argc, VALUE *argv, VALUE self) {
+  FXVec2f *arg1 = (FXVec2f *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2f *","y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","y", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  if (arg1) (arg1)->y = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2f_y_get(int argc, VALUE *argv, VALUE self) {
+  FXVec2f *arg1 = (FXVec2f *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2f *","y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2f * >(argp1);
+  result = (FXfloat) ((arg1)->y);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVec2f__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXfloat arg1 = (FXfloat) 0.0 ;
+  FXfloat arg2 = (FXfloat) 0.0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  FXVec2f *result = 0 ;
+  
+  if ((argc < 0) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  if (argc > 0) {
+    ecode1 = SWIG_AsVal_float(argv[0], &val1);
+    if (!SWIG_IsOK(ecode1)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXfloat","FXVec2f", 1, argv[0] ));
+    } 
+    arg1 = static_cast< FXfloat >(val1);
+  }
+  if (argc > 1) {
+    ecode2 = SWIG_AsVal_float(argv[1], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","FXVec2f", 2, argv[1] ));
+    } 
+    arg2 = static_cast< FXfloat >(val2);
+  }
+  {
+    result = (FXVec2f *)new FXVec2f(arg1,arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVec2f__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXVec2f *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXVec2f *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXVec2f,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2f const &","FXVec2f", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2f const &","FXVec2f", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXVec2f * >(argp1);
+  {
+    result = (FXVec2f *)new FXVec2f((FXVec2f const &)*arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXVec2f_allocate(VALUE self)
+#else
+_wrap_FXVec2f_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXVec2f);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVec2f__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXfloat *arg1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec2f *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_float, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXfloat const []","FXVec2f", 1, argv[0] )); 
+  } 
+  arg1 = reinterpret_cast< FXfloat * >(argp1);
+  {
+    result = (FXVec2f *)new FXVec2f((FXfloat const (*))arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXVec2f(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[2];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 2) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 0) && (argc <= 2)) {
+    int _v;
+    if (argc <= 0) {
+      return _wrap_new_FXVec2f__SWIG_0(nargs, args, self);
+    }
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      if (argc <= 1) {
+        return _wrap_new_FXVec2f__SWIG_0(nargs, args, self);
+      }
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_FXVec2f__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec2f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXVec2f__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_float, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXVec2f__SWIG_2(nargs, args, self);
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 2, "FXVec2f.new", 
+    "    FXVec2f.new(FXfloat xx, FXfloat yy)\n"
+    "    FXVec2f.new(FXVec2f const &v)\n"
+    "    FXVec2f.new(FXfloat const v[])\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2f_length2(int argc, VALUE *argv, VALUE self) {
+  FXVec2f *arg1 = (FXVec2f *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2f const *","length2", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2f * >(argp1);
+  result = (FXfloat)((FXVec2f const *)arg1)->length2();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2f_length(int argc, VALUE *argv, VALUE self) {
+  FXVec2f *arg1 = (FXVec2f *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2f const *","length", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2f * >(argp1);
+  result = (FXfloat)((FXVec2f const *)arg1)->length();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec2f.[]
+
+  call-seq:
+    [](i) -> FXfloat
+
+Element accessor/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec2f___getitem__(int argc, VALUE *argv, VALUE self) {
+  FXVec2f *arg1 = (FXVec2f *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2f const *","__getitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2f * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXfloat)FXVec2f___getitem__((FXVec2f const *)arg1,arg2);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec2f.[]=
+
+  call-seq:
+    []=(i, f) -> FXfloat
+
+Element setter/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec2f___setitem__(int argc, VALUE *argv, VALUE self) {
+  FXVec2f *arg1 = (FXVec2f *) 0 ;
+  FXint arg2 ;
+  FXfloat arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2f *","__setitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2f * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","__setitem__", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  result = (FXfloat)FXVec2f___setitem__(arg1,arg2,arg3);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec2f.-@
+
+  call-seq:
+    -@ -> FXVec2f
+
+Substraction operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec2f___neg__(int argc, VALUE *argv, VALUE self) {
+  FXVec2f *arg1 = (FXVec2f *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec2f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2f const *","operator -", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2f * >(argp1);
+  result = FXVec2f_operator_Ss_((FXVec2f const *)arg1);
+  vresult = SWIG_NewPointerObj((new FXVec2f(static_cast< const FXVec2f& >(result))), SWIGTYPE_p_FXVec2f, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec2f.+
+
+  call-seq:
+    +(other) -> FXVec2f
+
+Add operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec2f___add__(int argc, VALUE *argv, VALUE self) {
+  FXVec2f *arg1 = (FXVec2f *) 0 ;
+  FXVec2f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXVec2f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2f const *","operator +", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2f * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2f,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2f const &","operator +", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2f const &","operator +", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2f * >(argp2);
+  result = FXVec2f_operator_Sa_((FXVec2f const *)arg1,(FXVec2f const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec2f(static_cast< const FXVec2f& >(result))), SWIGTYPE_p_FXVec2f, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec2f.-
+
+  call-seq:
+    -(other) -> FXVec2f
+
+Substraction operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec2f___sub__(int argc, VALUE *argv, VALUE self) {
+  FXVec2f *arg1 = (FXVec2f *) 0 ;
+  FXVec2f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXVec2f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2f const *","operator -", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2f * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2f,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2f const &","operator -", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2f const &","operator -", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2f * >(argp2);
+  result = FXVec2f_operator_Ss_((FXVec2f const *)arg1,(FXVec2f const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec2f(static_cast< const FXVec2f& >(result))), SWIGTYPE_p_FXVec2f, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2f___mul____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXVec2f *arg1 = (FXVec2f *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  FXVec2f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2f const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","operator *", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  result = FXVec2f_operator_Sm___SWIG_0((FXVec2f const *)arg1,arg2);
+  vresult = SWIG_NewPointerObj((new FXVec2f(static_cast< const FXVec2f& >(result))), SWIGTYPE_p_FXVec2f, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2f___div__(int argc, VALUE *argv, VALUE self) {
+  FXVec2f *arg1 = (FXVec2f *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  FXVec2f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2f const *","operator /", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","operator /", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  result = FXVec2f_operator_Sd_((FXVec2f const *)arg1,arg2);
+  vresult = SWIG_NewPointerObj((new FXVec2f(static_cast< const FXVec2f& >(result))), SWIGTYPE_p_FXVec2f, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2f___mul____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXVec2f *arg1 = (FXVec2f *) 0 ;
+  FXVec2f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2f const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2f * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2f,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2f const &","operator *", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2f const &","operator *", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2f * >(argp2);
+  result = (FXfloat)FXVec2f_operator_Sm___SWIG_1((FXVec2f const *)arg1,(FXVec2f const &)*arg2);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXVec2f___mul__(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec2f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec2f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXVec2f___mul____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec2f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXVec2f___mul____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "__mul__", 
+    "    FXVec2f __mul__(FXfloat n)\n"
+    "    FXfloat __mul__(FXVec2f const &other)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2f_dot(int argc, VALUE *argv, VALUE self) {
+  FXVec2f *arg1 = (FXVec2f *) 0 ;
+  FXVec2f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2f const *","dot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2f * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2f,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2f const &","dot", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2f const &","dot", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2f * >(argp2);
+  result = (FXfloat)FXVec2f_dot((FXVec2f const *)arg1,(FXVec2f const &)*arg2);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec2f.==
+
+  call-seq:
+    ==(other) -> bool
+
+Equality comparison operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec2f___eq__(int argc, VALUE *argv, VALUE self) {
+  FXVec2f *arg1 = (FXVec2f *) 0 ;
+  FXVec2f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2f const *","operator ==", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2f * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2f,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2f const &","operator ==", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2f const &","operator ==", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2f * >(argp2);
+  result = (bool)FXVec2f_operator_Se__Se_((FXVec2f const *)arg1,(FXVec2f const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2f_normalize(int argc, VALUE *argv, VALUE self) {
+  FXVec2f *arg1 = (FXVec2f *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec2f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2f const *","normalize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2f * >(argp1);
+  result = FXVec2f_normalize((FXVec2f const *)arg1);
+  vresult = SWIG_NewPointerObj((new FXVec2f(static_cast< const FXVec2f& >(result))), SWIGTYPE_p_FXVec2f, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2f_lo(int argc, VALUE *argv, VALUE self) {
+  FXVec2f *arg1 = (FXVec2f *) 0 ;
+  FXVec2f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXVec2f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2f const *","lo", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2f * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2f,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2f const &","lo", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2f const &","lo", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2f * >(argp2);
+  result = FXVec2f_lo((FXVec2f const *)arg1,(FXVec2f const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec2f(static_cast< const FXVec2f& >(result))), SWIGTYPE_p_FXVec2f, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2f_hi(int argc, VALUE *argv, VALUE self) {
+  FXVec2f *arg1 = (FXVec2f *) 0 ;
+  FXVec2f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXVec2f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2f const *","hi", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2f * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2f,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2f const &","hi", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2f const &","hi", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2f * >(argp2);
+  result = FXVec2f_hi((FXVec2f const *)arg1,(FXVec2f const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec2f(static_cast< const FXVec2f& >(result))), SWIGTYPE_p_FXVec2f, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2f_clamp(int argc, VALUE *argv, VALUE self) {
+  FXVec2f *arg1 = (FXVec2f *) 0 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  FXVec2f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2f *","clamp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","clamp", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","clamp", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  result = (FXVec2f *) &(arg1)->clamp(arg2,arg3);
+  vresult = FXRbGetRubyObj(result, "FXVec2f *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXVec2d;
+
+SWIGINTERN VALUE
+_wrap_FXVec2d_x_set(int argc, VALUE *argv, VALUE self) {
+  FXVec2d *arg1 = (FXVec2d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2d *","x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","x", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->x = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2d_x_get(int argc, VALUE *argv, VALUE self) {
+  FXVec2d *arg1 = (FXVec2d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2d *","x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2d * >(argp1);
+  result = (FXdouble) ((arg1)->x);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2d_y_set(int argc, VALUE *argv, VALUE self) {
+  FXVec2d *arg1 = (FXVec2d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2d *","y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","y", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->y = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2d_y_get(int argc, VALUE *argv, VALUE self) {
+  FXVec2d *arg1 = (FXVec2d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2d *","y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2d * >(argp1);
+  result = (FXdouble) ((arg1)->y);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVec2d__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXdouble arg1 = (FXdouble) 0.0 ;
+  FXdouble arg2 = (FXdouble) 0.0 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  FXVec2d *result = 0 ;
+  
+  if ((argc < 0) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  if (argc > 0) {
+    ecode1 = SWIG_AsVal_double(argv[0], &val1);
+    if (!SWIG_IsOK(ecode1)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXdouble","FXVec2d", 1, argv[0] ));
+    } 
+    arg1 = static_cast< FXdouble >(val1);
+  }
+  if (argc > 1) {
+    ecode2 = SWIG_AsVal_double(argv[1], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","FXVec2d", 2, argv[1] ));
+    } 
+    arg2 = static_cast< FXdouble >(val2);
+  }
+  {
+    result = (FXVec2d *)new FXVec2d(arg1,arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXVec2d_allocate(VALUE self)
+#else
+_wrap_FXVec2d_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXVec2d);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVec2d__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXVec2d *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXVec2d *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXVec2d,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2d const &","FXVec2d", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2d const &","FXVec2d", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXVec2d * >(argp1);
+  {
+    result = (FXVec2d *)new FXVec2d((FXVec2d const &)*arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXVec2d(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[2];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 2) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 0) && (argc <= 2)) {
+    int _v;
+    if (argc <= 0) {
+      return _wrap_new_FXVec2d__SWIG_0(nargs, args, self);
+    }
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      if (argc <= 1) {
+        return _wrap_new_FXVec2d__SWIG_0(nargs, args, self);
+      }
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_FXVec2d__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec2d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXVec2d__SWIG_1(nargs, args, self);
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 2, "FXVec2d.new", 
+    "    FXVec2d.new(FXdouble xx, FXdouble yy)\n"
+    "    FXVec2d.new(FXVec2d const &v)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2d_length2(int argc, VALUE *argv, VALUE self) {
+  FXVec2d *arg1 = (FXVec2d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2d const *","length2", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2d * >(argp1);
+  result = (FXdouble)((FXVec2d const *)arg1)->length2();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2d_length(int argc, VALUE *argv, VALUE self) {
+  FXVec2d *arg1 = (FXVec2d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2d const *","length", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2d * >(argp1);
+  result = (FXdouble)((FXVec2d const *)arg1)->length();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec2d.[]
+
+  call-seq:
+    [](i) -> FXdouble
+
+Element accessor/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec2d___getitem__(int argc, VALUE *argv, VALUE self) {
+  FXVec2d *arg1 = (FXVec2d *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2d const *","__getitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2d * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXdouble)FXVec2d___getitem__((FXVec2d const *)arg1,arg2);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec2d.[]=
+
+  call-seq:
+    []=(i, d) -> FXdouble
+
+Element setter/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec2d___setitem__(int argc, VALUE *argv, VALUE self) {
+  FXVec2d *arg1 = (FXVec2d *) 0 ;
+  FXint arg2 ;
+  FXdouble arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2d *","__setitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2d * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","__setitem__", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  result = (FXdouble)FXVec2d___setitem__(arg1,arg2,arg3);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec2d.-@
+
+  call-seq:
+    -@ -> FXVec2d
+
+Substraction operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec2d___neg__(int argc, VALUE *argv, VALUE self) {
+  FXVec2d *arg1 = (FXVec2d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec2d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2d const *","operator -", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2d * >(argp1);
+  result = FXVec2d_operator_Ss_((FXVec2d const *)arg1);
+  vresult = SWIG_NewPointerObj((new FXVec2d(static_cast< const FXVec2d& >(result))), SWIGTYPE_p_FXVec2d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec2d.+
+
+  call-seq:
+    +(other) -> FXVec2d
+
+Add operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec2d___add__(int argc, VALUE *argv, VALUE self) {
+  FXVec2d *arg1 = (FXVec2d *) 0 ;
+  FXVec2d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXVec2d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2d const *","operator +", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2d const &","operator +", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2d const &","operator +", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2d * >(argp2);
+  result = FXVec2d_operator_Sa_((FXVec2d const *)arg1,(FXVec2d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec2d(static_cast< const FXVec2d& >(result))), SWIGTYPE_p_FXVec2d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec2d.-
+
+  call-seq:
+    -(other) -> FXVec2d
+
+Substraction operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec2d___sub__(int argc, VALUE *argv, VALUE self) {
+  FXVec2d *arg1 = (FXVec2d *) 0 ;
+  FXVec2d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXVec2d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2d const *","operator -", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2d const &","operator -", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2d const &","operator -", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2d * >(argp2);
+  result = FXVec2d_operator_Ss_((FXVec2d const *)arg1,(FXVec2d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec2d(static_cast< const FXVec2d& >(result))), SWIGTYPE_p_FXVec2d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2d___mul____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXVec2d *arg1 = (FXVec2d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  FXVec2d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2d const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","operator *", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  result = FXVec2d_operator_Sm___SWIG_0((FXVec2d const *)arg1,arg2);
+  vresult = SWIG_NewPointerObj((new FXVec2d(static_cast< const FXVec2d& >(result))), SWIGTYPE_p_FXVec2d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2d___div__(int argc, VALUE *argv, VALUE self) {
+  FXVec2d *arg1 = (FXVec2d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  FXVec2d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2d const *","operator /", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","operator /", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  result = FXVec2d_operator_Sd_((FXVec2d const *)arg1,arg2);
+  vresult = SWIG_NewPointerObj((new FXVec2d(static_cast< const FXVec2d& >(result))), SWIGTYPE_p_FXVec2d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2d___mul____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXVec2d *arg1 = (FXVec2d *) 0 ;
+  FXVec2d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2d const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2d const &","operator *", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2d const &","operator *", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2d * >(argp2);
+  result = (FXdouble)FXVec2d_operator_Sm___SWIG_1((FXVec2d const *)arg1,(FXVec2d const &)*arg2);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXVec2d___mul__(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec2d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec2d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXVec2d___mul____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec2d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXVec2d___mul____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "__mul__", 
+    "    FXVec2d __mul__(FXdouble n)\n"
+    "    FXdouble __mul__(FXVec2d const &other)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2d_dot(int argc, VALUE *argv, VALUE self) {
+  FXVec2d *arg1 = (FXVec2d *) 0 ;
+  FXVec2d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2d const *","dot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2d const &","dot", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2d const &","dot", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2d * >(argp2);
+  result = (FXdouble)FXVec2d_dot((FXVec2d const *)arg1,(FXVec2d const &)*arg2);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec2d.==
+
+  call-seq:
+    ==(other) -> bool
+
+Equality comparison operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec2d___eq__(int argc, VALUE *argv, VALUE self) {
+  FXVec2d *arg1 = (FXVec2d *) 0 ;
+  FXVec2d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2d const *","operator ==", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2d const &","operator ==", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2d const &","operator ==", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2d * >(argp2);
+  result = (bool)FXVec2d_operator_Se__Se_((FXVec2d const *)arg1,(FXVec2d const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2d_normalize(int argc, VALUE *argv, VALUE self) {
+  FXVec2d *arg1 = (FXVec2d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec2d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2d const *","normalize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2d * >(argp1);
+  result = FXVec2d_normalize((FXVec2d const *)arg1);
+  vresult = SWIG_NewPointerObj((new FXVec2d(static_cast< const FXVec2d& >(result))), SWIGTYPE_p_FXVec2d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2d_lo(int argc, VALUE *argv, VALUE self) {
+  FXVec2d *arg1 = (FXVec2d *) 0 ;
+  FXVec2d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXVec2d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2d const *","lo", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2d const &","lo", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2d const &","lo", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2d * >(argp2);
+  result = FXVec2d_lo((FXVec2d const *)arg1,(FXVec2d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec2d(static_cast< const FXVec2d& >(result))), SWIGTYPE_p_FXVec2d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2d_hi(int argc, VALUE *argv, VALUE self) {
+  FXVec2d *arg1 = (FXVec2d *) 0 ;
+  FXVec2d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXVec2d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2d const *","hi", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2d const &","hi", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2d const &","hi", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2d * >(argp2);
+  result = FXVec2d_hi((FXVec2d const *)arg1,(FXVec2d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec2d(static_cast< const FXVec2d& >(result))), SWIGTYPE_p_FXVec2d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec2d_clamp(int argc, VALUE *argv, VALUE self) {
+  FXVec2d *arg1 = (FXVec2d *) 0 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  FXVec2d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec2d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2d *","clamp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec2d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","clamp", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","clamp", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  result = (FXVec2d *) &(arg1)->clamp(arg2,arg3);
+  vresult = FXRbGetRubyObj(result, "FXVec2d *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXVec3f;
+
+SWIGINTERN VALUE
+_wrap_FXVec3f_x_set(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXfloat arg2 ;
+  FXVec3f tmp1 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","x", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  if (arg1) (arg1)->x = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3f_x_get(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXVec3f tmp1 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  result = (FXfloat) ((arg1)->x);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3f_y_set(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXfloat arg2 ;
+  FXVec3f tmp1 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","y", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  if (arg1) (arg1)->y = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3f_y_get(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXVec3f tmp1 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  result = (FXfloat) ((arg1)->y);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3f_z_set(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXfloat arg2 ;
+  FXVec3f tmp1 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","z", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  if (arg1) (arg1)->z = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3f_z_get(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXVec3f tmp1 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  result = (FXfloat) ((arg1)->z);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVec3f__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXVec3f *)new_FXVec3f__SWIG_0();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVec3f__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = 0 ;
+  FXVec3f *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg1 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg1 = new FXVec3f(*p);
+    }
+  }
+  {
+    result = (FXVec3f *)new FXVec3f((FXVec3f const &)*arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  delete arg1;
+  return self;
+fail:
+  delete arg1;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVec3f__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXfloat arg1 ;
+  FXfloat arg2 ;
+  FXfloat arg3 = (FXfloat) 1.0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  FXVec3f *result = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_float(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXfloat","FXVec3f", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXfloat >(val1);
+  ecode2 = SWIG_AsVal_float(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","FXVec3f", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  if (argc > 2) {
+    ecode3 = SWIG_AsVal_float(argv[2], &val3);
+    if (!SWIG_IsOK(ecode3)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","FXVec3f", 3, argv[2] ));
+    } 
+    arg3 = static_cast< FXfloat >(val3);
+  }
+  {
+    result = (FXVec3f *)new FXVec3f(arg1,arg2,arg3);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXVec3f_allocate(VALUE self)
+#else
+_wrap_FXVec3f_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXVec3f);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVec3f__SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXColor arg1 ;
+  FXVec3f *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  arg1 = to_FXColor(argv[0]);
+  {
+    result = (FXVec3f *)new FXVec3f(arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXVec3f(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 3) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_FXVec3f__SWIG_0(nargs, args, self);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXVec3f__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      _v = (TYPE(argv[0]) == T_FIXNUM || TYPE(argv[0]) == T_BIGNUM) ? 1 : 0;
+    }
+    if (_v) {
+      return _wrap_new_FXVec3f__SWIG_3(nargs, args, self);
+    }
+  }
+  if ((argc >= 2) && (argc <= 3)) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_new_FXVec3f__SWIG_2(nargs, args, self);
+        }
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_FXVec3f__SWIG_2(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "FXVec3f.new", 
+    "    FXVec3f.new()\n"
+    "    FXVec3f.new(FXVec3f const &v)\n"
+    "    FXVec3f.new(FXfloat xx, FXfloat yy, FXfloat zz)\n"
+    "    FXVec3f.new(FXColor color)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3f_length2(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXVec3f tmp1 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  result = (FXfloat)((FXVec3f const *)arg1)->length2();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3f_length(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXVec3f tmp1 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  result = (FXfloat)((FXVec3f const *)arg1)->length();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec3f.[]
+
+  call-seq:
+    [](i) -> FXfloat
+
+Element accessor/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec3f___getitem__(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXint arg2 ;
+  FXVec3f tmp1 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  arg2 = NUM2INT(argv[0]);
+  result = (FXfloat)FXVec3f___getitem__((FXVec3f const *)arg1,arg2);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec3f.[]=
+
+  call-seq:
+    []=(i, f) -> FXfloat
+
+Element setter/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec3f___setitem__(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXint arg2 ;
+  FXfloat arg3 ;
+  FXVec3f tmp1 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  arg2 = NUM2INT(argv[0]);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","__setitem__", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  result = (FXfloat)FXVec3f___setitem__(arg1,arg2,arg3);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec3f.-@
+
+  call-seq:
+    -@ -> FXVec3f
+
+Substraction operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec3f___neg__(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXVec3f tmp1 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  result = FXVec3f_operator_Ss_((FXVec3f const *)arg1);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec3f.+
+
+  call-seq:
+    +(other) -> FXVec3f
+
+Add operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec3f___add__(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXVec3f tmp1 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  result = FXVec3f_operator_Sa_((FXVec3f const *)arg1,(FXVec3f const &)*arg2);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec3f.-
+
+  call-seq:
+    -(other) -> FXVec3f
+
+Substraction operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec3f___sub__(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXVec3f tmp1 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  result = FXVec3f_operator_Ss_((FXVec3f const *)arg1,(FXVec3f const &)*arg2);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3f___mul____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXfloat arg2 ;
+  FXVec3f tmp1 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","operator *", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  result = FXVec3f_operator_Sm___SWIG_0((FXVec3f const *)arg1,arg2);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3f___div__(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXfloat arg2 ;
+  FXVec3f tmp1 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","operator /", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  result = FXVec3f_operator_Sd_((FXVec3f const *)arg1,arg2);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3f___mul____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXVec3f tmp1 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  result = (FXfloat)FXVec3f_operator_Sm___SWIG_1((FXVec3f const *)arg1,(FXVec3f const &)*arg2);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXVec3f___mul__(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXVec3f___mul____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXVec3f___mul____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "__mul__", 
+    "    FXVec3f __mul__(FXfloat n)\n"
+    "    FXfloat __mul__(FXVec3f const &other)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3f_dot(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXVec3f tmp1 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  result = (FXfloat)FXVec3f_dot((FXVec3f const *)arg1,(FXVec3f const &)*arg2);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec3f.^
+
+  call-seq:
+    ^(other) -> FXVec3f
+
+XOR operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec3f___xor__(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXVec3f tmp1 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  result = FXVec3f_operator_Sx_((FXVec3f const *)arg1,(FXVec3f const &)*arg2);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3f_cross(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXVec3f tmp1 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  result = FXVec3f_cross((FXVec3f const *)arg1,(FXVec3f const &)*arg2);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec3f.==
+
+  call-seq:
+    ==(other) -> bool
+
+Equality comparison operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec3f___eq__(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXVec3f tmp1 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  result = (bool)FXVec3f_operator_Se__Se_((FXVec3f const *)arg1,(FXVec3f const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3f_normalize(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXVec3f tmp1 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  result = FXVec3f_normalize((FXVec3f const *)arg1);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3f_lo(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXVec3f tmp1 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  result = FXVec3f_lo((FXVec3f const *)arg1,(FXVec3f const &)*arg2);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3f_hi(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXVec3f tmp1 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  result = FXVec3f_hi((FXVec3f const *)arg1,(FXVec3f const &)*arg2);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3f_normal__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXVec3f *arg3 = 0 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg1 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg1 = new FXVec3f(*p);
+    }
+  }
+  {
+    if (TYPE(argv[1]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[1], 0)), NUM2DBL(rb_ary_entry(argv[1], 1)), NUM2DBL(rb_ary_entry(argv[1], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[1], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  {
+    if (TYPE(argv[2]) == T_ARRAY) {
+      arg3 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[2], 0)), NUM2DBL(rb_ary_entry(argv[2], 1)), NUM2DBL(rb_ary_entry(argv[2], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[2], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg3 = new FXVec3f(*p);
+    }
+  }
+  result = FXVec3f_normal__SWIG_0((FXVec3f const &)*arg1,(FXVec3f const &)*arg2,(FXVec3f const &)*arg3);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  delete arg1;
+  delete arg2;
+  delete arg3;
+  return vresult;
+fail:
+  delete arg1;
+  delete arg2;
+  delete arg3;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3f_normal__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXVec3f *arg3 = 0 ;
+  FXVec3f *arg4 = 0 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg1 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg1 = new FXVec3f(*p);
+    }
+  }
+  {
+    if (TYPE(argv[1]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[1], 0)), NUM2DBL(rb_ary_entry(argv[1], 1)), NUM2DBL(rb_ary_entry(argv[1], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[1], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  {
+    if (TYPE(argv[2]) == T_ARRAY) {
+      arg3 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[2], 0)), NUM2DBL(rb_ary_entry(argv[2], 1)), NUM2DBL(rb_ary_entry(argv[2], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[2], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg3 = new FXVec3f(*p);
+    }
+  }
+  {
+    if (TYPE(argv[3]) == T_ARRAY) {
+      arg4 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[3], 0)), NUM2DBL(rb_ary_entry(argv[3], 1)), NUM2DBL(rb_ary_entry(argv[3], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[3], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg4 = new FXVec3f(*p);
+    }
+  }
+  result = FXVec3f_normal__SWIG_1((FXVec3f const &)*arg1,(FXVec3f const &)*arg2,(FXVec3f const &)*arg3,(FXVec3f const &)*arg4);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  delete arg1;
+  delete arg2;
+  delete arg3;
+  delete arg4;
+  return vresult;
+fail:
+  delete arg1;
+  delete arg2;
+  delete arg3;
+  delete arg4;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXVec3f_normal(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 4) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXVec3f, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_FXVec3f_normal__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXVec3f, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXVec3f, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            return _wrap_FXVec3f_normal__SWIG_1(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "normal", 
+    "    FXVec3f normal(FXVec3f const &a, FXVec3f const &b, FXVec3f const &c)\n"
+    "    FXVec3f normal(FXVec3f const &a, FXVec3f const &b, FXVec3f const &c, FXVec3f const &d)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3f_clamp(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = (FXVec3f *) 0 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  FXVec3f tmp1 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  FXVec3f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec3f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec3f, 1);
+    }
+  }
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","clamp", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","clamp", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  result = (FXVec3f *) &(arg1)->clamp(arg2,arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXVec3f, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXVec3d;
+
+SWIGINTERN VALUE
+_wrap_FXVec3d_x_set(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d *","x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","x", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->x = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3d_x_get(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d *","x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  result = (FXdouble) ((arg1)->x);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3d_y_set(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d *","y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","y", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->y = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3d_y_get(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d *","y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  result = (FXdouble) ((arg1)->y);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3d_z_set(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d *","z", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","z", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->z = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3d_z_get(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d *","z", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  result = (FXdouble) ((arg1)->z);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVec3d__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXVec3d *)new_FXVec3d__SWIG_0();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVec3d__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXVec3d *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const &","FXVec3d", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","FXVec3d", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  {
+    result = (FXVec3d *)new FXVec3d((FXVec3d const &)*arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVec3d__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXdouble arg1 ;
+  FXdouble arg2 ;
+  FXdouble arg3 = (FXdouble) 1.0 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  FXVec3d *result = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXdouble","FXVec3d", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXdouble >(val1);
+  ecode2 = SWIG_AsVal_double(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","FXVec3d", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (argc > 2) {
+    ecode3 = SWIG_AsVal_double(argv[2], &val3);
+    if (!SWIG_IsOK(ecode3)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","FXVec3d", 3, argv[2] ));
+    } 
+    arg3 = static_cast< FXdouble >(val3);
+  }
+  {
+    result = (FXVec3d *)new FXVec3d(arg1,arg2,arg3);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXVec3d_allocate(VALUE self)
+#else
+_wrap_FXVec3d_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXVec3d);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVec3d__SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXColor arg1 ;
+  FXVec3d *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  arg1 = to_FXColor(argv[0]);
+  {
+    result = (FXVec3d *)new FXVec3d(arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXVec3d(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 3) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_FXVec3d__SWIG_0(nargs, args, self);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXVec3d__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      _v = (TYPE(argv[0]) == T_FIXNUM || TYPE(argv[0]) == T_BIGNUM) ? 1 : 0;
+    }
+    if (_v) {
+      return _wrap_new_FXVec3d__SWIG_3(nargs, args, self);
+    }
+  }
+  if ((argc >= 2) && (argc <= 3)) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_new_FXVec3d__SWIG_2(nargs, args, self);
+        }
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_FXVec3d__SWIG_2(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "FXVec3d.new", 
+    "    FXVec3d.new()\n"
+    "    FXVec3d.new(FXVec3d const &v)\n"
+    "    FXVec3d.new(FXdouble xx, FXdouble yy, FXdouble zz)\n"
+    "    FXVec3d.new(FXColor color)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3d_length2(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const *","length2", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  result = (FXdouble)((FXVec3d const *)arg1)->length2();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3d_length(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const *","length", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  result = (FXdouble)((FXVec3d const *)arg1)->length();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec3d.[]
+
+  call-seq:
+    [](i) -> FXdouble
+
+Element accessor/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec3d___getitem__(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const *","__getitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXdouble)FXVec3d___getitem__((FXVec3d const *)arg1,arg2);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec3d.[]=
+
+  call-seq:
+    []=(i, d) -> FXdouble
+
+Element setter/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec3d___setitem__(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  FXint arg2 ;
+  FXdouble arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d *","__setitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","__setitem__", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  result = (FXdouble)FXVec3d___setitem__(arg1,arg2,arg3);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec3d.-@
+
+  call-seq:
+    -@ -> FXVec3d
+
+Substraction operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec3d___neg__(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const *","operator -", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  result = FXVec3d_operator_Ss_((FXVec3d const *)arg1);
+  vresult = SWIG_NewPointerObj((new FXVec3d(static_cast< const FXVec3d& >(result))), SWIGTYPE_p_FXVec3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec3d.+
+
+  call-seq:
+    +(other) -> FXVec3d
+
+Add operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec3d___add__(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXVec3d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const *","operator +", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","operator +", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","operator +", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  result = FXVec3d_operator_Sa_((FXVec3d const *)arg1,(FXVec3d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec3d(static_cast< const FXVec3d& >(result))), SWIGTYPE_p_FXVec3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec3d.-
+
+  call-seq:
+    -(other) -> FXVec3d
+
+Substraction operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec3d___sub__(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXVec3d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const *","operator -", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","operator -", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","operator -", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  result = FXVec3d_operator_Ss_((FXVec3d const *)arg1,(FXVec3d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec3d(static_cast< const FXVec3d& >(result))), SWIGTYPE_p_FXVec3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3d___mul____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  SwigValueWrapper< FXVec3d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","operator *", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  result = FXVec3d_operator_Sm___SWIG_0((FXVec3d const *)arg1,arg2);
+  vresult = SWIG_NewPointerObj((new FXVec3d(static_cast< const FXVec3d& >(result))), SWIGTYPE_p_FXVec3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3d___div__(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  SwigValueWrapper< FXVec3d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const *","operator /", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","operator /", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  result = FXVec3d_operator_Sd_((FXVec3d const *)arg1,arg2);
+  vresult = SWIG_NewPointerObj((new FXVec3d(static_cast< const FXVec3d& >(result))), SWIGTYPE_p_FXVec3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3d___mul____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","operator *", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","operator *", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  result = (FXdouble)FXVec3d_operator_Sm___SWIG_1((FXVec3d const *)arg1,(FXVec3d const &)*arg2);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXVec3d___mul__(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXVec3d___mul____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXVec3d___mul____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "__mul__", 
+    "    FXVec3d __mul__(FXdouble n)\n"
+    "    FXdouble __mul__(FXVec3d const &other)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3d_dot(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const *","dot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","dot", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","dot", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  result = (FXdouble)FXVec3d_dot((FXVec3d const *)arg1,(FXVec3d const &)*arg2);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec3d.^
+
+  call-seq:
+    ^(other) -> FXVec3d
+
+XOR operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec3d___xor__(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXVec3d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const *","operator ^", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","operator ^", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","operator ^", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  result = FXVec3d_operator_Sx_((FXVec3d const *)arg1,(FXVec3d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec3d(static_cast< const FXVec3d& >(result))), SWIGTYPE_p_FXVec3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3d_cross(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXVec3d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const *","cross", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","cross", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","cross", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  result = FXVec3d_cross((FXVec3d const *)arg1,(FXVec3d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec3d(static_cast< const FXVec3d& >(result))), SWIGTYPE_p_FXVec3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec3d.==
+
+  call-seq:
+    ==(other) -> bool
+
+Equality comparison operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec3d___eq__(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const *","operator ==", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","operator ==", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","operator ==", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  result = (bool)FXVec3d_operator_Se__Se_((FXVec3d const *)arg1,(FXVec3d const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3d_normalize(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const *","normalize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  result = FXVec3d_normalize((FXVec3d const *)arg1);
+  vresult = SWIG_NewPointerObj((new FXVec3d(static_cast< const FXVec3d& >(result))), SWIGTYPE_p_FXVec3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3d_lo(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXVec3d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const *","lo", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","lo", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","lo", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  result = FXVec3d_lo((FXVec3d const *)arg1,(FXVec3d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec3d(static_cast< const FXVec3d& >(result))), SWIGTYPE_p_FXVec3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3d_hi(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXVec3d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const *","hi", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","hi", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","hi", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  result = FXVec3d_hi((FXVec3d const *)arg1,(FXVec3d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec3d(static_cast< const FXVec3d& >(result))), SWIGTYPE_p_FXVec3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3d_normal__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = 0 ;
+  FXVec3d *arg2 = 0 ;
+  FXVec3d *arg3 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  SwigValueWrapper< FXVec3d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const &","FXVec3d_normal__SWIG_0", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","FXVec3d_normal__SWIG_0", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","FXVec3d_normal__SWIG_0", 2, argv[1] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","FXVec3d_normal__SWIG_0", 2, argv[1])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXVec3d const &","FXVec3d_normal__SWIG_0", 3, argv[2] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","FXVec3d_normal__SWIG_0", 3, argv[2])); 
+  }
+  arg3 = reinterpret_cast< FXVec3d * >(argp3);
+  result = FXVec3d_normal__SWIG_0((FXVec3d const &)*arg1,(FXVec3d const &)*arg2,(FXVec3d const &)*arg3);
+  vresult = SWIG_NewPointerObj((new FXVec3d(static_cast< const FXVec3d& >(result))), SWIGTYPE_p_FXVec3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3d_normal__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = 0 ;
+  FXVec3d *arg2 = 0 ;
+  FXVec3d *arg3 = 0 ;
+  FXVec3d *arg4 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  void *argp4 ;
+  int res4 = 0 ;
+  SwigValueWrapper< FXVec3d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const &","FXVec3d_normal__SWIG_1", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","FXVec3d_normal__SWIG_1", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","FXVec3d_normal__SWIG_1", 2, argv[1] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","FXVec3d_normal__SWIG_1", 2, argv[1])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXVec3d const &","FXVec3d_normal__SWIG_1", 3, argv[2] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","FXVec3d_normal__SWIG_1", 3, argv[2])); 
+  }
+  arg3 = reinterpret_cast< FXVec3d * >(argp3);
+  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXVec3d const &","FXVec3d_normal__SWIG_1", 4, argv[3] )); 
+  }
+  if (!argp4) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","FXVec3d_normal__SWIG_1", 4, argv[3])); 
+  }
+  arg4 = reinterpret_cast< FXVec3d * >(argp4);
+  result = FXVec3d_normal__SWIG_1((FXVec3d const &)*arg1,(FXVec3d const &)*arg2,(FXVec3d const &)*arg3,(FXVec3d const &)*arg4);
+  vresult = SWIG_NewPointerObj((new FXVec3d(static_cast< const FXVec3d& >(result))), SWIGTYPE_p_FXVec3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXVec3d_normal(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 4) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXVec3d, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_FXVec3d_normal__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXVec3d, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXVec3d, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            return _wrap_FXVec3d_normal__SWIG_1(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "normal", 
+    "    FXVec3d normal(FXVec3d const &a, FXVec3d const &b, FXVec3d const &c)\n"
+    "    FXVec3d normal(FXVec3d const &a, FXVec3d const &b, FXVec3d const &c, FXVec3d const &d)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec3d_clamp(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = (FXVec3d *) 0 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  FXVec3d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d *","clamp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","clamp", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","clamp", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  result = (FXVec3d *) &(arg1)->clamp(arg2,arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXVec3d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXVec4f;
+
+SWIGINTERN VALUE
+_wrap_FXVec4f_x_set(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXfloat arg2 ;
+  FXVec4f tmp1 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","x", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  if (arg1) (arg1)->x = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f_x_get(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXVec4f tmp1 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  result = (FXfloat) ((arg1)->x);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f_y_set(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXfloat arg2 ;
+  FXVec4f tmp1 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","y", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  if (arg1) (arg1)->y = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f_y_get(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXVec4f tmp1 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  result = (FXfloat) ((arg1)->y);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f_z_set(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXfloat arg2 ;
+  FXVec4f tmp1 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","z", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  if (arg1) (arg1)->z = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f_z_get(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXVec4f tmp1 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  result = (FXfloat) ((arg1)->z);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f_w_set(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXfloat arg2 ;
+  FXVec4f tmp1 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","w", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  if (arg1) (arg1)->w = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f_w_get(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXVec4f tmp1 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  result = (FXfloat) ((arg1)->w);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVec4f__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXVec4f *)new_FXVec4f__SWIG_0();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVec4f__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = 0 ;
+  FXVec4f *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg1 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg1 = new FXVec4f(*p);
+    }
+  }
+  {
+    result = (FXVec4f *)new FXVec4f((FXVec4f const &)*arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  delete arg1;
+  return self;
+fail:
+  delete arg1;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVec4f__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = 0 ;
+  FXfloat arg2 = (FXfloat) 1.0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  FXVec4f *result = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg1 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg1 = new FXVec3f(*p);
+    }
+  }
+  if (argc > 1) {
+    ecode2 = SWIG_AsVal_float(argv[1], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","FXVec4f", 2, argv[1] ));
+    } 
+    arg2 = static_cast< FXfloat >(val2);
+  }
+  {
+    result = (FXVec4f *)new FXVec4f((FXVec3f const &)*arg1,arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  delete arg1;
+  return self;
+fail:
+  delete arg1;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVec4f__SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXfloat arg1 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  FXfloat arg4 = (FXfloat) 1.0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  FXVec4f *result = 0 ;
+  
+  if ((argc < 3) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_float(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXfloat","FXVec4f", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXfloat >(val1);
+  ecode2 = SWIG_AsVal_float(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","FXVec4f", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","FXVec4f", 3, argv[2] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  if (argc > 3) {
+    ecode4 = SWIG_AsVal_float(argv[3], &val4);
+    if (!SWIG_IsOK(ecode4)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","FXVec4f", 4, argv[3] ));
+    } 
+    arg4 = static_cast< FXfloat >(val4);
+  }
+  {
+    result = (FXVec4f *)new FXVec4f(arg1,arg2,arg3,arg4);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXVec4f_allocate(VALUE self)
+#else
+_wrap_FXVec4f_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXVec4f);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVec4f__SWIG_4(int argc, VALUE *argv, VALUE self) {
+  FXColor arg1 ;
+  FXVec4f *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  arg1 = to_FXColor(argv[0]);
+  {
+    result = (FXVec4f *)new FXVec4f(arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXVec4f(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 4) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_FXVec4f__SWIG_0(nargs, args, self);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXVec4f__SWIG_1(nargs, args, self);
+    }
+  }
+  if ((argc >= 1) && (argc <= 2)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      if (argc <= 1) {
+        return _wrap_new_FXVec4f__SWIG_2(nargs, args, self);
+      }
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_FXVec4f__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      _v = (TYPE(argv[0]) == T_FIXNUM || TYPE(argv[0]) == T_BIGNUM) ? 1 : 0;
+    }
+    if (_v) {
+      return _wrap_new_FXVec4f__SWIG_4(nargs, args, self);
+    }
+  }
+  if ((argc >= 3) && (argc <= 4)) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXVec4f__SWIG_3(nargs, args, self);
+          }
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_new_FXVec4f__SWIG_3(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXVec4f.new", 
+    "    FXVec4f.new()\n"
+    "    FXVec4f.new(FXVec4f const &w)\n"
+    "    FXVec4f.new(FXVec3f const &w, FXfloat ww)\n"
+    "    FXVec4f.new(FXfloat x, FXfloat y, FXfloat z, FXfloat w)\n"
+    "    FXVec4f.new(FXColor color)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f_distance(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXVec4f tmp1 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  result = (FXfloat)((FXVec4f const *)arg1)->distance((FXVec3f const &)*arg2);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f_crossesq___(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXVec3f *arg3 = 0 ;
+  FXVec4f tmp1 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  {
+    if (TYPE(argv[1]) == T_ARRAY) {
+      arg3 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[1], 0)), NUM2DBL(rb_ary_entry(argv[1], 1)), NUM2DBL(rb_ary_entry(argv[1], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[1], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg3 = new FXVec3f(*p);
+    }
+  }
+  result = (bool)((FXVec4f const *)arg1)->crosses((FXVec3f const &)*arg2,(FXVec3f const &)*arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  delete arg2;
+  delete arg3;
+  return vresult;
+fail:
+  delete arg2;
+  delete arg3;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f_length(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXVec4f tmp1 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  result = (FXfloat)((FXVec4f const *)arg1)->length();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f_length2(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXVec4f tmp1 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  result = (FXfloat)((FXVec4f const *)arg1)->length2();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec4f.[]
+
+  call-seq:
+    [](i) -> FXfloat
+
+Element accessor/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec4f___getitem__(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXint arg2 ;
+  FXVec4f tmp1 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  arg2 = NUM2INT(argv[0]);
+  result = (FXfloat)FXVec4f___getitem__((FXVec4f const *)arg1,arg2);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec4f.[]=
+
+  call-seq:
+    []=(i, f) -> FXfloat
+
+Element setter/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec4f___setitem__(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXint arg2 ;
+  FXfloat arg3 ;
+  FXVec4f tmp1 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  arg2 = NUM2INT(argv[0]);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","__setitem__", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  result = (FXfloat)FXVec4f___setitem__(arg1,arg2,arg3);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec4f.-@
+
+  call-seq:
+    -@ -> FXVec4f
+
+Substraction operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec4f___neg__(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXVec4f tmp1 ;
+  SwigValueWrapper< FXVec4f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  result = FXVec4f_operator_Ss_((FXVec4f const *)arg1);
+  {
+    FXVec4f* resultptr = new FXVec4f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec4f.+
+
+  call-seq:
+    +(b) -> FXVec4f
+
+Add operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec4f___add__(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXVec4f *arg2 = 0 ;
+  FXVec4f tmp1 ;
+  SwigValueWrapper< FXVec4f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg2 = new FXVec4f(*p);
+    }
+  }
+  result = FXVec4f_operator_Sa_((FXVec4f const *)arg1,(FXVec4f const &)*arg2);
+  {
+    FXVec4f* resultptr = new FXVec4f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec4f.-
+
+  call-seq:
+    -(b) -> FXVec4f
+
+Substraction operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec4f___sub__(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXVec4f *arg2 = 0 ;
+  FXVec4f tmp1 ;
+  SwigValueWrapper< FXVec4f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg2 = new FXVec4f(*p);
+    }
+  }
+  result = FXVec4f_operator_Ss_((FXVec4f const *)arg1,(FXVec4f const &)*arg2);
+  {
+    FXVec4f* resultptr = new FXVec4f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f___mul____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXfloat arg2 ;
+  FXVec4f tmp1 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  SwigValueWrapper< FXVec4f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","operator *", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  result = FXVec4f_operator_Sm___SWIG_0((FXVec4f const *)arg1,arg2);
+  {
+    FXVec4f* resultptr = new FXVec4f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f___div__(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXfloat arg2 ;
+  FXVec4f tmp1 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  SwigValueWrapper< FXVec4f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","operator /", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  result = FXVec4f_operator_Sd_((FXVec4f const *)arg1,arg2);
+  {
+    FXVec4f* resultptr = new FXVec4f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f___mul____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXVec4f *arg2 = 0 ;
+  FXVec4f tmp1 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg2 = new FXVec4f(*p);
+    }
+  }
+  result = (FXfloat)FXVec4f_operator_Sm___SWIG_1((FXVec4f const *)arg1,(FXVec4f const &)*arg2);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXVec4f___mul__(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec4f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXVec4f___mul____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXVec4f___mul____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "__mul__", 
+    "    FXVec4f __mul__(FXfloat n)\n"
+    "    FXfloat __mul__(FXVec4f const &a)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f_dot(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXVec4f *arg2 = 0 ;
+  FXVec4f tmp1 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg2 = new FXVec4f(*p);
+    }
+  }
+  result = (FXfloat)FXVec4f_dot((FXVec4f const *)arg1,(FXVec4f const &)*arg2);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec4f.==
+
+  call-seq:
+    ==(b) -> bool
+    ==(n) -> bool
+
+Equality comparison operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec4f___eq____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXVec4f *arg2 = 0 ;
+  FXVec4f tmp1 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg2 = new FXVec4f(*p);
+    }
+  }
+  result = (bool)FXVec4f_operator_Se__Se___SWIG_0((FXVec4f const *)arg1,(FXVec4f const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f___eq____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXfloat arg2 ;
+  FXVec4f tmp1 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","operator ==", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  result = (bool)FXVec4f_operator_Se__Se___SWIG_1((FXVec4f const *)arg1,arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXVec4f___eq__(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec4f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXVec4f___eq____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXVec4f___eq____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "__eq__", 
+    "    bool __eq__(FXVec4f const &b)\n"
+    "    bool __eq__(FXfloat n)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f_normalize(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXVec4f tmp1 ;
+  SwigValueWrapper< FXVec4f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  result = FXVec4f_normalize((FXVec4f const *)arg1);
+  {
+    FXVec4f* resultptr = new FXVec4f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f_lo(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXVec4f *arg2 = 0 ;
+  FXVec4f tmp1 ;
+  SwigValueWrapper< FXVec4f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg2 = new FXVec4f(*p);
+    }
+  }
+  result = FXVec4f_lo((FXVec4f const *)arg1,(FXVec4f const &)*arg2);
+  {
+    FXVec4f* resultptr = new FXVec4f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f_hi(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXVec4f *arg2 = 0 ;
+  FXVec4f tmp1 ;
+  SwigValueWrapper< FXVec4f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg2 = new FXVec4f(*p);
+    }
+  }
+  result = FXVec4f_hi((FXVec4f const *)arg1,(FXVec4f const &)*arg2);
+  {
+    FXVec4f* resultptr = new FXVec4f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f_plane__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = 0 ;
+  SwigValueWrapper< FXVec4f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg1 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg1 = new FXVec4f(*p);
+    }
+  }
+  result = FXVec4f_plane__SWIG_0((FXVec4f const &)*arg1);
+  {
+    FXVec4f* resultptr = new FXVec4f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  delete arg1;
+  return vresult;
+fail:
+  delete arg1;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f_plane__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = 0 ;
+  FXfloat arg2 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  SwigValueWrapper< FXVec4f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg1 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg1 = new FXVec3f(*p);
+    }
+  }
+  ecode2 = SWIG_AsVal_float(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","FXVec4f_plane__SWIG_1", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  result = FXVec4f_plane__SWIG_1((FXVec3f const &)*arg1,arg2);
+  {
+    FXVec4f* resultptr = new FXVec4f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  delete arg1;
+  return vresult;
+fail:
+  delete arg1;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f_plane__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = 0 ;
+  FXVec3f *arg2 = 0 ;
+  SwigValueWrapper< FXVec4f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg1 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg1 = new FXVec3f(*p);
+    }
+  }
+  {
+    if (TYPE(argv[1]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[1], 0)), NUM2DBL(rb_ary_entry(argv[1], 1)), NUM2DBL(rb_ary_entry(argv[1], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[1], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  result = FXVec4f_plane__SWIG_2((FXVec3f const &)*arg1,(FXVec3f const &)*arg2);
+  {
+    FXVec4f* resultptr = new FXVec4f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  delete arg1;
+  delete arg2;
+  return vresult;
+fail:
+  delete arg1;
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f_plane__SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXVec3f *arg3 = 0 ;
+  SwigValueWrapper< FXVec4f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg1 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg1 = new FXVec3f(*p);
+    }
+  }
+  {
+    if (TYPE(argv[1]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[1], 0)), NUM2DBL(rb_ary_entry(argv[1], 1)), NUM2DBL(rb_ary_entry(argv[1], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[1], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  {
+    if (TYPE(argv[2]) == T_ARRAY) {
+      arg3 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[2], 0)), NUM2DBL(rb_ary_entry(argv[2], 1)), NUM2DBL(rb_ary_entry(argv[2], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[2], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg3 = new FXVec3f(*p);
+    }
+  }
+  result = FXVec4f_plane__SWIG_3((FXVec3f const &)*arg1,(FXVec3f const &)*arg2,(FXVec3f const &)*arg3);
+  {
+    FXVec4f* resultptr = new FXVec4f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  delete arg1;
+  delete arg2;
+  delete arg3;
+  return vresult;
+fail:
+  delete arg1;
+  delete arg2;
+  delete arg3;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXVec4f_plane(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 3) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXVec4f_plane__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXVec4f_plane__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXVec4f_plane__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXVec3f, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_FXVec4f_plane__SWIG_3(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "plane", 
+    "    FXVec4f plane(FXVec4f const &vec)\n"
+    "    FXVec4f plane(FXVec3f const &vec, FXfloat dist)\n"
+    "    FXVec4f plane(FXVec3f const &vec, FXVec3f const &p)\n"
+    "    FXVec4f plane(FXVec3f const &a, FXVec3f const &b, FXVec3f const &c)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4f_clamp(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = (FXVec4f *) 0 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  FXVec4f tmp1 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  FXVec4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(self) == T_ARRAY) {
+      tmp1 = FXVec4f(NUM2DBL(rb_ary_entry(self, 0)), NUM2DBL(rb_ary_entry(self, 1)), NUM2DBL(rb_ary_entry(self, 2)), NUM2DBL(rb_ary_entry(self, 3)));
+      arg1 = &tmp1;
+    } else {
+      SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FXVec4f, 1);
+    }
+  }
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","clamp", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","clamp", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  result = (FXVec4f *) &(arg1)->clamp(arg2,arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXVec4f, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXVec4d;
+
+SWIGINTERN VALUE
+_wrap_FXVec4d_x_set(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d *","x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","x", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->x = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4d_x_get(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d *","x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  result = (FXdouble) ((arg1)->x);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4d_y_set(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d *","y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","y", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->y = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4d_y_get(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d *","y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  result = (FXdouble) ((arg1)->y);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4d_z_set(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d *","z", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","z", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->z = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4d_z_get(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d *","z", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  result = (FXdouble) ((arg1)->z);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4d_w_set(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d *","w", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","w", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->w = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4d_w_get(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d *","w", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  result = (FXdouble) ((arg1)->w);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVec4d__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXVec4d *)new_FXVec4d__SWIG_0();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVec4d__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXVec4d *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXVec4d,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d const &","FXVec4d", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec4d const &","FXVec4d", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  {
+    result = (FXVec4d *)new FXVec4d((FXVec4d const &)*arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVec4d__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = 0 ;
+  FXdouble arg2 = (FXdouble) 1.0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  FXVec4d *result = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const &","FXVec4d", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","FXVec4d", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  if (argc > 1) {
+    ecode2 = SWIG_AsVal_double(argv[1], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","FXVec4d", 2, argv[1] ));
+    } 
+    arg2 = static_cast< FXdouble >(val2);
+  }
+  {
+    result = (FXVec4d *)new FXVec4d((FXVec3d const &)*arg1,arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVec4d__SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXdouble arg1 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  FXdouble arg4 = (FXdouble) 1.0 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  FXVec4d *result = 0 ;
+  
+  if ((argc < 3) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXdouble","FXVec4d", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXdouble >(val1);
+  ecode2 = SWIG_AsVal_double(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","FXVec4d", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","FXVec4d", 3, argv[2] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  if (argc > 3) {
+    ecode4 = SWIG_AsVal_double(argv[3], &val4);
+    if (!SWIG_IsOK(ecode4)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","FXVec4d", 4, argv[3] ));
+    } 
+    arg4 = static_cast< FXdouble >(val4);
+  }
+  {
+    result = (FXVec4d *)new FXVec4d(arg1,arg2,arg3,arg4);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXVec4d_allocate(VALUE self)
+#else
+_wrap_FXVec4d_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXVec4d);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVec4d__SWIG_4(int argc, VALUE *argv, VALUE self) {
+  FXColor arg1 ;
+  FXVec4d *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  arg1 = to_FXColor(argv[0]);
+  {
+    result = (FXVec4d *)new FXVec4d(arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXVec4d(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 4) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_FXVec4d__SWIG_0(nargs, args, self);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXVec4d__SWIG_1(nargs, args, self);
+    }
+  }
+  if ((argc >= 1) && (argc <= 2)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      if (argc <= 1) {
+        return _wrap_new_FXVec4d__SWIG_2(nargs, args, self);
+      }
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_FXVec4d__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      _v = (TYPE(argv[0]) == T_FIXNUM || TYPE(argv[0]) == T_BIGNUM) ? 1 : 0;
+    }
+    if (_v) {
+      return _wrap_new_FXVec4d__SWIG_4(nargs, args, self);
+    }
+  }
+  if ((argc >= 3) && (argc <= 4)) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXVec4d__SWIG_3(nargs, args, self);
+          }
+          {
+            int res = SWIG_AsVal_double(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_new_FXVec4d__SWIG_3(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXVec4d.new", 
+    "    FXVec4d.new()\n"
+    "    FXVec4d.new(FXVec4d const &v)\n"
+    "    FXVec4d.new(FXVec3d const &v, FXdouble ww)\n"
+    "    FXVec4d.new(FXdouble xx, FXdouble yy, FXdouble zz, FXdouble ww)\n"
+    "    FXVec4d.new(FXColor color)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4d_distance(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d const *","distance", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","distance", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","distance", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  result = (FXdouble)((FXVec4d const *)arg1)->distance((FXVec3d const &)*arg2);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4d_crossesq___(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  FXVec3d *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d const *","crosses", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","crosses", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","crosses", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXVec3d const &","crosses", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","crosses", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXVec3d * >(argp3);
+  result = (bool)((FXVec4d const *)arg1)->crosses((FXVec3d const &)*arg2,(FXVec3d const &)*arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4d_length2(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d const *","length2", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  result = (FXdouble)((FXVec4d const *)arg1)->length2();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4d_length(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d const *","length", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  result = (FXdouble)((FXVec4d const *)arg1)->length();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec4d.[]
+
+  call-seq:
+    [](i) -> FXdouble
+
+Element accessor/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec4d___getitem__(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d const *","__getitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXdouble)FXVec4d___getitem__((FXVec4d const *)arg1,arg2);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec4d.[]=
+
+  call-seq:
+    []=(i, d) -> FXdouble
+
+Element setter/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec4d___setitem__(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  FXint arg2 ;
+  FXdouble arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d *","__setitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","__setitem__", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  result = (FXdouble)FXVec4d___setitem__(arg1,arg2,arg3);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec4d.-@
+
+  call-seq:
+    -@ -> FXVec4d
+
+Substraction operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec4d___neg__(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec4d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d const *","operator -", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  result = FXVec4d_operator_Ss_((FXVec4d const *)arg1);
+  vresult = SWIG_NewPointerObj((new FXVec4d(static_cast< const FXVec4d& >(result))), SWIGTYPE_p_FXVec4d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec4d.+
+
+  call-seq:
+    +(other) -> FXVec4d
+
+Add operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec4d___add__(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  FXVec4d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXVec4d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d const *","operator +", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec4d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec4d const &","operator +", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec4d const &","operator +", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec4d * >(argp2);
+  result = FXVec4d_operator_Sa_((FXVec4d const *)arg1,(FXVec4d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec4d(static_cast< const FXVec4d& >(result))), SWIGTYPE_p_FXVec4d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec4d.-
+
+  call-seq:
+    -(other) -> FXVec4d
+
+Substraction operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec4d___sub__(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  FXVec4d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXVec4d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d const *","operator -", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec4d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec4d const &","operator -", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec4d const &","operator -", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec4d * >(argp2);
+  result = FXVec4d_operator_Ss_((FXVec4d const *)arg1,(FXVec4d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec4d(static_cast< const FXVec4d& >(result))), SWIGTYPE_p_FXVec4d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4d___mul____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  SwigValueWrapper< FXVec4d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","operator *", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  result = FXVec4d_operator_Sm___SWIG_0((FXVec4d const *)arg1,arg2);
+  vresult = SWIG_NewPointerObj((new FXVec4d(static_cast< const FXVec4d& >(result))), SWIGTYPE_p_FXVec4d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4d___div__(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  SwigValueWrapper< FXVec4d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d const *","operator /", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","operator /", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  result = FXVec4d_operator_Sd_((FXVec4d const *)arg1,arg2);
+  vresult = SWIG_NewPointerObj((new FXVec4d(static_cast< const FXVec4d& >(result))), SWIGTYPE_p_FXVec4d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4d___mul____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  FXVec4d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec4d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec4d const &","operator *", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec4d const &","operator *", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec4d * >(argp2);
+  result = (FXdouble)FXVec4d_operator_Sm___SWIG_1((FXVec4d const *)arg1,(FXVec4d const &)*arg2);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXVec4d___mul__(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec4d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXVec4d___mul____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXVec4d___mul____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "__mul__", 
+    "    FXVec4d __mul__(FXdouble n)\n"
+    "    FXdouble __mul__(FXVec4d const &other)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4d_dot(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  FXVec4d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d const *","dot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec4d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec4d const &","dot", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec4d const &","dot", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec4d * >(argp2);
+  result = (FXdouble)FXVec4d_dot((FXVec4d const *)arg1,(FXVec4d const &)*arg2);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXVec4d.==
+
+  call-seq:
+    ==(other) -> bool
+
+Equality comparison operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXVec4d___eq__(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  FXVec4d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d const *","operator ==", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec4d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec4d const &","operator ==", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec4d const &","operator ==", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec4d * >(argp2);
+  result = (bool)FXVec4d_operator_Se__Se_((FXVec4d const *)arg1,(FXVec4d const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4d_normalize(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec4d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d const *","normalize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  result = FXVec4d_normalize((FXVec4d const *)arg1);
+  vresult = SWIG_NewPointerObj((new FXVec4d(static_cast< const FXVec4d& >(result))), SWIGTYPE_p_FXVec4d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4d_lo(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  FXVec4d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXVec4d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d const *","lo", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec4d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec4d const &","lo", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec4d const &","lo", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec4d * >(argp2);
+  result = FXVec4d_lo((FXVec4d const *)arg1,(FXVec4d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec4d(static_cast< const FXVec4d& >(result))), SWIGTYPE_p_FXVec4d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4d_hi(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  FXVec4d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXVec4d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d const *","hi", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec4d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec4d const &","hi", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec4d const &","hi", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec4d * >(argp2);
+  result = FXVec4d_hi((FXVec4d const *)arg1,(FXVec4d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec4d(static_cast< const FXVec4d& >(result))), SWIGTYPE_p_FXVec4d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4d_plane__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec4d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXVec4d,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d const &","FXVec4d_plane__SWIG_0", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec4d const &","FXVec4d_plane__SWIG_0", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  result = FXVec4d_plane__SWIG_0((FXVec4d const &)*arg1);
+  vresult = SWIG_NewPointerObj((new FXVec4d(static_cast< const FXVec4d& >(result))), SWIGTYPE_p_FXVec4d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4d_plane__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = 0 ;
+  FXdouble arg2 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  SwigValueWrapper< FXVec4d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const &","FXVec4d_plane__SWIG_1", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","FXVec4d_plane__SWIG_1", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","FXVec4d_plane__SWIG_1", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  result = FXVec4d_plane__SWIG_1((FXVec3d const &)*arg1,arg2);
+  vresult = SWIG_NewPointerObj((new FXVec4d(static_cast< const FXVec4d& >(result))), SWIGTYPE_p_FXVec4d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4d_plane__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXVec4d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const &","FXVec4d_plane__SWIG_2", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","FXVec4d_plane__SWIG_2", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","FXVec4d_plane__SWIG_2", 2, argv[1] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","FXVec4d_plane__SWIG_2", 2, argv[1])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  result = FXVec4d_plane__SWIG_2((FXVec3d const &)*arg1,(FXVec3d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec4d(static_cast< const FXVec4d& >(result))), SWIGTYPE_p_FXVec4d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4d_plane__SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = 0 ;
+  FXVec3d *arg2 = 0 ;
+  FXVec3d *arg3 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  SwigValueWrapper< FXVec4d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const &","FXVec4d_plane__SWIG_3", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","FXVec4d_plane__SWIG_3", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","FXVec4d_plane__SWIG_3", 2, argv[1] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","FXVec4d_plane__SWIG_3", 2, argv[1])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXVec3d const &","FXVec4d_plane__SWIG_3", 3, argv[2] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","FXVec4d_plane__SWIG_3", 3, argv[2])); 
+  }
+  arg3 = reinterpret_cast< FXVec3d * >(argp3);
+  result = FXVec4d_plane__SWIG_3((FXVec3d const &)*arg1,(FXVec3d const &)*arg2,(FXVec3d const &)*arg3);
+  vresult = SWIG_NewPointerObj((new FXVec4d(static_cast< const FXVec4d& >(result))), SWIGTYPE_p_FXVec4d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXVec4d_plane(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 3) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXVec4d_plane__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXVec4d_plane__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXVec4d_plane__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXVec3d, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_FXVec4d_plane__SWIG_3(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "plane", 
+    "    FXVec4d plane(FXVec4d const &vec)\n"
+    "    FXVec4d plane(FXVec3d const &vec, FXdouble dist)\n"
+    "    FXVec4d plane(FXVec3d const &vec, FXVec3d const &p)\n"
+    "    FXVec4d plane(FXVec3d const &a, FXVec3d const &b, FXVec3d const &c)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVec4d_clamp(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = (FXVec4d *) 0 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  FXVec4d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVec4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d *","clamp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","clamp", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","clamp", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  result = (FXVec4d *) &(arg1)->clamp(arg2,arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXVec4d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXQuatf;
+
+SWIGINTERN VALUE
+_wrap_new_FXQuatf__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXQuatf *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXQuatf *)new FXQuatf();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXQuatf__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = 0 ;
+  FXfloat arg2 = (FXfloat) 0.0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  FXQuatf *result = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg1 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg1 = new FXVec3f(*p);
+    }
+  }
+  if (argc > 1) {
+    ecode2 = SWIG_AsVal_float(argv[1], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","FXQuatf", 2, argv[1] ));
+    } 
+    arg2 = static_cast< FXfloat >(val2);
+  }
+  {
+    result = (FXQuatf *)new FXQuatf((FXVec3f const &)*arg1,arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  delete arg1;
+  return self;
+fail:
+  delete arg1;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXQuatf__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXfloat arg1 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  FXQuatf *result = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_float(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXfloat","FXQuatf", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXfloat >(val1);
+  ecode2 = SWIG_AsVal_float(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","FXQuatf", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","FXQuatf", 3, argv[2] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  {
+    result = (FXQuatf *)new FXQuatf(arg1,arg2,arg3);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXQuatf__SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXVec3f *arg3 = 0 ;
+  FXQuatf *result = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg1 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg1 = new FXVec3f(*p);
+    }
+  }
+  {
+    if (TYPE(argv[1]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[1], 0)), NUM2DBL(rb_ary_entry(argv[1], 1)), NUM2DBL(rb_ary_entry(argv[1], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[1], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  {
+    if (TYPE(argv[2]) == T_ARRAY) {
+      arg3 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[2], 0)), NUM2DBL(rb_ary_entry(argv[2], 1)), NUM2DBL(rb_ary_entry(argv[2], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[2], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg3 = new FXVec3f(*p);
+    }
+  }
+  {
+    result = (FXQuatf *)new FXQuatf((FXVec3f const &)*arg1,(FXVec3f const &)*arg2,(FXVec3f const &)*arg3);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  delete arg1;
+  delete arg2;
+  delete arg3;
+  return self;
+fail:
+  delete arg1;
+  delete arg2;
+  delete arg3;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXQuatf__SWIG_4(int argc, VALUE *argv, VALUE self) {
+  FXMat3f *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXQuatf *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXMat3f,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3f const &","FXQuatf", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMat3f const &","FXQuatf", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXMat3f * >(argp1);
+  {
+    result = (FXQuatf *)new FXQuatf((FXMat3f const &)*arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXQuatf_allocate(VALUE self)
+#else
+_wrap_FXQuatf_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXQuatf);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXQuatf__SWIG_5(int argc, VALUE *argv, VALUE self) {
+  FXfloat arg1 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  FXfloat arg4 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  FXQuatf *result = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_float(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXfloat","FXQuatf", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXfloat >(val1);
+  ecode2 = SWIG_AsVal_float(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","FXQuatf", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","FXQuatf", 3, argv[2] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  ecode4 = SWIG_AsVal_float(argv[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","FXQuatf", 4, argv[3] ));
+  } 
+  arg4 = static_cast< FXfloat >(val4);
+  {
+    result = (FXQuatf *)new FXQuatf(arg1,arg2,arg3,arg4);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXQuatf(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 4) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_FXQuatf__SWIG_0(nargs, args, self);
+  }
+  if ((argc >= 1) && (argc <= 2)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      if (argc <= 1) {
+        return _wrap_new_FXQuatf__SWIG_1(nargs, args, self);
+      }
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_FXQuatf__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat3f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXQuatf__SWIG_4(nargs, args, self);
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXVec3f, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_new_FXQuatf__SWIG_3(nargs, args, self);
+        }
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_FXQuatf__SWIG_2(nargs, args, self);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_new_FXQuatf__SWIG_5(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXQuatf.new", 
+    "    FXQuatf.new()\n"
+    "    FXQuatf.new(FXVec3f const &axis, FXfloat phi)\n"
+    "    FXQuatf.new(FXfloat roll, FXfloat pitch, FXfloat yaw)\n"
+    "    FXQuatf.new(FXVec3f const &ex, FXVec3f const &ey, FXVec3f const &ez)\n"
+    "    FXQuatf.new(FXMat3f const &mat)\n"
+    "    FXQuatf.new(FXfloat x, FXfloat y, FXfloat z, FXfloat w)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatf_adjustN___(int argc, VALUE *argv, VALUE self) {
+  FXQuatf *arg1 = (FXQuatf *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXQuatf *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatf *","adjust", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatf * >(argp1);
+  result = (FXQuatf *) &(arg1)->adjust();
+  vresult = FXRbGetRubyObj(result, "FXQuatf *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatf_setAxisAngle(int argc, VALUE *argv, VALUE self) {
+  FXQuatf *arg1 = (FXQuatf *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXfloat arg3 = (FXfloat) 0.0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatf *","setAxisAngle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatf * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  if (argc > 1) {
+    ecode3 = SWIG_AsVal_float(argv[1], &val3);
+    if (!SWIG_IsOK(ecode3)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","setAxisAngle", 3, argv[1] ));
+    } 
+    arg3 = static_cast< FXfloat >(val3);
+  }
+  (arg1)->setAxisAngle((FXVec3f const &)*arg2,arg3);
+  delete arg2;
+  return Qnil;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatf_getAxisAngle(int argc, VALUE *argv, VALUE self) {
+  FXQuatf *arg1 = (FXQuatf *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatf const *","getAxisAngle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatf * >(argp1);
+  result = (VALUE)FXQuatf_getAxisAngle((FXQuatf const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatf_setRollPitchYaw(int argc, VALUE *argv, VALUE self) {
+  FXQuatf *arg1 = (FXQuatf *) 0 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  FXfloat arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatf *","setRollPitchYaw", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatf * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","setRollPitchYaw", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","setRollPitchYaw", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  ecode4 = SWIG_AsVal_float(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","setRollPitchYaw", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXfloat >(val4);
+  (arg1)->setRollPitchYaw(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatf_setAxes(int argc, VALUE *argv, VALUE self) {
+  FXQuatf *arg1 = (FXQuatf *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXVec3f *arg3 = 0 ;
+  FXVec3f *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatf *","setAxes", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatf * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  {
+    if (TYPE(argv[1]) == T_ARRAY) {
+      arg3 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[1], 0)), NUM2DBL(rb_ary_entry(argv[1], 1)), NUM2DBL(rb_ary_entry(argv[1], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[1], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg3 = new FXVec3f(*p);
+    }
+  }
+  {
+    if (TYPE(argv[2]) == T_ARRAY) {
+      arg4 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[2], 0)), NUM2DBL(rb_ary_entry(argv[2], 1)), NUM2DBL(rb_ary_entry(argv[2], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[2], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg4 = new FXVec3f(*p);
+    }
+  }
+  (arg1)->setAxes((FXVec3f const &)*arg2,(FXVec3f const &)*arg3,(FXVec3f const &)*arg4);
+  delete arg2;
+  delete arg3;
+  delete arg4;
+  return Qnil;
+fail:
+  delete arg2;
+  delete arg3;
+  delete arg4;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatf_getXAxis(int argc, VALUE *argv, VALUE self) {
+  FXQuatf *arg1 = (FXQuatf *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatf const *","getXAxis", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatf * >(argp1);
+  result = ((FXQuatf const *)arg1)->getXAxis();
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatf_getYAxis(int argc, VALUE *argv, VALUE self) {
+  FXQuatf *arg1 = (FXQuatf *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatf const *","getYAxis", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatf * >(argp1);
+  result = ((FXQuatf const *)arg1)->getYAxis();
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatf_getZAxis(int argc, VALUE *argv, VALUE self) {
+  FXQuatf *arg1 = (FXQuatf *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatf const *","getZAxis", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatf * >(argp1);
+  result = ((FXQuatf const *)arg1)->getZAxis();
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatf_exp(int argc, VALUE *argv, VALUE self) {
+  FXQuatf *arg1 = (FXQuatf *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXQuatf result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatf const *","exp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatf * >(argp1);
+  result = ((FXQuatf const *)arg1)->exp();
+  {
+    FXQuatf *resultptr = new FXQuatf(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXQuatf *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatf_log(int argc, VALUE *argv, VALUE self) {
+  FXQuatf *arg1 = (FXQuatf *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXQuatf result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatf const *","log", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatf * >(argp1);
+  result = ((FXQuatf const *)arg1)->log();
+  {
+    FXQuatf *resultptr = new FXQuatf(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXQuatf *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatf_invert(int argc, VALUE *argv, VALUE self) {
+  FXQuatf *arg1 = (FXQuatf *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXQuatf result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatf const *","invert", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatf * >(argp1);
+  result = ((FXQuatf const *)arg1)->invert();
+  {
+    FXQuatf *resultptr = new FXQuatf(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXQuatf *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatf_unitinvert(int argc, VALUE *argv, VALUE self) {
+  FXQuatf *arg1 = (FXQuatf *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXQuatf result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatf const *","unitinvert", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatf * >(argp1);
+  result = ((FXQuatf const *)arg1)->unitinvert();
+  {
+    FXQuatf *resultptr = new FXQuatf(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXQuatf *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatf_conj(int argc, VALUE *argv, VALUE self) {
+  FXQuatf *arg1 = (FXQuatf *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXQuatf result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatf const *","conj", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatf * >(argp1);
+  result = ((FXQuatf const *)arg1)->conj();
+  {
+    FXQuatf *resultptr = new FXQuatf(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXQuatf *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatf_arcN___(int argc, VALUE *argv, VALUE self) {
+  FXQuatf *arg1 = (FXQuatf *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXVec3f *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXQuatf *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatf *","arc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatf * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  {
+    if (TYPE(argv[1]) == T_ARRAY) {
+      arg3 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[1], 0)), NUM2DBL(rb_ary_entry(argv[1], 1)), NUM2DBL(rb_ary_entry(argv[1], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[1], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg3 = new FXVec3f(*p);
+    }
+  }
+  result = (FXQuatf *) &(arg1)->arc((FXVec3f const &)*arg2,(FXVec3f const &)*arg3);
+  vresult = FXRbGetRubyObj(result, "FXQuatf *");
+  delete arg2;
+  delete arg3;
+  return vresult;
+fail:
+  delete arg2;
+  delete arg3;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatf_lerpN___(int argc, VALUE *argv, VALUE self) {
+  FXQuatf *arg1 = (FXQuatf *) 0 ;
+  FXQuatf *arg2 = 0 ;
+  FXQuatf *arg3 = 0 ;
+  FXfloat arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  FXQuatf *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatf *","lerp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatf * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXQuatf,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXQuatf const &","lerp", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXQuatf const &","lerp", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXQuatf * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXQuatf,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXQuatf const &","lerp", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXQuatf const &","lerp", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXQuatf * >(argp3);
+  ecode4 = SWIG_AsVal_float(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","lerp", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXfloat >(val4);
+  result = (FXQuatf *) &(arg1)->lerp((FXQuatf const &)*arg2,(FXQuatf const &)*arg3,arg4);
+  vresult = FXRbGetRubyObj(result, "FXQuatf *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatf_getRollPitchYaw(int argc, VALUE *argv, VALUE self) {
+  FXQuatf *arg1 = (FXQuatf *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatf const *","getRollPitchYaw", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatf * >(argp1);
+  result = (VALUE)FXQuatf_getRollPitchYaw((FXQuatf const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatf_getAxes(int argc, VALUE *argv, VALUE self) {
+  FXQuatf *arg1 = (FXQuatf *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatf const *","getAxes", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatf * >(argp1);
+  result = (VALUE)FXQuatf_getAxes((FXQuatf const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatf___mul____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXQuatf *arg1 = (FXQuatf *) 0 ;
+  FXQuatf *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXQuatf result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatf const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatf * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXQuatf,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXQuatf const &","operator *", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXQuatf const &","operator *", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXQuatf * >(argp2);
+  result = FXQuatf_operator_Sm___SWIG_0((FXQuatf const *)arg1,(FXQuatf const &)*arg2);
+  {
+    FXQuatf *resultptr = new FXQuatf(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXQuatf *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatf___mul____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXQuatf *arg1 = (FXQuatf *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatf const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatf * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  result = FXQuatf_operator_Sm___SWIG_1((FXQuatf const *)arg1,(FXVec3f const &)*arg2);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXQuatf___mul__(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXQuatf, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXQuatf, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXQuatf___mul____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXQuatf, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXQuatf___mul____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "__mul__", 
+    "    FXQuatf __mul__(FXQuatf const &other)\n"
+    "    FXVec3f __mul__(FXVec3f const &vec)\n");
+  
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXQuatd;
+
+SWIGINTERN VALUE
+_wrap_new_FXQuatd__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXQuatd *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXQuatd *)new FXQuatd();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXQuatd__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXQuatd *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXQuatd *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXQuatd,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatd const &","FXQuatd", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXQuatd const &","FXQuatd", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXQuatd * >(argp1);
+  {
+    result = (FXQuatd *)new FXQuatd((FXQuatd const &)*arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXQuatd__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXdouble arg1 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  FXdouble arg4 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  FXQuatd *result = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXdouble","FXQuatd", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXdouble >(val1);
+  ecode2 = SWIG_AsVal_double(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","FXQuatd", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","FXQuatd", 3, argv[2] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  ecode4 = SWIG_AsVal_double(argv[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","FXQuatd", 4, argv[3] ));
+  } 
+  arg4 = static_cast< FXdouble >(val4);
+  {
+    result = (FXQuatd *)new FXQuatd(arg1,arg2,arg3,arg4);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXQuatd__SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXdouble *arg1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXQuatd *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXdouble const []","FXQuatd", 1, argv[0] )); 
+  } 
+  arg1 = reinterpret_cast< FXdouble * >(argp1);
+  {
+    result = (FXQuatd *)new FXQuatd((FXdouble const (*))arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXQuatd__SWIG_4(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = 0 ;
+  FXdouble arg2 = (FXdouble) 0.0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  FXQuatd *result = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const &","FXQuatd", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","FXQuatd", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  if (argc > 1) {
+    ecode2 = SWIG_AsVal_double(argv[1], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","FXQuatd", 2, argv[1] ));
+    } 
+    arg2 = static_cast< FXdouble >(val2);
+  }
+  {
+    result = (FXQuatd *)new FXQuatd((FXVec3d const &)*arg1,arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXQuatd__SWIG_5(int argc, VALUE *argv, VALUE self) {
+  FXdouble arg1 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  FXQuatd *result = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXdouble","FXQuatd", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXdouble >(val1);
+  ecode2 = SWIG_AsVal_double(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","FXQuatd", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","FXQuatd", 3, argv[2] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  {
+    result = (FXQuatd *)new FXQuatd(arg1,arg2,arg3);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXQuatd_allocate(VALUE self)
+#else
+_wrap_FXQuatd_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXQuatd);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXQuatd__SWIG_6(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = 0 ;
+  FXVec3d *arg2 = 0 ;
+  FXVec3d *arg3 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  FXQuatd *result = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const &","FXQuatd", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","FXQuatd", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","FXQuatd", 2, argv[1] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","FXQuatd", 2, argv[1])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXVec3d const &","FXQuatd", 3, argv[2] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","FXQuatd", 3, argv[2])); 
+  }
+  arg3 = reinterpret_cast< FXVec3d * >(argp3);
+  {
+    result = (FXQuatd *)new FXQuatd((FXVec3d const &)*arg1,(FXVec3d const &)*arg2,(FXVec3d const &)*arg3);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXQuatd(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 4) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_FXQuatd__SWIG_0(nargs, args, self);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXQuatd, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXQuatd__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXQuatd__SWIG_3(nargs, args, self);
+    }
+  }
+  if ((argc >= 1) && (argc <= 2)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      if (argc <= 1) {
+        return _wrap_new_FXQuatd__SWIG_4(nargs, args, self);
+      }
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_FXQuatd__SWIG_4(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXVec3d, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_new_FXQuatd__SWIG_6(nargs, args, self);
+        }
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_FXQuatd__SWIG_5(nargs, args, self);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_double(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_new_FXQuatd__SWIG_2(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXQuatd.new", 
+    "    FXQuatd.new()\n"
+    "    FXQuatd.new(FXQuatd const &q)\n"
+    "    FXQuatd.new(FXdouble xx, FXdouble yy, FXdouble zz, FXdouble ww)\n"
+    "    FXQuatd.new(FXdouble const v[])\n"
+    "    FXQuatd.new(FXVec3d const &axis, FXdouble phi)\n"
+    "    FXQuatd.new(FXdouble roll, FXdouble pitch, FXdouble yaw)\n"
+    "    FXQuatd.new(FXVec3d const &ex, FXVec3d const &ey, FXVec3d const &ez)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatd_adjustN___(int argc, VALUE *argv, VALUE self) {
+  FXQuatd *arg1 = (FXQuatd *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXQuatd *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatd *","adjust", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatd * >(argp1);
+  result = (FXQuatd *) &(arg1)->adjust();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXQuatd, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatd_setAxisAngle(int argc, VALUE *argv, VALUE self) {
+  FXQuatd *arg1 = (FXQuatd *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  FXdouble arg3 = (FXdouble) 0.0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatd *","setAxisAngle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatd * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","setAxisAngle", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","setAxisAngle", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  if (argc > 1) {
+    ecode3 = SWIG_AsVal_double(argv[1], &val3);
+    if (!SWIG_IsOK(ecode3)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","setAxisAngle", 3, argv[1] ));
+    } 
+    arg3 = static_cast< FXdouble >(val3);
+  }
+  (arg1)->setAxisAngle((FXVec3d const &)*arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatd_getAxisAngle(int argc, VALUE *argv, VALUE self) {
+  FXQuatd *arg1 = (FXQuatd *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatd const *","getAxisAngle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatd * >(argp1);
+  result = (VALUE)FXQuatd_getAxisAngle((FXQuatd const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatd_setRollPitchYaw(int argc, VALUE *argv, VALUE self) {
+  FXQuatd *arg1 = (FXQuatd *) 0 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  FXdouble arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatd *","setRollPitchYaw", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatd * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","setRollPitchYaw", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","setRollPitchYaw", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  ecode4 = SWIG_AsVal_double(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","setRollPitchYaw", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXdouble >(val4);
+  (arg1)->setRollPitchYaw(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatd_exp(int argc, VALUE *argv, VALUE self) {
+  FXQuatd *arg1 = (FXQuatd *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXQuatd result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatd const *","exp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatd * >(argp1);
+  result = ((FXQuatd const *)arg1)->exp();
+  vresult = SWIG_NewPointerObj((new FXQuatd(static_cast< const FXQuatd& >(result))), SWIGTYPE_p_FXQuatd, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatd_log(int argc, VALUE *argv, VALUE self) {
+  FXQuatd *arg1 = (FXQuatd *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXQuatd result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatd const *","log", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatd * >(argp1);
+  result = ((FXQuatd const *)arg1)->log();
+  vresult = SWIG_NewPointerObj((new FXQuatd(static_cast< const FXQuatd& >(result))), SWIGTYPE_p_FXQuatd, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatd_invert(int argc, VALUE *argv, VALUE self) {
+  FXQuatd *arg1 = (FXQuatd *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXQuatd result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatd const *","invert", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatd * >(argp1);
+  result = ((FXQuatd const *)arg1)->invert();
+  vresult = SWIG_NewPointerObj((new FXQuatd(static_cast< const FXQuatd& >(result))), SWIGTYPE_p_FXQuatd, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatd_unitinvert(int argc, VALUE *argv, VALUE self) {
+  FXQuatd *arg1 = (FXQuatd *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXQuatd result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatd const *","unitinvert", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatd * >(argp1);
+  result = ((FXQuatd const *)arg1)->unitinvert();
+  vresult = SWIG_NewPointerObj((new FXQuatd(static_cast< const FXQuatd& >(result))), SWIGTYPE_p_FXQuatd, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatd_conj(int argc, VALUE *argv, VALUE self) {
+  FXQuatd *arg1 = (FXQuatd *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXQuatd result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatd const *","conj", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatd * >(argp1);
+  result = ((FXQuatd const *)arg1)->conj();
+  vresult = SWIG_NewPointerObj((new FXQuatd(static_cast< const FXQuatd& >(result))), SWIGTYPE_p_FXQuatd, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatd_arcN___(int argc, VALUE *argv, VALUE self) {
+  FXQuatd *arg1 = (FXQuatd *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  FXVec3d *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  FXQuatd *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatd *","arc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatd * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","arc", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","arc", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXVec3d const &","arc", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","arc", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXVec3d * >(argp3);
+  result = (FXQuatd *) &(arg1)->arc((FXVec3d const &)*arg2,(FXVec3d const &)*arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXQuatd, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatd_lerpN___(int argc, VALUE *argv, VALUE self) {
+  FXQuatd *arg1 = (FXQuatd *) 0 ;
+  FXQuatd *arg2 = 0 ;
+  FXQuatd *arg3 = 0 ;
+  FXdouble arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  FXQuatd *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatd *","lerp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatd * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXQuatd,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXQuatd const &","lerp", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXQuatd const &","lerp", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXQuatd * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXQuatd,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXQuatd const &","lerp", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXQuatd const &","lerp", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXQuatd * >(argp3);
+  ecode4 = SWIG_AsVal_double(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","lerp", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXdouble >(val4);
+  result = (FXQuatd *) &(arg1)->lerp((FXQuatd const &)*arg2,(FXQuatd const &)*arg3,arg4);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXQuatd, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatd_getRollPitchYaw(int argc, VALUE *argv, VALUE self) {
+  FXQuatd *arg1 = (FXQuatd *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatd const *","getRollPitchYaw", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatd * >(argp1);
+  result = (VALUE)FXQuatd_getRollPitchYaw((FXQuatd const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatd___mul____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXQuatd *arg1 = (FXQuatd *) 0 ;
+  FXQuatd *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXQuatd result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatd const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatd * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXQuatd,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXQuatd const &","operator *", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXQuatd const &","operator *", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXQuatd * >(argp2);
+  result = FXQuatd_operator_Sm___SWIG_0((FXQuatd const *)arg1,(FXQuatd const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXQuatd(static_cast< const FXQuatd& >(result))), SWIGTYPE_p_FXQuatd, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatd___mul____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXQuatd *arg1 = (FXQuatd *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXVec3d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatd const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatd * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","operator *", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","operator *", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  result = FXQuatd_operator_Sm___SWIG_1((FXQuatd const *)arg1,(FXVec3d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec3d(static_cast< const FXVec3d& >(result))), SWIGTYPE_p_FXVec3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXQuatd___mul__(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXQuatd, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXQuatd, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXQuatd___mul____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXQuatd, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXQuatd___mul____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "__mul__", 
+    "    FXQuatd __mul__(FXQuatd const &other)\n"
+    "    FXVec3d __mul__(FXVec3d const &vec)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatd_setAxes(int argc, VALUE *argv, VALUE self) {
+  FXQuatd *arg1 = (FXQuatd *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  FXVec3d *arg3 = 0 ;
+  FXVec3d *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  void *argp4 ;
+  int res4 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatd *","setAxes", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatd * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","setAxes", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","setAxes", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXVec3d const &","setAxes", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","setAxes", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXVec3d * >(argp3);
+  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXVec3d const &","setAxes", 4, argv[2] )); 
+  }
+  if (!argp4) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","setAxes", 4, argv[2])); 
+  }
+  arg4 = reinterpret_cast< FXVec3d * >(argp4);
+  (arg1)->setAxes((FXVec3d const &)*arg2,(FXVec3d const &)*arg3,(FXVec3d const &)*arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatd_getAxes(int argc, VALUE *argv, VALUE self) {
+  FXQuatd *arg1 = (FXQuatd *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatd const *","getAxes", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatd * >(argp1);
+  result = (VALUE)FXQuatd_getAxes((FXQuatd const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatd_getXAxis(int argc, VALUE *argv, VALUE self) {
+  FXQuatd *arg1 = (FXQuatd *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatd const *","getXAxis", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatd * >(argp1);
+  result = ((FXQuatd const *)arg1)->getXAxis();
+  vresult = SWIG_NewPointerObj((new FXVec3d(static_cast< const FXVec3d& >(result))), SWIGTYPE_p_FXVec3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatd_getYAxis(int argc, VALUE *argv, VALUE self) {
+  FXQuatd *arg1 = (FXQuatd *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatd const *","getYAxis", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatd * >(argp1);
+  result = ((FXQuatd const *)arg1)->getYAxis();
+  vresult = SWIG_NewPointerObj((new FXVec3d(static_cast< const FXVec3d& >(result))), SWIGTYPE_p_FXVec3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXQuatd_getZAxis(int argc, VALUE *argv, VALUE self) {
+  FXQuatd *arg1 = (FXQuatd *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXQuatd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatd const *","getZAxis", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXQuatd * >(argp1);
+  result = ((FXQuatd const *)arg1)->getZAxis();
+  vresult = SWIG_NewPointerObj((new FXVec3d(static_cast< const FXVec3d& >(result))), SWIGTYPE_p_FXVec3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMat3f;
+
+SWIGINTERN VALUE
+_wrap_new_FXMat3f__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat3f *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXMat3f *)new FXMat3f();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMat3f__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMat3f *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXMat3f *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXMat3f,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3f const &","FXMat3f", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMat3f const &","FXMat3f", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXMat3f * >(argp1);
+  {
+    result = (FXMat3f *)new FXMat3f((FXMat3f const &)*arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMat3f__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXfloat arg1 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  FXMat3f *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_float(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXfloat","FXMat3f", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXfloat >(val1);
+  {
+    result = (FXMat3f *)new FXMat3f(arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMat3f__SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXfloat arg1 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  FXfloat arg4 ;
+  FXfloat arg5 ;
+  FXfloat arg6 ;
+  FXfloat arg7 ;
+  FXfloat arg8 ;
+  FXfloat arg9 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  float val5 ;
+  int ecode5 = 0 ;
+  float val6 ;
+  int ecode6 = 0 ;
+  float val7 ;
+  int ecode7 = 0 ;
+  float val8 ;
+  int ecode8 = 0 ;
+  float val9 ;
+  int ecode9 = 0 ;
+  FXMat3f *result = 0 ;
+  
+  if ((argc < 9) || (argc > 9)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_float(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXfloat","FXMat3f", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXfloat >(val1);
+  ecode2 = SWIG_AsVal_float(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","FXMat3f", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","FXMat3f", 3, argv[2] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  ecode4 = SWIG_AsVal_float(argv[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","FXMat3f", 4, argv[3] ));
+  } 
+  arg4 = static_cast< FXfloat >(val4);
+  ecode5 = SWIG_AsVal_float(argv[4], &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "FXfloat","FXMat3f", 5, argv[4] ));
+  } 
+  arg5 = static_cast< FXfloat >(val5);
+  ecode6 = SWIG_AsVal_float(argv[5], &val6);
+  if (!SWIG_IsOK(ecode6)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "FXfloat","FXMat3f", 6, argv[5] ));
+  } 
+  arg6 = static_cast< FXfloat >(val6);
+  ecode7 = SWIG_AsVal_float(argv[6], &val7);
+  if (!SWIG_IsOK(ecode7)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "FXfloat","FXMat3f", 7, argv[6] ));
+  } 
+  arg7 = static_cast< FXfloat >(val7);
+  ecode8 = SWIG_AsVal_float(argv[7], &val8);
+  if (!SWIG_IsOK(ecode8)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "FXfloat","FXMat3f", 8, argv[7] ));
+  } 
+  arg8 = static_cast< FXfloat >(val8);
+  ecode9 = SWIG_AsVal_float(argv[8], &val9);
+  if (!SWIG_IsOK(ecode9)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "FXfloat","FXMat3f", 9, argv[8] ));
+  } 
+  arg9 = static_cast< FXfloat >(val9);
+  {
+    result = (FXMat3f *)new FXMat3f(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMat3f__SWIG_4(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXVec3f *arg3 = 0 ;
+  FXMat3f *result = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg1 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg1 = new FXVec3f(*p);
+    }
+  }
+  {
+    if (TYPE(argv[1]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[1], 0)), NUM2DBL(rb_ary_entry(argv[1], 1)), NUM2DBL(rb_ary_entry(argv[1], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[1], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  {
+    if (TYPE(argv[2]) == T_ARRAY) {
+      arg3 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[2], 0)), NUM2DBL(rb_ary_entry(argv[2], 1)), NUM2DBL(rb_ary_entry(argv[2], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[2], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg3 = new FXVec3f(*p);
+    }
+  }
+  {
+    result = (FXMat3f *)new FXMat3f((FXVec3f const &)*arg1,(FXVec3f const &)*arg2,(FXVec3f const &)*arg3);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  delete arg1;
+  delete arg2;
+  delete arg3;
+  return self;
+fail:
+  delete arg1;
+  delete arg2;
+  delete arg3;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMat3f_allocate(VALUE self)
+#else
+_wrap_FXMat3f_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMat3f);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMat3f__SWIG_5(int argc, VALUE *argv, VALUE self) {
+  FXQuatf *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXMat3f *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXQuatf,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatf const &","FXMat3f", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXQuatf const &","FXMat3f", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXQuatf * >(argp1);
+  {
+    result = (FXMat3f *)new FXMat3f((FXQuatf const &)*arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXMat3f(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[9];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 9) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_FXMat3f__SWIG_0(nargs, args, self);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat3f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXMat3f__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXQuatf, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXMat3f__SWIG_5(nargs, args, self);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_FXMat3f__SWIG_2(nargs, args, self);
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXVec3f, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_new_FXMat3f__SWIG_4(nargs, args, self);
+        }
+      }
+    }
+  }
+  if (argc == 9) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            {
+              int res = SWIG_AsVal_float(argv[4], NULL);
+              _v = SWIG_CheckState(res);
+            }
+            if (_v) {
+              {
+                int res = SWIG_AsVal_float(argv[5], NULL);
+                _v = SWIG_CheckState(res);
+              }
+              if (_v) {
+                {
+                  int res = SWIG_AsVal_float(argv[6], NULL);
+                  _v = SWIG_CheckState(res);
+                }
+                if (_v) {
+                  {
+                    int res = SWIG_AsVal_float(argv[7], NULL);
+                    _v = SWIG_CheckState(res);
+                  }
+                  if (_v) {
+                    {
+                      int res = SWIG_AsVal_float(argv[8], NULL);
+                      _v = SWIG_CheckState(res);
+                    }
+                    if (_v) {
+                      return _wrap_new_FXMat3f__SWIG_3(nargs, args, self);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 9, "FXMat3f.new", 
+    "    FXMat3f.new()\n"
+    "    FXMat3f.new(FXMat3f const &other)\n"
+    "    FXMat3f.new(FXfloat w)\n"
+    "    FXMat3f.new(FXfloat a00, FXfloat a01, FXfloat a02, FXfloat a10, FXfloat a11, FXfloat a12, FXfloat a20, FXfloat a21, FXfloat a22)\n"
+    "    FXMat3f.new(FXVec3f const &a, FXVec3f const &b, FXVec3f const &c)\n"
+    "    FXMat3f.new(FXQuatf const &quat)\n");
+  
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXMat3f.[]
+
+  call-seq:
+    [](i) -> FXVec3f
+
+Element accessor/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXMat3f___getitem__(int argc, VALUE *argv, VALUE self) {
+  FXMat3f *arg1 = (FXMat3f *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec3f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3f const *","__getitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3f * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXVec3f *) &FXMat3f___getitem__((FXMat3f const *)arg1,arg2);
+  {
+    FXVec3f* resultptr = new FXVec3f(*result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXMat3f.[]=
+
+  call-seq:
+    []=(i, other) -> FXVec3f
+
+Element setter/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXMat3f___setitem__(int argc, VALUE *argv, VALUE self) {
+  FXMat3f *arg1 = (FXMat3f *) 0 ;
+  FXint arg2 ;
+  FXVec3d *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  FXVec3f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3f *","__setitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3f * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXVec3d const &","__setitem__", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","__setitem__", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXVec3d * >(argp3);
+  result = (FXVec3f *) &FXMat3f___setitem__(arg1,arg2,(FXVec3d const &)*arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXVec3f, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXMat3f.+
+
+  call-seq:
+    +(other) -> FXMat3f
+
+Add operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXMat3f___add__(int argc, VALUE *argv, VALUE self) {
+  FXMat3f *arg1 = (FXMat3f *) 0 ;
+  FXMat3f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXMat3f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3f const *","operator +", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3f * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXMat3f,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXMat3f const &","operator +", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMat3f const &","operator +", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXMat3f * >(argp2);
+  result = FXMat3f_operator_Sa_((FXMat3f const *)arg1,(FXMat3f const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXMat3f(static_cast< const FXMat3f& >(result))), SWIGTYPE_p_FXMat3f, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXMat3f.-
+
+  call-seq:
+    -(other) -> FXMat3f
+
+Substraction operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXMat3f___sub__(int argc, VALUE *argv, VALUE self) {
+  FXMat3f *arg1 = (FXMat3f *) 0 ;
+  FXMat3f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXMat3f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3f const *","operator -", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3f * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXMat3f,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXMat3f const &","operator -", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMat3f const &","operator -", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXMat3f * >(argp2);
+  result = FXMat3f_operator_Ss_((FXMat3f const *)arg1,(FXMat3f const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXMat3f(static_cast< const FXMat3f& >(result))), SWIGTYPE_p_FXMat3f, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXMat3f.-@
+
+  call-seq:
+    -@ -> FXMat3f
+
+Substraction operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXMat3f___neg__(int argc, VALUE *argv, VALUE self) {
+  FXMat3f *arg1 = (FXMat3f *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMat3f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3f const *","operator -", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3f * >(argp1);
+  result = FXMat3f_operator_Ss_((FXMat3f const *)arg1);
+  vresult = SWIG_NewPointerObj((new FXMat3f(static_cast< const FXMat3f& >(result))), SWIGTYPE_p_FXMat3f, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3f___mul____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat3f *arg1 = (FXMat3f *) 0 ;
+  FXMat3f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXMat3f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3f const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3f * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXMat3f,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXMat3f const &","operator *", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMat3f const &","operator *", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXMat3f * >(argp2);
+  result = FXMat3f_operator_Sm___SWIG_0((FXMat3f const *)arg1,(FXMat3f const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXMat3f(static_cast< const FXMat3f& >(result))), SWIGTYPE_p_FXMat3f, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3f___mul____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMat3f *arg1 = (FXMat3f *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  FXMat3f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3f const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","operator *", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  result = FXMat3f_operator_Sm___SWIG_1((FXMat3f const *)arg1,arg2);
+  vresult = SWIG_NewPointerObj((new FXMat3f(static_cast< const FXMat3f& >(result))), SWIGTYPE_p_FXMat3f, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3f___div__(int argc, VALUE *argv, VALUE self) {
+  FXMat3f *arg1 = (FXMat3f *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  FXMat3f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3f const *","operator /", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","operator /", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  result = FXMat3f_operator_Sd_((FXMat3f const *)arg1,arg2);
+  vresult = SWIG_NewPointerObj((new FXMat3f(static_cast< const FXMat3f& >(result))), SWIGTYPE_p_FXMat3f, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3f___mul____SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMat3f *arg1 = (FXMat3f *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3f const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3f * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  result = FXMat3f_operator_Sm___SWIG_2((FXMat3f const *)arg1,(FXVec3f const &)*arg2);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3f___mul____SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXMat3f *arg1 = (FXMat3f *) 0 ;
+  FXVec2f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXVec2f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3f const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3f * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2f,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2f const &","operator *", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2f const &","operator *", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2f * >(argp2);
+  result = FXMat3f_operator_Sm___SWIG_3((FXMat3f const *)arg1,(FXVec2f const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec2f(static_cast< const FXVec2f& >(result))), SWIGTYPE_p_FXVec2f, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMat3f___mul__(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat3f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXMat3f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMat3f___mul____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat3f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMat3f___mul____SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat3f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec2f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMat3f___mul____SWIG_3(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat3f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXMat3f___mul____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "__mul__", 
+    "    FXMat3f __mul__(FXMat3f const &other)\n"
+    "    FXMat3f __mul__(FXfloat x)\n"
+    "    FXVec3f __mul__(FXVec3f const &other)\n"
+    "    FXVec2f __mul__(FXVec2f const &other)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3f_eye(int argc, VALUE *argv, VALUE self) {
+  FXMat3f *arg1 = (FXMat3f *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMat3f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3f *","eye", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3f * >(argp1);
+  result = (FXMat3f *) &(arg1)->eye();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat3f, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3f_rot__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat3f *arg1 = (FXMat3f *) 0 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  FXMat3f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3f *","rot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","rot", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","rot", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  result = (FXMat3f *) &(arg1)->rot(arg2,arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat3f, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3f_rot__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMat3f *arg1 = (FXMat3f *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  FXMat3f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3f *","rot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","rot", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  result = (FXMat3f *) &(arg1)->rot(arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat3f, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMat3f_rot(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 4) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat3f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXMat3f_rot__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat3f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_FXMat3f_rot__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXMat3f.rot", 
+    "    FXMat3f FXMat3f.rot(FXfloat c, FXfloat s)\n"
+    "    FXMat3f & FXMat3f.rot(FXfloat phi)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3f_trans(int argc, VALUE *argv, VALUE self) {
+  FXMat3f *arg1 = (FXMat3f *) 0 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  FXMat3f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3f *","trans", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","trans", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","trans", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  result = (FXMat3f *) &(arg1)->trans(arg2,arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat3f, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3f_scale__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat3f *arg1 = (FXMat3f *) 0 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  FXMat3f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3f *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","scale", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","scale", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  result = (FXMat3f *) &(arg1)->scale(arg2,arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat3f, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3f_scale__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMat3f *arg1 = (FXMat3f *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  FXMat3f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3f *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","scale", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  result = (FXMat3f *) &(arg1)->scale(arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat3f, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMat3f_scale(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 4) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat3f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXMat3f_scale__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat3f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_FXMat3f_scale__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXMat3f.scale", 
+    "    FXMat3f FXMat3f.scale(FXfloat sx, FXfloat sy)\n"
+    "    FXMat3f & FXMat3f.scale(FXfloat s)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3f_det(int argc, VALUE *argv, VALUE self) {
+  FXMat3f *arg1 = (FXMat3f *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3f const *","det", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3f * >(argp1);
+  result = (FXfloat)((FXMat3f const *)arg1)->det();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3f_transpose(int argc, VALUE *argv, VALUE self) {
+  FXMat3f *arg1 = (FXMat3f *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMat3f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3f const *","transpose", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3f * >(argp1);
+  result = ((FXMat3f const *)arg1)->transpose();
+  vresult = SWIG_NewPointerObj((new FXMat3f(static_cast< const FXMat3f& >(result))), SWIGTYPE_p_FXMat3f, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3f_invert(int argc, VALUE *argv, VALUE self) {
+  FXMat3f *arg1 = (FXMat3f *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMat3f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3f const *","invert", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3f * >(argp1);
+  result = ((FXMat3f const *)arg1)->invert();
+  vresult = SWIG_NewPointerObj((new FXMat3f(static_cast< const FXMat3f& >(result))), SWIGTYPE_p_FXMat3f, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMat3d;
+
+SWIGINTERN VALUE
+_wrap_new_FXMat3d__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat3d *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXMat3d *)new FXMat3d();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMat3d__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMat3d *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXMat3d *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXMat3d,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3d const &","FXMat3d", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMat3d const &","FXMat3d", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXMat3d * >(argp1);
+  {
+    result = (FXMat3d *)new FXMat3d((FXMat3d const &)*arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMat3d__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXdouble arg1 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  FXMat3d *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXdouble","FXMat3d", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXdouble >(val1);
+  {
+    result = (FXMat3d *)new FXMat3d(arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMat3d__SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXdouble arg1 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  FXdouble arg4 ;
+  FXdouble arg5 ;
+  FXdouble arg6 ;
+  FXdouble arg7 ;
+  FXdouble arg8 ;
+  FXdouble arg9 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  double val5 ;
+  int ecode5 = 0 ;
+  double val6 ;
+  int ecode6 = 0 ;
+  double val7 ;
+  int ecode7 = 0 ;
+  double val8 ;
+  int ecode8 = 0 ;
+  double val9 ;
+  int ecode9 = 0 ;
+  FXMat3d *result = 0 ;
+  
+  if ((argc < 9) || (argc > 9)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXdouble","FXMat3d", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXdouble >(val1);
+  ecode2 = SWIG_AsVal_double(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","FXMat3d", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","FXMat3d", 3, argv[2] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  ecode4 = SWIG_AsVal_double(argv[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","FXMat3d", 4, argv[3] ));
+  } 
+  arg4 = static_cast< FXdouble >(val4);
+  ecode5 = SWIG_AsVal_double(argv[4], &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "FXdouble","FXMat3d", 5, argv[4] ));
+  } 
+  arg5 = static_cast< FXdouble >(val5);
+  ecode6 = SWIG_AsVal_double(argv[5], &val6);
+  if (!SWIG_IsOK(ecode6)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "FXdouble","FXMat3d", 6, argv[5] ));
+  } 
+  arg6 = static_cast< FXdouble >(val6);
+  ecode7 = SWIG_AsVal_double(argv[6], &val7);
+  if (!SWIG_IsOK(ecode7)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "FXdouble","FXMat3d", 7, argv[6] ));
+  } 
+  arg7 = static_cast< FXdouble >(val7);
+  ecode8 = SWIG_AsVal_double(argv[7], &val8);
+  if (!SWIG_IsOK(ecode8)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "FXdouble","FXMat3d", 8, argv[7] ));
+  } 
+  arg8 = static_cast< FXdouble >(val8);
+  ecode9 = SWIG_AsVal_double(argv[8], &val9);
+  if (!SWIG_IsOK(ecode9)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "FXdouble","FXMat3d", 9, argv[8] ));
+  } 
+  arg9 = static_cast< FXdouble >(val9);
+  {
+    result = (FXMat3d *)new FXMat3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMat3d__SWIG_4(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = 0 ;
+  FXVec3d *arg2 = 0 ;
+  FXVec3d *arg3 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  FXMat3d *result = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const &","FXMat3d", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","FXMat3d", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","FXMat3d", 2, argv[1] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","FXMat3d", 2, argv[1])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXVec3d const &","FXMat3d", 3, argv[2] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","FXMat3d", 3, argv[2])); 
+  }
+  arg3 = reinterpret_cast< FXVec3d * >(argp3);
+  {
+    result = (FXMat3d *)new FXMat3d((FXVec3d const &)*arg1,(FXVec3d const &)*arg2,(FXVec3d const &)*arg3);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMat3d_allocate(VALUE self)
+#else
+_wrap_FXMat3d_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMat3d);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMat3d__SWIG_5(int argc, VALUE *argv, VALUE self) {
+  FXQuatd *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXMat3d *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXQuatd,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXQuatd const &","FXMat3d", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXQuatd const &","FXMat3d", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXQuatd * >(argp1);
+  {
+    result = (FXMat3d *)new FXMat3d((FXQuatd const &)*arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXMat3d(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[9];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 9) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_FXMat3d__SWIG_0(nargs, args, self);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat3d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXMat3d__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXQuatd, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXMat3d__SWIG_5(nargs, args, self);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_FXMat3d__SWIG_2(nargs, args, self);
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXVec3d, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_new_FXMat3d__SWIG_4(nargs, args, self);
+        }
+      }
+    }
+  }
+  if (argc == 9) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_double(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            {
+              int res = SWIG_AsVal_double(argv[4], NULL);
+              _v = SWIG_CheckState(res);
+            }
+            if (_v) {
+              {
+                int res = SWIG_AsVal_double(argv[5], NULL);
+                _v = SWIG_CheckState(res);
+              }
+              if (_v) {
+                {
+                  int res = SWIG_AsVal_double(argv[6], NULL);
+                  _v = SWIG_CheckState(res);
+                }
+                if (_v) {
+                  {
+                    int res = SWIG_AsVal_double(argv[7], NULL);
+                    _v = SWIG_CheckState(res);
+                  }
+                  if (_v) {
+                    {
+                      int res = SWIG_AsVal_double(argv[8], NULL);
+                      _v = SWIG_CheckState(res);
+                    }
+                    if (_v) {
+                      return _wrap_new_FXMat3d__SWIG_3(nargs, args, self);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 9, "FXMat3d.new", 
+    "    FXMat3d.new()\n"
+    "    FXMat3d.new(FXMat3d const &other)\n"
+    "    FXMat3d.new(FXdouble w)\n"
+    "    FXMat3d.new(FXdouble a00, FXdouble a01, FXdouble a02, FXdouble a10, FXdouble a11, FXdouble a12, FXdouble a20, FXdouble a21, FXdouble a22)\n"
+    "    FXMat3d.new(FXVec3d const &a, FXVec3d const &b, FXVec3d const &c)\n"
+    "    FXMat3d.new(FXQuatd const &quat)\n");
+  
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXMat3d.[]
+
+  call-seq:
+    [](i) -> FXVec3d
+
+Element accessor/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXMat3d___getitem__(int argc, VALUE *argv, VALUE self) {
+  FXMat3d *arg1 = (FXMat3d *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec3d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3d const *","__getitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3d * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXVec3d *) &FXMat3d___getitem__((FXMat3d const *)arg1,arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXVec3d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXMat3d.[]=
+
+  call-seq:
+    []=(i, other) -> FXVec3d
+
+Element setter/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXMat3d___setitem__(int argc, VALUE *argv, VALUE self) {
+  FXMat3d *arg1 = (FXMat3d *) 0 ;
+  FXint arg2 ;
+  FXVec3d *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  FXVec3d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3d *","__setitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3d * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXVec3d const &","__setitem__", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","__setitem__", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXVec3d * >(argp3);
+  result = (FXVec3d *) &FXMat3d___setitem__(arg1,arg2,(FXVec3d const &)*arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXVec3d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXMat3d.+
+
+  call-seq:
+    +(other) -> FXMat3d
+
+Add operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXMat3d___add__(int argc, VALUE *argv, VALUE self) {
+  FXMat3d *arg1 = (FXMat3d *) 0 ;
+  FXMat3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXMat3d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3d const *","operator +", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXMat3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXMat3d const &","operator +", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMat3d const &","operator +", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXMat3d * >(argp2);
+  result = FXMat3d_operator_Sa_((FXMat3d const *)arg1,(FXMat3d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXMat3d(static_cast< const FXMat3d& >(result))), SWIGTYPE_p_FXMat3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXMat3d.-
+
+  call-seq:
+    -(other) -> FXMat3d
+
+Substraction operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXMat3d___sub__(int argc, VALUE *argv, VALUE self) {
+  FXMat3d *arg1 = (FXMat3d *) 0 ;
+  FXMat3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXMat3d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3d const *","operator -", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXMat3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXMat3d const &","operator -", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMat3d const &","operator -", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXMat3d * >(argp2);
+  result = FXMat3d_operator_Ss_((FXMat3d const *)arg1,(FXMat3d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXMat3d(static_cast< const FXMat3d& >(result))), SWIGTYPE_p_FXMat3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXMat3d.-@
+
+  call-seq:
+    -@ -> FXMat3d
+
+Substraction operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXMat3d___neg__(int argc, VALUE *argv, VALUE self) {
+  FXMat3d *arg1 = (FXMat3d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMat3d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3d const *","operator -", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3d * >(argp1);
+  result = FXMat3d_operator_Ss_((FXMat3d const *)arg1);
+  vresult = SWIG_NewPointerObj((new FXMat3d(static_cast< const FXMat3d& >(result))), SWIGTYPE_p_FXMat3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3d___mul____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat3d *arg1 = (FXMat3d *) 0 ;
+  FXMat3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXMat3d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3d const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXMat3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXMat3d const &","operator *", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMat3d const &","operator *", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXMat3d * >(argp2);
+  result = FXMat3d_operator_Sm___SWIG_0((FXMat3d const *)arg1,(FXMat3d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXMat3d(static_cast< const FXMat3d& >(result))), SWIGTYPE_p_FXMat3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3d___mul____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMat3d *arg1 = (FXMat3d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  FXMat3d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3d const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","operator *", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  result = FXMat3d_operator_Sm___SWIG_1((FXMat3d const *)arg1,arg2);
+  vresult = SWIG_NewPointerObj((new FXMat3d(static_cast< const FXMat3d& >(result))), SWIGTYPE_p_FXMat3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3d___div__(int argc, VALUE *argv, VALUE self) {
+  FXMat3d *arg1 = (FXMat3d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  FXMat3d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3d const *","operator /", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","operator /", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  result = FXMat3d_operator_Sd_((FXMat3d const *)arg1,arg2);
+  vresult = SWIG_NewPointerObj((new FXMat3d(static_cast< const FXMat3d& >(result))), SWIGTYPE_p_FXMat3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3d___mul____SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMat3d *arg1 = (FXMat3d *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXVec3d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3d const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","operator *", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","operator *", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  result = FXMat3d_operator_Sm___SWIG_2((FXMat3d const *)arg1,(FXVec3d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec3d(static_cast< const FXVec3d& >(result))), SWIGTYPE_p_FXVec3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3d___mul____SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXMat3d *arg1 = (FXMat3d *) 0 ;
+  FXVec2d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXVec2d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3d const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2d const &","operator *", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2d const &","operator *", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2d * >(argp2);
+  result = FXMat3d_operator_Sm___SWIG_3((FXMat3d const *)arg1,(FXVec2d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec2d(static_cast< const FXVec2d& >(result))), SWIGTYPE_p_FXVec2d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMat3d___mul__(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat3d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXMat3d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMat3d___mul____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat3d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMat3d___mul____SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat3d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec2d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMat3d___mul____SWIG_3(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat3d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXMat3d___mul____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "__mul__", 
+    "    FXMat3d __mul__(FXMat3d const &other)\n"
+    "    FXMat3d __mul__(FXdouble x)\n"
+    "    FXVec3d __mul__(FXVec3d const &other)\n"
+    "    FXVec2d __mul__(FXVec2d const &other)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3d_eye(int argc, VALUE *argv, VALUE self) {
+  FXMat3d *arg1 = (FXMat3d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMat3d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3d *","eye", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3d * >(argp1);
+  result = (FXMat3d *) &(arg1)->eye();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat3d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3d_rot__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat3d *arg1 = (FXMat3d *) 0 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  FXMat3d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3d *","rot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","rot", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","rot", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  result = (FXMat3d *) &(arg1)->rot(arg2,arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat3d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3d_rot__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMat3d *arg1 = (FXMat3d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  FXMat3d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3d *","rot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","rot", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  result = (FXMat3d *) &(arg1)->rot(arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat3d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMat3d_rot(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 4) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat3d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXMat3d_rot__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat3d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_FXMat3d_rot__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXMat3d.rot", 
+    "    FXMat3d FXMat3d.rot(FXdouble c, FXdouble s)\n"
+    "    FXMat3d & FXMat3d.rot(FXdouble phi)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3d_trans(int argc, VALUE *argv, VALUE self) {
+  FXMat3d *arg1 = (FXMat3d *) 0 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  FXMat3d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3d *","trans", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","trans", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","trans", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  result = (FXMat3d *) &(arg1)->trans(arg2,arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat3d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3d_scale__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat3d *arg1 = (FXMat3d *) 0 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  FXMat3d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3d *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","scale", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","scale", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  result = (FXMat3d *) &(arg1)->scale(arg2,arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat3d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3d_scale__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMat3d *arg1 = (FXMat3d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  FXMat3d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3d *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","scale", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  result = (FXMat3d *) &(arg1)->scale(arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat3d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMat3d_scale(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 4) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat3d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXMat3d_scale__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat3d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_FXMat3d_scale__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXMat3d.scale", 
+    "    FXMat3d FXMat3d.scale(FXdouble sx, FXdouble sy)\n"
+    "    FXMat3d & FXMat3d.scale(FXdouble s)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3d_det(int argc, VALUE *argv, VALUE self) {
+  FXMat3d *arg1 = (FXMat3d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3d const *","det", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3d * >(argp1);
+  result = (FXdouble)((FXMat3d const *)arg1)->det();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3d_transpose(int argc, VALUE *argv, VALUE self) {
+  FXMat3d *arg1 = (FXMat3d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMat3d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3d const *","transpose", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3d * >(argp1);
+  result = ((FXMat3d const *)arg1)->transpose();
+  vresult = SWIG_NewPointerObj((new FXMat3d(static_cast< const FXMat3d& >(result))), SWIGTYPE_p_FXMat3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat3d_invert(int argc, VALUE *argv, VALUE self) {
+  FXMat3d *arg1 = (FXMat3d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMat3d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat3d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat3d const *","invert", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat3d * >(argp1);
+  result = ((FXMat3d const *)arg1)->invert();
+  vresult = SWIG_NewPointerObj((new FXMat3d(static_cast< const FXMat3d& >(result))), SWIGTYPE_p_FXMat3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMat4f;
+
+SWIGINTERN VALUE
+_wrap_new_FXMat4f__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXMat4f *)new FXMat4f();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMat4f__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXfloat arg1 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  FXMat4f *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_float(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXfloat","FXMat4f", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXfloat >(val1);
+  {
+    result = (FXMat4f *)new FXMat4f(arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMat4f__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXfloat arg1 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  FXfloat arg4 ;
+  FXfloat arg5 ;
+  FXfloat arg6 ;
+  FXfloat arg7 ;
+  FXfloat arg8 ;
+  FXfloat arg9 ;
+  FXfloat arg10 ;
+  FXfloat arg11 ;
+  FXfloat arg12 ;
+  FXfloat arg13 ;
+  FXfloat arg14 ;
+  FXfloat arg15 ;
+  FXfloat arg16 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  float val5 ;
+  int ecode5 = 0 ;
+  float val6 ;
+  int ecode6 = 0 ;
+  float val7 ;
+  int ecode7 = 0 ;
+  float val8 ;
+  int ecode8 = 0 ;
+  float val9 ;
+  int ecode9 = 0 ;
+  float val10 ;
+  int ecode10 = 0 ;
+  float val11 ;
+  int ecode11 = 0 ;
+  float val12 ;
+  int ecode12 = 0 ;
+  float val13 ;
+  int ecode13 = 0 ;
+  float val14 ;
+  int ecode14 = 0 ;
+  float val15 ;
+  int ecode15 = 0 ;
+  float val16 ;
+  int ecode16 = 0 ;
+  FXMat4f *result = 0 ;
+  
+  if ((argc < 16) || (argc > 16)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 16)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_float(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXfloat","FXMat4f", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXfloat >(val1);
+  ecode2 = SWIG_AsVal_float(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","FXMat4f", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","FXMat4f", 3, argv[2] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  ecode4 = SWIG_AsVal_float(argv[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","FXMat4f", 4, argv[3] ));
+  } 
+  arg4 = static_cast< FXfloat >(val4);
+  ecode5 = SWIG_AsVal_float(argv[4], &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "FXfloat","FXMat4f", 5, argv[4] ));
+  } 
+  arg5 = static_cast< FXfloat >(val5);
+  ecode6 = SWIG_AsVal_float(argv[5], &val6);
+  if (!SWIG_IsOK(ecode6)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "FXfloat","FXMat4f", 6, argv[5] ));
+  } 
+  arg6 = static_cast< FXfloat >(val6);
+  ecode7 = SWIG_AsVal_float(argv[6], &val7);
+  if (!SWIG_IsOK(ecode7)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "FXfloat","FXMat4f", 7, argv[6] ));
+  } 
+  arg7 = static_cast< FXfloat >(val7);
+  ecode8 = SWIG_AsVal_float(argv[7], &val8);
+  if (!SWIG_IsOK(ecode8)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "FXfloat","FXMat4f", 8, argv[7] ));
+  } 
+  arg8 = static_cast< FXfloat >(val8);
+  ecode9 = SWIG_AsVal_float(argv[8], &val9);
+  if (!SWIG_IsOK(ecode9)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "FXfloat","FXMat4f", 9, argv[8] ));
+  } 
+  arg9 = static_cast< FXfloat >(val9);
+  ecode10 = SWIG_AsVal_float(argv[9], &val10);
+  if (!SWIG_IsOK(ecode10)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "FXfloat","FXMat4f", 10, argv[9] ));
+  } 
+  arg10 = static_cast< FXfloat >(val10);
+  ecode11 = SWIG_AsVal_float(argv[10], &val11);
+  if (!SWIG_IsOK(ecode11)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "FXfloat","FXMat4f", 11, argv[10] ));
+  } 
+  arg11 = static_cast< FXfloat >(val11);
+  ecode12 = SWIG_AsVal_float(argv[11], &val12);
+  if (!SWIG_IsOK(ecode12)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "FXfloat","FXMat4f", 12, argv[11] ));
+  } 
+  arg12 = static_cast< FXfloat >(val12);
+  ecode13 = SWIG_AsVal_float(argv[12], &val13);
+  if (!SWIG_IsOK(ecode13)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "FXfloat","FXMat4f", 13, argv[12] ));
+  } 
+  arg13 = static_cast< FXfloat >(val13);
+  ecode14 = SWIG_AsVal_float(argv[13], &val14);
+  if (!SWIG_IsOK(ecode14)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "FXfloat","FXMat4f", 14, argv[13] ));
+  } 
+  arg14 = static_cast< FXfloat >(val14);
+  ecode15 = SWIG_AsVal_float(argv[14], &val15);
+  if (!SWIG_IsOK(ecode15)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode15), Ruby_Format_TypeError( "", "FXfloat","FXMat4f", 15, argv[14] ));
+  } 
+  arg15 = static_cast< FXfloat >(val15);
+  ecode16 = SWIG_AsVal_float(argv[15], &val16);
+  if (!SWIG_IsOK(ecode16)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode16), Ruby_Format_TypeError( "", "FXfloat","FXMat4f", 16, argv[15] ));
+  } 
+  arg16 = static_cast< FXfloat >(val16);
+  {
+    result = (FXMat4f *)new FXMat4f(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMat4f__SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXVec4f *arg1 = 0 ;
+  FXVec4f *arg2 = 0 ;
+  FXVec4f *arg3 = 0 ;
+  FXVec4f *arg4 = 0 ;
+  FXMat4f *result = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg1 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg1 = new FXVec4f(*p);
+    }
+  }
+  {
+    if (TYPE(argv[1]) == T_ARRAY) {
+      arg2 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[1], 0)), NUM2DBL(rb_ary_entry(argv[1], 1)), NUM2DBL(rb_ary_entry(argv[1], 2)), NUM2DBL(rb_ary_entry(argv[1], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[1],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg2 = new FXVec4f(*p);
+    }
+  }
+  {
+    if (TYPE(argv[2]) == T_ARRAY) {
+      arg3 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[2], 0)), NUM2DBL(rb_ary_entry(argv[2], 1)), NUM2DBL(rb_ary_entry(argv[2], 2)), NUM2DBL(rb_ary_entry(argv[2], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[2],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg3 = new FXVec4f(*p);
+    }
+  }
+  {
+    if (TYPE(argv[3]) == T_ARRAY) {
+      arg4 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[3], 0)), NUM2DBL(rb_ary_entry(argv[3], 1)), NUM2DBL(rb_ary_entry(argv[3], 2)), NUM2DBL(rb_ary_entry(argv[3], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[3],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg4 = new FXVec4f(*p);
+    }
+  }
+  {
+    result = (FXMat4f *)new FXMat4f((FXVec4f const &)*arg1,(FXVec4f const &)*arg2,(FXVec4f const &)*arg3,(FXVec4f const &)*arg4);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  delete arg1;
+  delete arg2;
+  delete arg3;
+  delete arg4;
+  return self;
+fail:
+  delete arg1;
+  delete arg2;
+  delete arg3;
+  delete arg4;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMat4f_allocate(VALUE self)
+#else
+_wrap_FXMat4f_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMat4f);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMat4f__SWIG_4(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXMat4f *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXMat4f,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f const &","FXMat4f", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMat4f const &","FXMat4f", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  {
+    result = (FXMat4f *)new FXMat4f((FXMat4f const &)*arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXMat4f(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[16];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 16) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_FXMat4f__SWIG_0(nargs, args, self);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXMat4f__SWIG_4(nargs, args, self);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_FXMat4f__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec4f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXVec4f, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXVec4f, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            return _wrap_new_FXMat4f__SWIG_3(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  if (argc == 16) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            {
+              int res = SWIG_AsVal_float(argv[4], NULL);
+              _v = SWIG_CheckState(res);
+            }
+            if (_v) {
+              {
+                int res = SWIG_AsVal_float(argv[5], NULL);
+                _v = SWIG_CheckState(res);
+              }
+              if (_v) {
+                {
+                  int res = SWIG_AsVal_float(argv[6], NULL);
+                  _v = SWIG_CheckState(res);
+                }
+                if (_v) {
+                  {
+                    int res = SWIG_AsVal_float(argv[7], NULL);
+                    _v = SWIG_CheckState(res);
+                  }
+                  if (_v) {
+                    {
+                      int res = SWIG_AsVal_float(argv[8], NULL);
+                      _v = SWIG_CheckState(res);
+                    }
+                    if (_v) {
+                      {
+                        int res = SWIG_AsVal_float(argv[9], NULL);
+                        _v = SWIG_CheckState(res);
+                      }
+                      if (_v) {
+                        {
+                          int res = SWIG_AsVal_float(argv[10], NULL);
+                          _v = SWIG_CheckState(res);
+                        }
+                        if (_v) {
+                          {
+                            int res = SWIG_AsVal_float(argv[11], NULL);
+                            _v = SWIG_CheckState(res);
+                          }
+                          if (_v) {
+                            {
+                              int res = SWIG_AsVal_float(argv[12], NULL);
+                              _v = SWIG_CheckState(res);
+                            }
+                            if (_v) {
+                              {
+                                int res = SWIG_AsVal_float(argv[13], NULL);
+                                _v = SWIG_CheckState(res);
+                              }
+                              if (_v) {
+                                {
+                                  int res = SWIG_AsVal_float(argv[14], NULL);
+                                  _v = SWIG_CheckState(res);
+                                }
+                                if (_v) {
+                                  {
+                                    int res = SWIG_AsVal_float(argv[15], NULL);
+                                    _v = SWIG_CheckState(res);
+                                  }
+                                  if (_v) {
+                                    return _wrap_new_FXMat4f__SWIG_2(nargs, args, self);
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 16, "FXMat4f.new", 
+    "    FXMat4f.new()\n"
+    "    FXMat4f.new(FXfloat w)\n"
+    "    FXMat4f.new(FXfloat a00, FXfloat a01, FXfloat a02, FXfloat a03, FXfloat a10, FXfloat a11, FXfloat a12, FXfloat a13, FXfloat a20, FXfloat a21, FXfloat a22, FXfloat a23, FXfloat a30, FXfloat a31, FXfloat a32, FXfloat a33)\n"
+    "    FXMat4f.new(FXVec4f const &a, FXVec4f const &b, FXVec4f const &c, FXVec4f const &d)\n"
+    "    FXMat4f.new(FXMat4f const &other)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f_det(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f const *","det", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  result = (FXfloat)((FXMat4f const *)arg1)->det();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f_transpose(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMat4f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f const *","transpose", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  result = ((FXMat4f const *)arg1)->transpose();
+  {
+    FXMat4f* resultptr = new FXMat4f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXMat4f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f_invert(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMat4f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f const *","invert", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  result = ((FXMat4f const *)arg1)->invert();
+  {
+    FXMat4f* resultptr = new FXMat4f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXMat4f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXMat4f.[]
+
+  call-seq:
+    [](i) -> FXVec4f
+
+Element accessor/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXMat4f___getitem__(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f const *","__getitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXVec4f *) &FXMat4f___getitem__((FXMat4f const *)arg1,arg2);
+  {
+    FXVec4f* resultptr = new FXVec4f(*result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXMat4f.[]=
+
+  call-seq:
+    []=(i, other) -> FXVec4f
+
+Element setter/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXMat4f___setitem__(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXint arg2 ;
+  FXVec3d *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  FXVec4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","__setitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXVec3d const &","__setitem__", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","__setitem__", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXVec3d * >(argp3);
+  result = (FXVec4f *) &FXMat4f___setitem__(arg1,arg2,(FXVec3d const &)*arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXVec4f, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXMat4f.+
+
+  call-seq:
+    +(other) -> FXMat4f
+
+Add operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXMat4f___add__(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXMat4f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXMat4f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f const *","operator +", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXMat4f,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXMat4f const &","operator +", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMat4f const &","operator +", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXMat4f * >(argp2);
+  result = FXMat4f_operator_Sa_((FXMat4f const *)arg1,(FXMat4f const &)*arg2);
+  {
+    FXMat4f* resultptr = new FXMat4f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXMat4f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXMat4f.-
+
+  call-seq:
+    -(other) -> FXMat4f
+
+Substraction operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXMat4f___sub__(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXMat4f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXMat4f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f const *","operator -", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXMat4f,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXMat4f const &","operator -", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMat4f const &","operator -", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXMat4f * >(argp2);
+  result = FXMat4f_operator_Ss_((FXMat4f const *)arg1,(FXMat4f const &)*arg2);
+  {
+    FXMat4f* resultptr = new FXMat4f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXMat4f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f___mul____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXMat4f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXMat4f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXMat4f,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXMat4f const &","operator *", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMat4f const &","operator *", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXMat4f * >(argp2);
+  result = FXMat4f_operator_Sm___SWIG_0((FXMat4f const *)arg1,(FXMat4f const &)*arg2);
+  {
+    FXMat4f* resultptr = new FXMat4f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXMat4f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f___mul____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  FXMat4f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","operator *", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  result = FXMat4f_operator_Sm___SWIG_1((FXMat4f const *)arg1,arg2);
+  {
+    FXMat4f* resultptr = new FXMat4f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXMat4f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f___mul____SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXVec4f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec4f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg2 = new FXVec4f(*p);
+    }
+  }
+  result = FXMat4f_operator_Sm___SWIG_2((FXMat4f const *)arg1,(FXVec4f const &)*arg2);
+  {
+    FXVec4f* resultptr = new FXVec4f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f___mul____SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  result = FXMat4f_operator_Sm___SWIG_3((FXMat4f const *)arg1,(FXVec3f const &)*arg2);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMat4f___mul__(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXMat4f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMat4f___mul____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec4f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMat4f___mul____SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMat4f___mul____SWIG_3(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXMat4f___mul____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "__mul__", 
+    "    FXMat4f __mul__(FXMat4f const &other)\n"
+    "    FXMat4f __mul__(FXfloat x)\n"
+    "    FXVec4f __mul__(FXVec4f const &other)\n"
+    "    FXVec3f __mul__(FXVec3f const &other)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f___div__(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  FXMat4f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f const *","operator /", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","operator /", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  result = FXMat4f_operator_Sd_((FXMat4f const *)arg1,arg2);
+  {
+    FXMat4f* resultptr = new FXMat4f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXMat4f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXMat4f.-@
+
+  call-seq:
+    -@ -> FXMat4f
+
+Substraction operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXMat4f___neg__(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMat4f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f const *","operator -", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  result = FXMat4f_operator_Ss_((FXMat4f const *)arg1);
+  {
+    FXMat4f* resultptr = new FXMat4f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXMat4f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXMat4f.to_s
+
+  call-seq:
+    to_s -> FXString
+
+Convert class to a String representation.
+*/
+SWIGINTERN VALUE
+_wrap_FXMat4f_to_s(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f const *","to_s", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  result = FXMat4f_to_s((FXMat4f const *)arg1);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f_eye(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMat4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","eye", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  result = (FXMat4f *) &(arg1)->eye();
+  vresult = FXRbGetRubyObj(result, "FXMat4f *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f_ortho(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  FXfloat arg4 ;
+  FXfloat arg5 ;
+  FXfloat arg6 ;
+  FXfloat arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  float val5 ;
+  int ecode5 = 0 ;
+  float val6 ;
+  int ecode6 = 0 ;
+  float val7 ;
+  int ecode7 = 0 ;
+  FXMat4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","ortho", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","ortho", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","ortho", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  ecode4 = SWIG_AsVal_float(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","ortho", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXfloat >(val4);
+  ecode5 = SWIG_AsVal_float(argv[3], &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "FXfloat","ortho", 5, argv[3] ));
+  } 
+  arg5 = static_cast< FXfloat >(val5);
+  ecode6 = SWIG_AsVal_float(argv[4], &val6);
+  if (!SWIG_IsOK(ecode6)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "FXfloat","ortho", 6, argv[4] ));
+  } 
+  arg6 = static_cast< FXfloat >(val6);
+  ecode7 = SWIG_AsVal_float(argv[5], &val7);
+  if (!SWIG_IsOK(ecode7)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "FXfloat","ortho", 7, argv[5] ));
+  } 
+  arg7 = static_cast< FXfloat >(val7);
+  result = (FXMat4f *) &(arg1)->ortho(arg2,arg3,arg4,arg5,arg6,arg7);
+  vresult = FXRbGetRubyObj(result, "FXMat4f *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f_frustum(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  FXfloat arg4 ;
+  FXfloat arg5 ;
+  FXfloat arg6 ;
+  FXfloat arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  float val5 ;
+  int ecode5 = 0 ;
+  float val6 ;
+  int ecode6 = 0 ;
+  float val7 ;
+  int ecode7 = 0 ;
+  FXMat4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","frustum", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","frustum", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","frustum", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  ecode4 = SWIG_AsVal_float(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","frustum", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXfloat >(val4);
+  ecode5 = SWIG_AsVal_float(argv[3], &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "FXfloat","frustum", 5, argv[3] ));
+  } 
+  arg5 = static_cast< FXfloat >(val5);
+  ecode6 = SWIG_AsVal_float(argv[4], &val6);
+  if (!SWIG_IsOK(ecode6)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "FXfloat","frustum", 6, argv[4] ));
+  } 
+  arg6 = static_cast< FXfloat >(val6);
+  ecode7 = SWIG_AsVal_float(argv[5], &val7);
+  if (!SWIG_IsOK(ecode7)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "FXfloat","frustum", 7, argv[5] ));
+  } 
+  arg7 = static_cast< FXfloat >(val7);
+  result = (FXMat4f *) &(arg1)->frustum(arg2,arg3,arg4,arg5,arg6,arg7);
+  vresult = FXRbGetRubyObj(result, "FXMat4f *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f_left(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMat4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","left", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  result = (FXMat4f *) &(arg1)->left();
+  vresult = FXRbGetRubyObj(result, "FXMat4f *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f_rot__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXQuatf *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXMat4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","rot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXQuatf,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXQuatf const &","rot", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXQuatf const &","rot", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXQuatf * >(argp2);
+  result = (FXMat4f *) &(arg1)->rot((FXQuatf const &)*arg2);
+  vresult = FXRbGetRubyObj(result, "FXMat4f *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f_rot__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXfloat arg3 ;
+  FXfloat arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  FXMat4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","rot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","rot", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  ecode4 = SWIG_AsVal_float(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","rot", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXfloat >(val4);
+  result = (FXMat4f *) &(arg1)->rot((FXVec3f const &)*arg2,arg3,arg4);
+  vresult = FXRbGetRubyObj(result, "FXMat4f *");
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f_rot__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXfloat arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  FXMat4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","rot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","rot", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  result = (FXMat4f *) &(arg1)->rot((FXVec3f const &)*arg2,arg3);
+  vresult = FXRbGetRubyObj(result, "FXMat4f *");
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMat4f_rot(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 5) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXQuatf, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMat4f_rot__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_FXMat4f_rot__SWIG_2(nargs, args, self);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_FXMat4f_rot__SWIG_1(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 5, "FXMat4f.rot", 
+    "    FXMat4f FXMat4f.rot(FXQuatf const &q)\n"
+    "    FXMat4f FXMat4f.rot(FXVec3f const &v, FXfloat c, FXfloat s)\n"
+    "    FXMat4f & FXMat4f.rot(FXVec3f const &v, FXfloat phi)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f_xrot__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  FXMat4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","xrot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","xrot", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","xrot", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  result = (FXMat4f *) &(arg1)->xrot(arg2,arg3);
+  vresult = FXRbGetRubyObj(result, "FXMat4f *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f_xrot__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  FXMat4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","xrot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","xrot", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  result = (FXMat4f *) &(arg1)->xrot(arg2);
+  vresult = FXRbGetRubyObj(result, "FXMat4f *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMat4f_xrot(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 4) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXMat4f_xrot__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_FXMat4f_xrot__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXMat4f.xrot", 
+    "    FXMat4f FXMat4f.xrot(FXfloat c, FXfloat s)\n"
+    "    FXMat4f & FXMat4f.xrot(FXfloat phi)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f_yrot__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  FXMat4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","yrot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","yrot", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","yrot", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  result = (FXMat4f *) &(arg1)->yrot(arg2,arg3);
+  vresult = FXRbGetRubyObj(result, "FXMat4f *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f_yrot__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  FXMat4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","yrot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","yrot", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  result = (FXMat4f *) &(arg1)->yrot(arg2);
+  vresult = FXRbGetRubyObj(result, "FXMat4f *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMat4f_yrot(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 4) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXMat4f_yrot__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_FXMat4f_yrot__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXMat4f.yrot", 
+    "    FXMat4f FXMat4f.yrot(FXfloat c, FXfloat s)\n"
+    "    FXMat4f & FXMat4f.yrot(FXfloat phi)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f_zrot__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  FXMat4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","zrot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","zrot", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","zrot", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  result = (FXMat4f *) &(arg1)->zrot(arg2,arg3);
+  vresult = FXRbGetRubyObj(result, "FXMat4f *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f_zrot__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  FXMat4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","zrot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","zrot", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  result = (FXMat4f *) &(arg1)->zrot(arg2);
+  vresult = FXRbGetRubyObj(result, "FXMat4f *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMat4f_zrot(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 4) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXMat4f_zrot__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_FXMat4f_zrot__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXMat4f.zrot", 
+    "    FXMat4f FXMat4f.zrot(FXfloat c, FXfloat s)\n"
+    "    FXMat4f & FXMat4f.zrot(FXfloat phi)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f_look(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXVec3f *arg3 = 0 ;
+  FXVec3f *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMat4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","look", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  {
+    if (TYPE(argv[1]) == T_ARRAY) {
+      arg3 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[1], 0)), NUM2DBL(rb_ary_entry(argv[1], 1)), NUM2DBL(rb_ary_entry(argv[1], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[1], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg3 = new FXVec3f(*p);
+    }
+  }
+  {
+    if (TYPE(argv[2]) == T_ARRAY) {
+      arg4 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[2], 0)), NUM2DBL(rb_ary_entry(argv[2], 1)), NUM2DBL(rb_ary_entry(argv[2], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[2], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg4 = new FXVec3f(*p);
+    }
+  }
+  result = (FXMat4f *) &(arg1)->look((FXVec3f const &)*arg2,(FXVec3f const &)*arg3,(FXVec3f const &)*arg4);
+  vresult = FXRbGetRubyObj(result, "FXMat4f *");
+  delete arg2;
+  delete arg3;
+  delete arg4;
+  return vresult;
+fail:
+  delete arg2;
+  delete arg3;
+  delete arg4;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f_trans__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  FXfloat arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  FXMat4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","trans", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","trans", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","trans", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  ecode4 = SWIG_AsVal_float(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","trans", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXfloat >(val4);
+  result = (FXMat4f *) &(arg1)->trans(arg2,arg3,arg4);
+  vresult = FXRbGetRubyObj(result, "FXMat4f *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f_trans__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMat4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","trans", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  result = (FXMat4f *) &(arg1)->trans((FXVec3f const &)*arg2);
+  vresult = FXRbGetRubyObj(result, "FXMat4f *");
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMat4f_trans(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 5) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMat4f_trans__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_FXMat4f_trans__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 5, "FXMat4f.trans", 
+    "    FXMat4f FXMat4f.trans(FXfloat tx, FXfloat ty, FXfloat tz)\n"
+    "    FXMat4f & FXMat4f.trans(FXVec3f const &v)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f_scale__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  FXfloat arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  FXMat4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","scale", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","scale", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  ecode4 = SWIG_AsVal_float(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","scale", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXfloat >(val4);
+  result = (FXMat4f *) &(arg1)->scale(arg2,arg3,arg4);
+  vresult = FXRbGetRubyObj(result, "FXMat4f *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f_scale__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  FXMat4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","scale", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  result = (FXMat4f *) &(arg1)->scale(arg2);
+  vresult = FXRbGetRubyObj(result, "FXMat4f *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4f_scale__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMat4f *arg1 = (FXMat4f *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMat4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4f, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4f *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4f * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  result = (FXMat4f *) &(arg1)->scale((FXVec3f const &)*arg2);
+  vresult = FXRbGetRubyObj(result, "FXMat4f *");
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMat4f_scale(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 5) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMat4f_scale__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXMat4f_scale__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_FXMat4f_scale__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 5, "FXMat4f.scale", 
+    "    FXMat4f FXMat4f.scale(FXfloat sx, FXfloat sy, FXfloat sz)\n"
+    "    FXMat4f FXMat4f.scale(FXfloat s)\n"
+    "    FXMat4f & FXMat4f.scale(FXVec3f const &v)\n");
+  
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMat4d;
+
+SWIGINTERN VALUE
+_wrap_new_FXMat4d__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXMat4d *)new FXMat4d();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMat4d__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXdouble arg1 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  FXMat4d *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXdouble","FXMat4d", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXdouble >(val1);
+  {
+    result = (FXMat4d *)new FXMat4d(arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMat4d__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXdouble arg1 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  FXdouble arg4 ;
+  FXdouble arg5 ;
+  FXdouble arg6 ;
+  FXdouble arg7 ;
+  FXdouble arg8 ;
+  FXdouble arg9 ;
+  FXdouble arg10 ;
+  FXdouble arg11 ;
+  FXdouble arg12 ;
+  FXdouble arg13 ;
+  FXdouble arg14 ;
+  FXdouble arg15 ;
+  FXdouble arg16 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  double val5 ;
+  int ecode5 = 0 ;
+  double val6 ;
+  int ecode6 = 0 ;
+  double val7 ;
+  int ecode7 = 0 ;
+  double val8 ;
+  int ecode8 = 0 ;
+  double val9 ;
+  int ecode9 = 0 ;
+  double val10 ;
+  int ecode10 = 0 ;
+  double val11 ;
+  int ecode11 = 0 ;
+  double val12 ;
+  int ecode12 = 0 ;
+  double val13 ;
+  int ecode13 = 0 ;
+  double val14 ;
+  int ecode14 = 0 ;
+  double val15 ;
+  int ecode15 = 0 ;
+  double val16 ;
+  int ecode16 = 0 ;
+  FXMat4d *result = 0 ;
+  
+  if ((argc < 16) || (argc > 16)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 16)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXdouble","FXMat4d", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXdouble >(val1);
+  ecode2 = SWIG_AsVal_double(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","FXMat4d", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","FXMat4d", 3, argv[2] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  ecode4 = SWIG_AsVal_double(argv[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","FXMat4d", 4, argv[3] ));
+  } 
+  arg4 = static_cast< FXdouble >(val4);
+  ecode5 = SWIG_AsVal_double(argv[4], &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "FXdouble","FXMat4d", 5, argv[4] ));
+  } 
+  arg5 = static_cast< FXdouble >(val5);
+  ecode6 = SWIG_AsVal_double(argv[5], &val6);
+  if (!SWIG_IsOK(ecode6)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "FXdouble","FXMat4d", 6, argv[5] ));
+  } 
+  arg6 = static_cast< FXdouble >(val6);
+  ecode7 = SWIG_AsVal_double(argv[6], &val7);
+  if (!SWIG_IsOK(ecode7)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "FXdouble","FXMat4d", 7, argv[6] ));
+  } 
+  arg7 = static_cast< FXdouble >(val7);
+  ecode8 = SWIG_AsVal_double(argv[7], &val8);
+  if (!SWIG_IsOK(ecode8)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "FXdouble","FXMat4d", 8, argv[7] ));
+  } 
+  arg8 = static_cast< FXdouble >(val8);
+  ecode9 = SWIG_AsVal_double(argv[8], &val9);
+  if (!SWIG_IsOK(ecode9)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "FXdouble","FXMat4d", 9, argv[8] ));
+  } 
+  arg9 = static_cast< FXdouble >(val9);
+  ecode10 = SWIG_AsVal_double(argv[9], &val10);
+  if (!SWIG_IsOK(ecode10)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "FXdouble","FXMat4d", 10, argv[9] ));
+  } 
+  arg10 = static_cast< FXdouble >(val10);
+  ecode11 = SWIG_AsVal_double(argv[10], &val11);
+  if (!SWIG_IsOK(ecode11)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "FXdouble","FXMat4d", 11, argv[10] ));
+  } 
+  arg11 = static_cast< FXdouble >(val11);
+  ecode12 = SWIG_AsVal_double(argv[11], &val12);
+  if (!SWIG_IsOK(ecode12)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "FXdouble","FXMat4d", 12, argv[11] ));
+  } 
+  arg12 = static_cast< FXdouble >(val12);
+  ecode13 = SWIG_AsVal_double(argv[12], &val13);
+  if (!SWIG_IsOK(ecode13)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "FXdouble","FXMat4d", 13, argv[12] ));
+  } 
+  arg13 = static_cast< FXdouble >(val13);
+  ecode14 = SWIG_AsVal_double(argv[13], &val14);
+  if (!SWIG_IsOK(ecode14)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "FXdouble","FXMat4d", 14, argv[13] ));
+  } 
+  arg14 = static_cast< FXdouble >(val14);
+  ecode15 = SWIG_AsVal_double(argv[14], &val15);
+  if (!SWIG_IsOK(ecode15)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode15), Ruby_Format_TypeError( "", "FXdouble","FXMat4d", 15, argv[14] ));
+  } 
+  arg15 = static_cast< FXdouble >(val15);
+  ecode16 = SWIG_AsVal_double(argv[15], &val16);
+  if (!SWIG_IsOK(ecode16)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode16), Ruby_Format_TypeError( "", "FXdouble","FXMat4d", 16, argv[15] ));
+  } 
+  arg16 = static_cast< FXdouble >(val16);
+  {
+    result = (FXMat4d *)new FXMat4d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMat4d__SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXVec4d *arg1 = 0 ;
+  FXVec4d *arg2 = 0 ;
+  FXVec4d *arg3 = 0 ;
+  FXVec4d *arg4 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  void *argp4 ;
+  int res4 = 0 ;
+  FXMat4d *result = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXVec4d,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec4d const &","FXMat4d", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec4d const &","FXMat4d", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXVec4d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FXVec4d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec4d const &","FXMat4d", 2, argv[1] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec4d const &","FXMat4d", 2, argv[1])); 
+  }
+  arg2 = reinterpret_cast< FXVec4d * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_FXVec4d,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXVec4d const &","FXMat4d", 3, argv[2] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec4d const &","FXMat4d", 3, argv[2])); 
+  }
+  arg3 = reinterpret_cast< FXVec4d * >(argp3);
+  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_FXVec4d,  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXVec4d const &","FXMat4d", 4, argv[3] )); 
+  }
+  if (!argp4) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec4d const &","FXMat4d", 4, argv[3])); 
+  }
+  arg4 = reinterpret_cast< FXVec4d * >(argp4);
+  {
+    result = (FXMat4d *)new FXMat4d((FXVec4d const &)*arg1,(FXVec4d const &)*arg2,(FXVec4d const &)*arg3,(FXVec4d const &)*arg4);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMat4d_allocate(VALUE self)
+#else
+_wrap_FXMat4d_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMat4d);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMat4d__SWIG_4(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXMat4d *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXMat4d,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d const &","FXMat4d", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMat4d const &","FXMat4d", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  {
+    result = (FXMat4d *)new FXMat4d((FXMat4d const &)*arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXMat4d(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[16];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 16) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_FXMat4d__SWIG_0(nargs, args, self);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXMat4d__SWIG_4(nargs, args, self);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_FXMat4d__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec4d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXVec4d, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXVec4d, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            return _wrap_new_FXMat4d__SWIG_3(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  if (argc == 16) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_double(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            {
+              int res = SWIG_AsVal_double(argv[4], NULL);
+              _v = SWIG_CheckState(res);
+            }
+            if (_v) {
+              {
+                int res = SWIG_AsVal_double(argv[5], NULL);
+                _v = SWIG_CheckState(res);
+              }
+              if (_v) {
+                {
+                  int res = SWIG_AsVal_double(argv[6], NULL);
+                  _v = SWIG_CheckState(res);
+                }
+                if (_v) {
+                  {
+                    int res = SWIG_AsVal_double(argv[7], NULL);
+                    _v = SWIG_CheckState(res);
+                  }
+                  if (_v) {
+                    {
+                      int res = SWIG_AsVal_double(argv[8], NULL);
+                      _v = SWIG_CheckState(res);
+                    }
+                    if (_v) {
+                      {
+                        int res = SWIG_AsVal_double(argv[9], NULL);
+                        _v = SWIG_CheckState(res);
+                      }
+                      if (_v) {
+                        {
+                          int res = SWIG_AsVal_double(argv[10], NULL);
+                          _v = SWIG_CheckState(res);
+                        }
+                        if (_v) {
+                          {
+                            int res = SWIG_AsVal_double(argv[11], NULL);
+                            _v = SWIG_CheckState(res);
+                          }
+                          if (_v) {
+                            {
+                              int res = SWIG_AsVal_double(argv[12], NULL);
+                              _v = SWIG_CheckState(res);
+                            }
+                            if (_v) {
+                              {
+                                int res = SWIG_AsVal_double(argv[13], NULL);
+                                _v = SWIG_CheckState(res);
+                              }
+                              if (_v) {
+                                {
+                                  int res = SWIG_AsVal_double(argv[14], NULL);
+                                  _v = SWIG_CheckState(res);
+                                }
+                                if (_v) {
+                                  {
+                                    int res = SWIG_AsVal_double(argv[15], NULL);
+                                    _v = SWIG_CheckState(res);
+                                  }
+                                  if (_v) {
+                                    return _wrap_new_FXMat4d__SWIG_2(nargs, args, self);
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 16, "FXMat4d.new", 
+    "    FXMat4d.new()\n"
+    "    FXMat4d.new(FXdouble w)\n"
+    "    FXMat4d.new(FXdouble a00, FXdouble a01, FXdouble a02, FXdouble a03, FXdouble a10, FXdouble a11, FXdouble a12, FXdouble a13, FXdouble a20, FXdouble a21, FXdouble a22, FXdouble a23, FXdouble a30, FXdouble a31, FXdouble a32, FXdouble a33)\n"
+    "    FXMat4d.new(FXVec4d const &a, FXVec4d const &b, FXVec4d const &c, FXVec4d const &d)\n"
+    "    FXMat4d.new(FXMat4d const &other)\n");
+  
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXMat4d.[]
+
+  call-seq:
+    [](i) -> FXVec4d
+
+Element accessor/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXMat4d___getitem__(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec4d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d const *","__getitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXVec4d *) &FXMat4d___getitem__((FXMat4d const *)arg1,arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXVec4d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXMat4d.[]=
+
+  call-seq:
+    []=(i, other) -> FXVec4d
+
+Element setter/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXMat4d___setitem__(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXint arg2 ;
+  FXVec3d *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  FXVec4d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","__setitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXVec3d const &","__setitem__", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","__setitem__", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXVec3d * >(argp3);
+  result = (FXVec4d *) &FXMat4d___setitem__(arg1,arg2,(FXVec3d const &)*arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXVec4d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXMat4d.+
+
+  call-seq:
+    +(other) -> FXMat4d
+
+Add operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXMat4d___add__(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXMat4d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXMat4d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d const *","operator +", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXMat4d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXMat4d const &","operator +", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMat4d const &","operator +", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXMat4d * >(argp2);
+  result = FXMat4d_operator_Sa_((FXMat4d const *)arg1,(FXMat4d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXMat4d(static_cast< const FXMat4d& >(result))), SWIGTYPE_p_FXMat4d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXMat4d.-
+
+  call-seq:
+    -(other) -> FXMat4d
+
+Substraction operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXMat4d___sub__(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXMat4d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXMat4d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d const *","operator -", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXMat4d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXMat4d const &","operator -", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMat4d const &","operator -", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXMat4d * >(argp2);
+  result = FXMat4d_operator_Ss_((FXMat4d const *)arg1,(FXMat4d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXMat4d(static_cast< const FXMat4d& >(result))), SWIGTYPE_p_FXMat4d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXMat4d.-@
+
+  call-seq:
+    -@ -> FXMat4d
+
+Substraction operator.
+*/
+SWIGINTERN VALUE
+_wrap_FXMat4d___neg__(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMat4d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d const *","operator -", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  result = FXMat4d_operator_Ss_((FXMat4d const *)arg1);
+  vresult = SWIG_NewPointerObj((new FXMat4d(static_cast< const FXMat4d& >(result))), SWIGTYPE_p_FXMat4d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d___mul____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXMat4d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXMat4d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXMat4d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXMat4d const &","operator *", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMat4d const &","operator *", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXMat4d * >(argp2);
+  result = FXMat4d_operator_Sm___SWIG_0((FXMat4d const *)arg1,(FXMat4d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXMat4d(static_cast< const FXMat4d& >(result))), SWIGTYPE_p_FXMat4d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d___mul____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  FXMat4d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","operator *", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  result = FXMat4d_operator_Sm___SWIG_1((FXMat4d const *)arg1,arg2);
+  vresult = SWIG_NewPointerObj((new FXMat4d(static_cast< const FXMat4d& >(result))), SWIGTYPE_p_FXMat4d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d___div__(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  FXMat4d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d const *","operator /", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","operator /", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  result = FXMat4d_operator_Sd_((FXMat4d const *)arg1,arg2);
+  vresult = SWIG_NewPointerObj((new FXMat4d(static_cast< const FXMat4d& >(result))), SWIGTYPE_p_FXMat4d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d___mul____SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXVec4d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXVec4d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec4d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec4d const &","operator *", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec4d const &","operator *", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec4d * >(argp2);
+  result = FXMat4d_operator_Sm___SWIG_2((FXMat4d const *)arg1,(FXVec4d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec4d(static_cast< const FXVec4d& >(result))), SWIGTYPE_p_FXVec4d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d___mul____SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXVec3d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d const *","operator *", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","operator *", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","operator *", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  result = FXMat4d_operator_Sm___SWIG_3((FXMat4d const *)arg1,(FXVec3d const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXVec3d(static_cast< const FXVec3d& >(result))), SWIGTYPE_p_FXVec3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMat4d___mul__(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXMat4d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMat4d___mul____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec4d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMat4d___mul____SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMat4d___mul____SWIG_3(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXMat4d___mul____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "__mul__", 
+    "    FXMat4d __mul__(FXMat4d const &other)\n"
+    "    FXMat4d __mul__(FXdouble x)\n"
+    "    FXVec4d __mul__(FXVec4d const &other)\n"
+    "    FXVec3d __mul__(FXVec3d const &v)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d_eye(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMat4d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","eye", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  result = (FXMat4d *) &(arg1)->eye();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d_ortho(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  FXdouble arg4 ;
+  FXdouble arg5 ;
+  FXdouble arg6 ;
+  FXdouble arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  double val5 ;
+  int ecode5 = 0 ;
+  double val6 ;
+  int ecode6 = 0 ;
+  double val7 ;
+  int ecode7 = 0 ;
+  FXMat4d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","ortho", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","ortho", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","ortho", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  ecode4 = SWIG_AsVal_double(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","ortho", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXdouble >(val4);
+  ecode5 = SWIG_AsVal_double(argv[3], &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "FXdouble","ortho", 5, argv[3] ));
+  } 
+  arg5 = static_cast< FXdouble >(val5);
+  ecode6 = SWIG_AsVal_double(argv[4], &val6);
+  if (!SWIG_IsOK(ecode6)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "FXdouble","ortho", 6, argv[4] ));
+  } 
+  arg6 = static_cast< FXdouble >(val6);
+  ecode7 = SWIG_AsVal_double(argv[5], &val7);
+  if (!SWIG_IsOK(ecode7)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "FXdouble","ortho", 7, argv[5] ));
+  } 
+  arg7 = static_cast< FXdouble >(val7);
+  result = (FXMat4d *) &(arg1)->ortho(arg2,arg3,arg4,arg5,arg6,arg7);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d_frustum(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  FXdouble arg4 ;
+  FXdouble arg5 ;
+  FXdouble arg6 ;
+  FXdouble arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  double val5 ;
+  int ecode5 = 0 ;
+  double val6 ;
+  int ecode6 = 0 ;
+  double val7 ;
+  int ecode7 = 0 ;
+  FXMat4d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","frustum", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","frustum", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","frustum", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  ecode4 = SWIG_AsVal_double(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","frustum", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXdouble >(val4);
+  ecode5 = SWIG_AsVal_double(argv[3], &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "FXdouble","frustum", 5, argv[3] ));
+  } 
+  arg5 = static_cast< FXdouble >(val5);
+  ecode6 = SWIG_AsVal_double(argv[4], &val6);
+  if (!SWIG_IsOK(ecode6)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "FXdouble","frustum", 6, argv[4] ));
+  } 
+  arg6 = static_cast< FXdouble >(val6);
+  ecode7 = SWIG_AsVal_double(argv[5], &val7);
+  if (!SWIG_IsOK(ecode7)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "FXdouble","frustum", 7, argv[5] ));
+  } 
+  arg7 = static_cast< FXdouble >(val7);
+  result = (FXMat4d *) &(arg1)->frustum(arg2,arg3,arg4,arg5,arg6,arg7);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d_left(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMat4d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","left", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  result = (FXMat4d *) &(arg1)->left();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d_rot__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXQuatd *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXMat4d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","rot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXQuatd,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXQuatd const &","rot", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXQuatd const &","rot", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXQuatd * >(argp2);
+  result = (FXMat4d *) &(arg1)->rot((FXQuatd const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d_rot__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  FXdouble arg3 ;
+  FXdouble arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  FXMat4d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","rot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","rot", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","rot", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","rot", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  ecode4 = SWIG_AsVal_double(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","rot", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXdouble >(val4);
+  result = (FXMat4d *) &(arg1)->rot((FXVec3d const &)*arg2,arg3,arg4);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d_rot__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  FXdouble arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  FXMat4d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","rot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","rot", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","rot", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","rot", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  result = (FXMat4d *) &(arg1)->rot((FXVec3d const &)*arg2,arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMat4d_rot(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 5) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXQuatd, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMat4d_rot__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_FXMat4d_rot__SWIG_2(nargs, args, self);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_double(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_FXMat4d_rot__SWIG_1(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 5, "FXMat4d.rot", 
+    "    FXMat4d FXMat4d.rot(FXQuatd const &q)\n"
+    "    FXMat4d FXMat4d.rot(FXVec3d const &v, FXdouble c, FXdouble s)\n"
+    "    FXMat4d & FXMat4d.rot(FXVec3d const &v, FXdouble phi)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d_xrot__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  FXMat4d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","xrot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","xrot", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","xrot", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  result = (FXMat4d *) &(arg1)->xrot(arg2,arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d_xrot__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  FXMat4d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","xrot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","xrot", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  result = (FXMat4d *) &(arg1)->xrot(arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMat4d_xrot(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 4) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXMat4d_xrot__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_FXMat4d_xrot__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXMat4d.xrot", 
+    "    FXMat4d FXMat4d.xrot(FXdouble c, FXdouble s)\n"
+    "    FXMat4d & FXMat4d.xrot(FXdouble phi)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d_yrot__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  FXMat4d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","yrot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","yrot", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","yrot", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  result = (FXMat4d *) &(arg1)->yrot(arg2,arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d_yrot__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  FXMat4d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","yrot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","yrot", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  result = (FXMat4d *) &(arg1)->yrot(arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMat4d_yrot(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 4) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXMat4d_yrot__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_FXMat4d_yrot__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXMat4d.yrot", 
+    "    FXMat4d FXMat4d.yrot(FXdouble c, FXdouble s)\n"
+    "    FXMat4d & FXMat4d.yrot(FXdouble phi)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d_zrot__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  FXMat4d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","zrot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","zrot", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","zrot", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  result = (FXMat4d *) &(arg1)->zrot(arg2,arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d_zrot__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  FXMat4d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","zrot", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","zrot", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  result = (FXMat4d *) &(arg1)->zrot(arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMat4d_zrot(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 4) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXMat4d_zrot__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_FXMat4d_zrot__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXMat4d.zrot", 
+    "    FXMat4d FXMat4d.zrot(FXdouble c, FXdouble s)\n"
+    "    FXMat4d & FXMat4d.zrot(FXdouble phi)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d_look(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  FXVec3d *arg3 = 0 ;
+  FXVec3d *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  void *argp4 ;
+  int res4 = 0 ;
+  FXMat4d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","look", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","look", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","look", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXVec3d const &","look", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","look", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXVec3d * >(argp3);
+  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXVec3d const &","look", 4, argv[2] )); 
+  }
+  if (!argp4) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","look", 4, argv[2])); 
+  }
+  arg4 = reinterpret_cast< FXVec3d * >(argp4);
+  result = (FXMat4d *) &(arg1)->look((FXVec3d const &)*arg2,(FXVec3d const &)*arg3,(FXVec3d const &)*arg4);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d_trans__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  FXdouble arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  FXMat4d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","trans", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","trans", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","trans", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  ecode4 = SWIG_AsVal_double(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","trans", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXdouble >(val4);
+  result = (FXMat4d *) &(arg1)->trans(arg2,arg3,arg4);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d_trans__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXMat4d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","trans", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","trans", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","trans", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  result = (FXMat4d *) &(arg1)->trans((FXVec3d const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMat4d_trans(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 5) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMat4d_trans__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_double(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_FXMat4d_trans__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 5, "FXMat4d.trans", 
+    "    FXMat4d FXMat4d.trans(FXdouble tx, FXdouble ty, FXdouble tz)\n"
+    "    FXMat4d & FXMat4d.trans(FXVec3d const &v)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d_scale__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  FXdouble arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  FXMat4d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","scale", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","scale", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  ecode4 = SWIG_AsVal_double(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","scale", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXdouble >(val4);
+  result = (FXMat4d *) &(arg1)->scale(arg2,arg3,arg4);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d_scale__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  FXMat4d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","scale", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  result = (FXMat4d *) &(arg1)->scale(arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d_scale__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXMat4d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","scale", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","scale", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  result = (FXMat4d *) &(arg1)->scale((FXVec3d const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMat4d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMat4d_scale(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 5) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMat4d_scale__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_FXMat4d_scale__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMat4d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_double(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_FXMat4d_scale__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 5, "FXMat4d.scale", 
+    "    FXMat4d FXMat4d.scale(FXdouble sx, FXdouble sy, FXdouble sz)\n"
+    "    FXMat4d FXMat4d.scale(FXdouble s)\n"
+    "    FXMat4d & FXMat4d.scale(FXVec3d const &v)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d_det(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d const *","det", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  result = (FXdouble)((FXMat4d const *)arg1)->det();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d_transpose(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMat4d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d const *","transpose", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  result = ((FXMat4d const *)arg1)->transpose();
+  vresult = SWIG_NewPointerObj((new FXMat4d(static_cast< const FXMat4d& >(result))), SWIGTYPE_p_FXMat4d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMat4d_invert(int argc, VALUE *argv, VALUE self) {
+  FXMat4d *arg1 = (FXMat4d *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMat4d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMat4d, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMat4d const *","invert", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMat4d * >(argp1);
+  result = ((FXMat4d const *)arg1)->invert();
+  vresult = SWIG_NewPointerObj((new FXMat4d(static_cast< const FXMat4d& >(result))), SWIGTYPE_p_FXMat4d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXRangef;
+
+SWIGINTERN VALUE
+_wrap_new_FXRangef__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXRangef *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXRangef *)new FXRangef();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRangef__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXRangef *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXRangef,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef const &","FXRangef", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRangef const &","FXRangef", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  {
+    result = (FXRangef *)new FXRangef((FXRangef const &)*arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRangef__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXfloat arg1 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  FXfloat arg4 ;
+  FXfloat arg5 ;
+  FXfloat arg6 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  float val5 ;
+  int ecode5 = 0 ;
+  float val6 ;
+  int ecode6 = 0 ;
+  FXRangef *result = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_float(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXfloat","FXRangef", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXfloat >(val1);
+  ecode2 = SWIG_AsVal_float(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","FXRangef", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","FXRangef", 3, argv[2] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  ecode4 = SWIG_AsVal_float(argv[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","FXRangef", 4, argv[3] ));
+  } 
+  arg4 = static_cast< FXfloat >(val4);
+  ecode5 = SWIG_AsVal_float(argv[4], &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "FXfloat","FXRangef", 5, argv[4] ));
+  } 
+  arg5 = static_cast< FXfloat >(val5);
+  ecode6 = SWIG_AsVal_float(argv[5], &val6);
+  if (!SWIG_IsOK(ecode6)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "FXfloat","FXRangef", 6, argv[5] ));
+  } 
+  arg6 = static_cast< FXfloat >(val6);
+  {
+    result = (FXRangef *)new FXRangef(arg1,arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXRangef_allocate(VALUE self)
+#else
+_wrap_FXRangef_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXRangef);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRangef__SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXRangef *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXSpheref,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref const &","FXRangef", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSpheref const &","FXRangef", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  {
+    result = (FXRangef *)new FXRangef((FXSpheref const &)*arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXRangef(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 6) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_FXRangef__SWIG_0(nargs, args, self);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRangef, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXRangef__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSpheref, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXRangef__SWIG_3(nargs, args, self);
+    }
+  }
+  if (argc == 6) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            {
+              int res = SWIG_AsVal_float(argv[4], NULL);
+              _v = SWIG_CheckState(res);
+            }
+            if (_v) {
+              {
+                int res = SWIG_AsVal_float(argv[5], NULL);
+                _v = SWIG_CheckState(res);
+              }
+              if (_v) {
+                return _wrap_new_FXRangef__SWIG_2(nargs, args, self);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "FXRangef.new", 
+    "    FXRangef.new()\n"
+    "    FXRangef.new(FXRangef const &bounds)\n"
+    "    FXRangef.new(FXfloat xlo, FXfloat xhi, FXfloat ylo, FXfloat yhi, FXfloat zlo, FXfloat zhi)\n"
+    "    FXRangef.new(FXSpheref const &sphere)\n");
+  
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXRangef.[]
+
+  call-seq:
+    [](i) -> FXVec3f
+
+Element accessor/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXRangef___getitem__(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec3f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef *","__getitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXVec3f *) &FXRangef___getitem__(arg1,arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXVec3f, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXRangef.[]=
+
+  call-seq:
+    []=(i, slice)
+
+Element setter/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXRangef___setitem__(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  FXint arg2 ;
+  FXVec3f *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef *","__setitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXVec3f,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXVec3f &","__setitem__", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3f &","__setitem__", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXVec3f * >(argp3);
+  FXRangef___setitem__(arg1,arg2,*arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_upper(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef const *","upper", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  result = FXRangef_upper((FXRangef const *)arg1);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_lower(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef const *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  result = FXRangef_lower((FXRangef const *)arg1);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_width(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef const *","width", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  result = (FXfloat)((FXRangef const *)arg1)->width();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_height(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef const *","height", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  result = (FXfloat)((FXRangef const *)arg1)->height();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_depth(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef const *","depth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  result = (FXfloat)((FXRangef const *)arg1)->depth();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_longest(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef const *","longest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  result = (FXfloat)((FXRangef const *)arg1)->longest();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_shortest(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef const *","shortest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  result = (FXfloat)((FXRangef const *)arg1)->shortest();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_diameter(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef const *","diameter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  result = (FXfloat)((FXRangef const *)arg1)->diameter();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_radius(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef const *","radius", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  result = (FXfloat)((FXRangef const *)arg1)->radius();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_diagonal(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef const *","diagonal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  result = ((FXRangef const *)arg1)->diagonal();
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_center(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef const *","center", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  result = ((FXRangef const *)arg1)->center();
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXRangef.empty?
+
+  call-seq:
+    empty? -> bool
+
+Check if FXRangef is empty.
+*/
+SWIGINTERN VALUE
+_wrap_FXRangef_emptyq___(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef const *","empty", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  result = (bool)((FXRangef const *)arg1)->empty();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_containsq_____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  FXfloat arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","contains", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","contains", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  ecode4 = SWIG_AsVal_float(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","contains", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXfloat >(val4);
+  result = (bool)((FXRangef const *)arg1)->contains(arg2,arg3,arg4);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_containsq_____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  result = (bool)((FXRangef const *)arg1)->contains((FXVec3f const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_containsq_____SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  FXRangef *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRangef,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRangef const &","contains", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRangef const &","contains", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRangef * >(argp2);
+  result = (bool)((FXRangef const *)arg1)->contains((FXRangef const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_containsq_____SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  FXSpheref *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXSpheref,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXSpheref const &","contains", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSpheref const &","contains", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXSpheref * >(argp2);
+  result = (bool)((FXRangef const *)arg1)->contains((FXSpheref const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXRangef_containsq___(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 5) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRangef, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRangef_containsq_____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRangef, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRangef, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRangef_containsq_____SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRangef, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXSpheref, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRangef_containsq_____SWIG_3(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRangef, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_FXRangef_containsq_____SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 5, "FXRangef.contains?", 
+    "    bool FXRangef.contains?(FXfloat x, FXfloat y, FXfloat z)\n"
+    "    bool FXRangef.contains?(FXVec3f const &p)\n"
+    "    bool FXRangef.contains?(FXRangef const &bounds)\n"
+    "    bool FXRangef.contains?(FXSpheref const &sphere)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_includeN_____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  FXfloat arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  FXRangef *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef *","include", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","include", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","include", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  ecode4 = SWIG_AsVal_float(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","include", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXfloat >(val4);
+  result = (FXRangef *) &(arg1)->include(arg2,arg3,arg4);
+  vresult = FXRbGetRubyObj(result, "FXRangef *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_includeN_____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXRangef *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef *","include", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  result = (FXRangef *) &(arg1)->include((FXVec3f const &)*arg2);
+  vresult = FXRbGetRubyObj(result, "FXRangef *");
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_includeN_____SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  FXRangef *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXRangef *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef *","include", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRangef,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRangef const &","include", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRangef const &","include", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRangef * >(argp2);
+  result = (FXRangef *) &(arg1)->include((FXRangef const &)*arg2);
+  vresult = FXRbGetRubyObj(result, "FXRangef *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_includeN_____SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  FXSpheref *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXRangef *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef *","include", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXSpheref,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXSpheref const &","include", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSpheref const &","include", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXSpheref * >(argp2);
+  result = (FXRangef *) &(arg1)->include((FXSpheref const &)*arg2);
+  vresult = FXRbGetRubyObj(result, "FXRangef *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXRangef_includeN___(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 5) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRangef, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRangef_includeN_____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRangef, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRangef, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRangef_includeN_____SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRangef, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXSpheref, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRangef_includeN_____SWIG_3(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRangef, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_FXRangef_includeN_____SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 5, "FXRangef.include!", 
+    "    FXRangef FXRangef.include!(FXfloat x, FXfloat y, FXfloat z)\n"
+    "    FXRangef FXRangef.include!(FXVec3f const &v)\n"
+    "    FXRangef FXRangef.include!(FXRangef const &box)\n"
+    "    FXRangef & FXRangef.include!(FXSpheref const &sphere)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_intersect__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  FXVec4f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef const *","intersect", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg2 = new FXVec4f(*p);
+    }
+  }
+  result = (FXint)((FXRangef const *)arg1)->intersect((FXVec4f const &)*arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_intersect__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXVec3f *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef *","intersect", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  {
+    if (TYPE(argv[1]) == T_ARRAY) {
+      arg3 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[1], 0)), NUM2DBL(rb_ary_entry(argv[1], 1)), NUM2DBL(rb_ary_entry(argv[1], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[1], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg3 = new FXVec3f(*p);
+    }
+  }
+  result = (bool)(arg1)->intersect((FXVec3f const &)*arg2,(FXVec3f const &)*arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  delete arg2;
+  delete arg3;
+  return vresult;
+fail:
+  delete arg2;
+  delete arg3;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXRangef_intersect(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 4) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRangef, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec4f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRangef_intersect__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRangef, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXVec3f, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_FXRangef_intersect__SWIG_1(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXRangef.intersect", 
+    "    FXint FXRangef.intersect(FXVec4f const &plane)\n"
+    "    bool FXRangef.intersect(FXVec3f const &u, FXVec3f const &v)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_overlapsq___(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  FXRangef *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef const *","overlaps", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRangef,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRangef const &","overlaps", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRangef const &","overlaps", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRangef * >(argp2);
+  result = (bool)FXRangef_overlaps((FXRangef const *)arg1,(FXRangef const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_corner(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef const *","corner", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = FXRangef_corner((FXRangef const *)arg1,arg2);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_union(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  FXRangef *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXRangef result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef const *","onion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRangef,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRangef const &","onion", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRangef const &","onion", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRangef * >(argp2);
+  result = FXRangef_onion((FXRangef const *)arg1,(FXRangef const &)*arg2);
+  {
+    FXRangef* resultptr = new FXRangef(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXRangef *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRangef_intersection(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = (FXRangef *) 0 ;
+  FXRangef *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXRangef result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRangef, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef const *","intersection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRangef,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRangef const &","intersection", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRangef const &","intersection", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRangef * >(argp2);
+  result = FXRangef_intersection((FXRangef const *)arg1,(FXRangef const &)*arg2);
+  {
+    FXRangef* resultptr = new FXRangef(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXRangef *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXRanged;
+
+SWIGINTERN VALUE
+_wrap_FXRanged_lower_set(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","lower", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","lower", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  if (arg1) (arg1)->lower = *arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_lower_get(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec3d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  result = (FXVec3d *) & ((arg1)->lower);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXVec3d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_upper_set(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged *","upper", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","upper", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","upper", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  if (arg1) (arg1)->upper = *arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_upper_get(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec3d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged *","upper", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  result = (FXVec3d *) & ((arg1)->upper);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXVec3d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRanged__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXRanged *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXRanged *)new FXRanged();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRanged__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXRanged *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXRanged,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged const &","FXRanged", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRanged const &","FXRanged", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  {
+    result = (FXRanged *)new FXRanged((FXRanged const &)*arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRanged__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXdouble arg1 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  FXdouble arg4 ;
+  FXdouble arg5 ;
+  FXdouble arg6 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  double val5 ;
+  int ecode5 = 0 ;
+  double val6 ;
+  int ecode6 = 0 ;
+  FXRanged *result = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXdouble","FXRanged", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXdouble >(val1);
+  ecode2 = SWIG_AsVal_double(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","FXRanged", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","FXRanged", 3, argv[2] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  ecode4 = SWIG_AsVal_double(argv[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","FXRanged", 4, argv[3] ));
+  } 
+  arg4 = static_cast< FXdouble >(val4);
+  ecode5 = SWIG_AsVal_double(argv[4], &val5);
+  if (!SWIG_IsOK(ecode5)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "FXdouble","FXRanged", 5, argv[4] ));
+  } 
+  arg5 = static_cast< FXdouble >(val5);
+  ecode6 = SWIG_AsVal_double(argv[5], &val6);
+  if (!SWIG_IsOK(ecode6)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "FXdouble","FXRanged", 6, argv[5] ));
+  } 
+  arg6 = static_cast< FXdouble >(val6);
+  {
+    result = (FXRanged *)new FXRanged(arg1,arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXRanged_allocate(VALUE self)
+#else
+_wrap_FXRanged_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXRanged);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRanged__SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXRanged *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXSphered,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered const &","FXRanged", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSphered const &","FXRanged", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  {
+    result = (FXRanged *)new FXRanged((FXSphered const &)*arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXRanged(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 6) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_FXRanged__SWIG_0(nargs, args, self);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRanged, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXRanged__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSphered, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXRanged__SWIG_3(nargs, args, self);
+    }
+  }
+  if (argc == 6) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_double(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            {
+              int res = SWIG_AsVal_double(argv[4], NULL);
+              _v = SWIG_CheckState(res);
+            }
+            if (_v) {
+              {
+                int res = SWIG_AsVal_double(argv[5], NULL);
+                _v = SWIG_CheckState(res);
+              }
+              if (_v) {
+                return _wrap_new_FXRanged__SWIG_2(nargs, args, self);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "FXRanged.new", 
+    "    FXRanged.new()\n"
+    "    FXRanged.new(FXRanged const &bounds)\n"
+    "    FXRanged.new(FXdouble xlo, FXdouble xhi, FXdouble ylo, FXdouble yhi, FXdouble zlo, FXdouble zhi)\n"
+    "    FXRanged.new(FXSphered const &sphere)\n");
+  
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXRanged.[]
+
+  call-seq:
+    [](i) -> FXVec3d
+
+Element accessor/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXRanged___getitem__(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec3d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged *","__getitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXVec3d *) &FXRanged___getitem__(arg1,arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXVec3d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXRanged.[]=
+
+  call-seq:
+    []=(i, slice)
+
+Element setter/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXRanged___setitem__(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  FXint arg2 ;
+  FXVec3d *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged *","__setitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXVec3d &","__setitem__", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d &","__setitem__", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXVec3d * >(argp3);
+  FXRanged___setitem__(arg1,arg2,*arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_width(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged const *","width", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  result = (FXdouble)((FXRanged const *)arg1)->width();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_height(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged const *","height", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  result = (FXdouble)((FXRanged const *)arg1)->height();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_depth(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged const *","depth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  result = (FXdouble)((FXRanged const *)arg1)->depth();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_longest(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged const *","longest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  result = (FXdouble)((FXRanged const *)arg1)->longest();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_shortest(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged const *","shortest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  result = (FXdouble)((FXRanged const *)arg1)->shortest();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_diameter(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged const *","diameter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  result = (FXdouble)((FXRanged const *)arg1)->diameter();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_radius(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged const *","radius", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  result = (FXdouble)((FXRanged const *)arg1)->radius();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_diagonal(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged const *","diagonal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  result = ((FXRanged const *)arg1)->diagonal();
+  vresult = SWIG_NewPointerObj((new FXVec3d(static_cast< const FXVec3d& >(result))), SWIGTYPE_p_FXVec3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_center(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged const *","center", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  result = ((FXRanged const *)arg1)->center();
+  vresult = SWIG_NewPointerObj((new FXVec3d(static_cast< const FXVec3d& >(result))), SWIGTYPE_p_FXVec3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXRanged.empty?
+
+  call-seq:
+    empty? -> bool
+
+Check if FXRanged is empty.
+*/
+SWIGINTERN VALUE
+_wrap_FXRanged_emptyq___(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged const *","empty", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  result = (bool)((FXRanged const *)arg1)->empty();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_contains(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  FXdouble arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","contains", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","contains", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  ecode4 = SWIG_AsVal_double(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","contains", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXdouble >(val4);
+  result = (bool)((FXRanged const *)arg1)->contains(arg2,arg3,arg4);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_containsq_____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","contains", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","contains", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  result = (bool)((FXRanged const *)arg1)->contains((FXVec3d const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_containsq_____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  FXRanged *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRanged,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRanged const &","contains", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRanged const &","contains", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRanged * >(argp2);
+  result = (bool)((FXRanged const *)arg1)->contains((FXRanged const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_containsq_____SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  FXSphered *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXSphered,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXSphered const &","contains", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSphered const &","contains", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXSphered * >(argp2);
+  result = (bool)((FXRanged const *)arg1)->contains((FXSphered const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXRanged_containsq___(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRanged, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRanged_containsq_____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRanged, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRanged, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRanged_containsq_____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRanged, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXSphered, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRanged_containsq_____SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "FXRanged.contains?", 
+    "    bool FXRanged.contains?(FXVec3d const &p)\n"
+    "    bool FXRanged.contains?(FXRanged const &bounds)\n"
+    "    bool FXRanged.contains?(FXSphered const &sphere)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_include__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  FXdouble arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  FXRanged *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged *","include", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","include", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","include", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  ecode4 = SWIG_AsVal_double(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","include", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXdouble >(val4);
+  result = (FXRanged *) &(arg1)->include(arg2,arg3,arg4);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXRanged, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_include__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXRanged *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged *","include", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","include", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","include", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  result = (FXRanged *) &(arg1)->include((FXVec3d const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXRanged, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_include__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  FXRanged *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXRanged *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged *","include", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRanged,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRanged const &","include", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRanged const &","include", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRanged * >(argp2);
+  result = (FXRanged *) &(arg1)->include((FXRanged const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXRanged, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_include__SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  FXSphered *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXRanged *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged *","include", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXSphered,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXSphered const &","include", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSphered const &","include", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXSphered * >(argp2);
+  result = (FXRanged *) &(arg1)->include((FXSphered const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXRanged, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXRanged_include(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 5) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRanged, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRanged_include__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRanged, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRanged, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRanged_include__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRanged, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXSphered, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRanged_include__SWIG_3(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRanged, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_double(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_FXRanged_include__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 5, "FXRanged.include", 
+    "    FXRanged FXRanged.include(FXdouble x, FXdouble y, FXdouble z)\n"
+    "    FXRanged FXRanged.include(FXVec3d const &v)\n"
+    "    FXRanged FXRanged.include(FXRanged const &box)\n"
+    "    FXRanged & FXRanged.include(FXSphered const &sphere)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_intersect__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  FXVec4d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged const *","intersect", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec4d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec4d const &","intersect", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec4d const &","intersect", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec4d * >(argp2);
+  result = (FXint)((FXRanged const *)arg1)->intersect((FXVec4d const &)*arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_intersect__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  FXVec3d *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged *","intersect", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","intersect", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","intersect", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXVec3d const &","intersect", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","intersect", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXVec3d * >(argp3);
+  result = (bool)(arg1)->intersect((FXVec3d const &)*arg2,(FXVec3d const &)*arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXRanged_intersect(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 4) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRanged, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec4d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRanged_intersect__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRanged, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXVec3d, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_FXRanged_intersect__SWIG_1(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXRanged.intersect", 
+    "    FXint FXRanged.intersect(FXVec4d const &plane)\n"
+    "    bool FXRanged.intersect(FXVec3d const &u, FXVec3d const &v)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_overlapsq___(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  FXRanged *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged const *","overlaps", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRanged,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRanged const &","overlaps", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRanged const &","overlaps", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRanged * >(argp2);
+  result = (bool)FXRanged_overlaps((FXRanged const *)arg1,(FXRanged const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_corner(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3d > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged const *","corner", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = FXRanged_corner((FXRanged const *)arg1,arg2);
+  vresult = SWIG_NewPointerObj((new FXVec3d(static_cast< const FXVec3d& >(result))), SWIGTYPE_p_FXVec3d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_union(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  FXRanged *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXRanged result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged const *","onion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRanged,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRanged const &","onion", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRanged const &","onion", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRanged * >(argp2);
+  result = FXRanged_onion((FXRanged const *)arg1,(FXRanged const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXRanged(static_cast< const FXRanged& >(result))), SWIGTYPE_p_FXRanged, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRanged_intersection(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = (FXRanged *) 0 ;
+  FXRanged *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXRanged result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRanged, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged const *","intersection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRanged,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRanged const &","intersection", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRanged const &","intersection", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRanged * >(argp2);
+  result = FXRanged_intersection((FXRanged const *)arg1,(FXRanged const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXRanged(static_cast< const FXRanged& >(result))), SWIGTYPE_p_FXRanged, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXSpheref;
+
+SWIGINTERN VALUE
+_wrap_FXSpheref_center_set(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = (FXSpheref *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpheref, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref *","center", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  if (arg1) (arg1)->center = *arg2;
+  delete arg2;
+  return Qnil;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpheref_center_get(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = (FXSpheref *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec3f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpheref, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref *","center", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  result = (FXVec3f *) & ((arg1)->center);
+  {
+    FXVec3f* resultptr = new FXVec3f(*result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpheref_radius_set(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = (FXSpheref *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpheref, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref *","radius", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","radius", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  if (arg1) (arg1)->radius = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpheref_radius_get(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = (FXSpheref *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpheref, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref *","radius", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  result = (FXfloat) ((arg1)->radius);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSpheref__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (FXSpheref *)new FXSpheref();
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSpheref__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXSpheref *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXSpheref,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref const &","FXSpheref", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSpheref const &","FXSpheref", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  result = (FXSpheref *)new FXSpheref((FXSpheref const &)*arg1);
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSpheref__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXVec3f *arg1 = 0 ;
+  FXfloat arg2 = (FXfloat) 0.0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  FXSpheref *result = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg1 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg1 = new FXVec3f(*p);
+    }
+  }
+  if (argc > 1) {
+    ecode2 = SWIG_AsVal_float(argv[1], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","FXSpheref", 2, argv[1] ));
+    } 
+    arg2 = static_cast< FXfloat >(val2);
+  }
+  result = (FXSpheref *)new FXSpheref((FXVec3f const &)*arg1,arg2);
+  DATA_PTR(self) = result;
+  delete arg1;
+  return self;
+fail:
+  delete arg1;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSpheref__SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXfloat arg1 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  FXfloat arg4 = (FXfloat) 0.0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  FXSpheref *result = 0 ;
+  
+  if ((argc < 3) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_float(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXfloat","FXSpheref", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXfloat >(val1);
+  ecode2 = SWIG_AsVal_float(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","FXSpheref", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","FXSpheref", 3, argv[2] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  if (argc > 3) {
+    ecode4 = SWIG_AsVal_float(argv[3], &val4);
+    if (!SWIG_IsOK(ecode4)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","FXSpheref", 4, argv[3] ));
+    } 
+    arg4 = static_cast< FXfloat >(val4);
+  }
+  result = (FXSpheref *)new FXSpheref(arg1,arg2,arg3,arg4);
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXSpheref_allocate(VALUE self)
+#else
+_wrap_FXSpheref_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXSpheref);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSpheref__SWIG_4(int argc, VALUE *argv, VALUE self) {
+  FXRangef *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXSpheref *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXRangef,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRangef const &","FXSpheref", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRangef const &","FXSpheref", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXRangef * >(argp1);
+  result = (FXSpheref *)new FXSpheref((FXRangef const &)*arg1);
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXSpheref(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 4) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_FXSpheref__SWIG_0(nargs, args, self);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSpheref, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXSpheref__SWIG_1(nargs, args, self);
+    }
+  }
+  if ((argc >= 1) && (argc <= 2)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      if (argc <= 1) {
+        return _wrap_new_FXSpheref__SWIG_2(nargs, args, self);
+      }
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_FXSpheref__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRangef, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXSpheref__SWIG_4(nargs, args, self);
+    }
+  }
+  if ((argc >= 3) && (argc <= 4)) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXSpheref__SWIG_3(nargs, args, self);
+          }
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_new_FXSpheref__SWIG_3(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXSpheref.new", 
+    "    FXSpheref.new()\n"
+    "    FXSpheref.new(FXSpheref const &sphere)\n"
+    "    FXSpheref.new(FXVec3f const &cen, FXfloat rad)\n"
+    "    FXSpheref.new(FXfloat x, FXfloat y, FXfloat z, FXfloat rad)\n"
+    "    FXSpheref.new(FXRangef const &bounds)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpheref_diameter(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = (FXSpheref *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpheref, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref const *","diameter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  result = (FXfloat)((FXSpheref const *)arg1)->diameter();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXSpheref.empty?
+
+  call-seq:
+    empty? -> bool
+
+Check if FXSpheref is empty.
+*/
+SWIGINTERN VALUE
+_wrap_FXSpheref_emptyq___(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = (FXSpheref *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpheref, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref const *","empty", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  result = (bool)((FXSpheref const *)arg1)->empty();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpheref_containsq_____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = (FXSpheref *) 0 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  FXfloat arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpheref, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","contains", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","contains", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  ecode4 = SWIG_AsVal_float(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","contains", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXfloat >(val4);
+  result = (bool)((FXSpheref const *)arg1)->contains(arg2,arg3,arg4);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpheref_containsq_____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = (FXSpheref *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpheref, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  result = (bool)((FXSpheref const *)arg1)->contains((FXVec3f const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpheref_containsq_____SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = (FXSpheref *) 0 ;
+  FXRangef *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpheref, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRangef,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRangef const &","contains", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRangef const &","contains", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRangef * >(argp2);
+  result = (bool)((FXSpheref const *)arg1)->contains((FXRangef const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpheref_containsq_____SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = (FXSpheref *) 0 ;
+  FXSpheref *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpheref, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXSpheref,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXSpheref const &","contains", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSpheref const &","contains", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXSpheref * >(argp2);
+  result = (bool)((FXSpheref const *)arg1)->contains((FXSpheref const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXSpheref_containsq___(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 5) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSpheref, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSpheref_containsq_____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSpheref, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRangef, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSpheref_containsq_____SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSpheref, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXSpheref, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSpheref_containsq_____SWIG_3(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSpheref, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_FXSpheref_containsq_____SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 5, "FXSpheref.contains?", 
+    "    bool FXSpheref.contains?(FXfloat x, FXfloat y, FXfloat z)\n"
+    "    bool FXSpheref.contains?(FXVec3f const &p)\n"
+    "    bool FXSpheref.contains?(FXRangef const &box)\n"
+    "    bool FXSpheref.contains?(FXSpheref const &sphere)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpheref_includeN_____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = (FXSpheref *) 0 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  FXfloat arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  FXSpheref *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpheref, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref *","include", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","include", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","include", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  ecode4 = SWIG_AsVal_float(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","include", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXfloat >(val4);
+  result = (FXSpheref *) &(arg1)->include(arg2,arg3,arg4);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSpheref, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpheref_includeN_____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = (FXSpheref *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXSpheref *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpheref, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref *","include", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  result = (FXSpheref *) &(arg1)->include((FXVec3f const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSpheref, 0 |  0 );
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpheref_includeInRadiusN_____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = (FXSpheref *) 0 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  FXfloat arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  FXSpheref *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpheref, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref *","includeInRadius", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","includeInRadius", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","includeInRadius", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  ecode4 = SWIG_AsVal_float(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","includeInRadius", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXfloat >(val4);
+  result = (FXSpheref *) &(arg1)->includeInRadius(arg2,arg3,arg4);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSpheref, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpheref_includeInRadiusN_____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = (FXSpheref *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXSpheref *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpheref, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref *","includeInRadius", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  result = (FXSpheref *) &(arg1)->includeInRadius((FXVec3f const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSpheref, 0 |  0 );
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpheref_includeN_____SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = (FXSpheref *) 0 ;
+  FXRangef *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXSpheref *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpheref, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref *","include", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRangef,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRangef const &","include", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRangef const &","include", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRangef * >(argp2);
+  result = (FXSpheref *) &(arg1)->include((FXRangef const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSpheref, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpheref_includeInRadiusN_____SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = (FXSpheref *) 0 ;
+  FXRangef *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXSpheref *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpheref, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref *","includeInRadius", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRangef,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRangef const &","includeInRadius", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRangef const &","includeInRadius", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRangef * >(argp2);
+  result = (FXSpheref *) &(arg1)->includeInRadius((FXRangef const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSpheref, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpheref_includeN_____SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = (FXSpheref *) 0 ;
+  FXSpheref *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXSpheref *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpheref, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref *","include", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXSpheref,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXSpheref const &","include", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSpheref const &","include", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXSpheref * >(argp2);
+  result = (FXSpheref *) &(arg1)->include((FXSpheref const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSpheref, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXSpheref_includeN___(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 5) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSpheref, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSpheref_includeN_____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSpheref, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRangef, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSpheref_includeN_____SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSpheref, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXSpheref, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSpheref_includeN_____SWIG_3(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSpheref, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_FXSpheref_includeN_____SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 5, "FXSpheref.include!", 
+    "    FXSpheref FXSpheref.include!(FXfloat x, FXfloat y, FXfloat z)\n"
+    "    FXSpheref FXSpheref.include!(FXVec3f const &p)\n"
+    "    FXSpheref FXSpheref.include!(FXRangef const &box)\n"
+    "    FXSpheref & FXSpheref.include!(FXSpheref const &sphere)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpheref_includeInRadiusN_____SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = (FXSpheref *) 0 ;
+  FXSpheref *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXSpheref *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpheref, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref *","includeInRadius", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXSpheref,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXSpheref const &","includeInRadius", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSpheref const &","includeInRadius", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXSpheref * >(argp2);
+  result = (FXSpheref *) &(arg1)->includeInRadius((FXSpheref const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSpheref, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXSpheref_includeInRadiusN___(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 5) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSpheref, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSpheref_includeInRadiusN_____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSpheref, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRangef, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSpheref_includeInRadiusN_____SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSpheref, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXSpheref, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSpheref_includeInRadiusN_____SWIG_3(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSpheref, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_FXSpheref_includeInRadiusN_____SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 5, "FXSpheref.includeInRadius!", 
+    "    FXSpheref FXSpheref.includeInRadius!(FXfloat x, FXfloat y, FXfloat z)\n"
+    "    FXSpheref FXSpheref.includeInRadius!(FXVec3f const &p)\n"
+    "    FXSpheref FXSpheref.includeInRadius!(FXRangef const &box)\n"
+    "    FXSpheref & FXSpheref.includeInRadius!(FXSpheref const &sphere)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpheref_intersect(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = (FXSpheref *) 0 ;
+  FXVec4f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpheref, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref const *","intersect", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg2 = new FXVec4f(*p);
+    }
+  }
+  result = (FXint)((FXSpheref const *)arg1)->intersect((FXVec4f const &)*arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  delete arg2;
+  return vresult;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpheref_intersectsq___(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = (FXSpheref *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  FXVec3f *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpheref, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref const *","intersect", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  {
+    if (TYPE(argv[1]) == T_ARRAY) {
+      arg3 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[1], 0)), NUM2DBL(rb_ary_entry(argv[1], 1)), NUM2DBL(rb_ary_entry(argv[1], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[1], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg3 = new FXVec3f(*p);
+    }
+  }
+  result = (bool)((FXSpheref const *)arg1)->intersect((FXVec3f const &)*arg2,(FXVec3f const &)*arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  delete arg2;
+  delete arg3;
+  return vresult;
+fail:
+  delete arg2;
+  delete arg3;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpheref_overlapsq_____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = (FXSpheref *) 0 ;
+  FXRangef *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpheref, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref const *","overlap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRangef,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRangef const &","overlap", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRangef const &","overlap", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRangef * >(argp2);
+  result = (bool)FXSpheref_overlap__SWIG_0((FXSpheref const *)arg1,(FXRangef const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpheref_overlapsq_____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXSpheref *arg1 = (FXSpheref *) 0 ;
+  FXSpheref *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpheref, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpheref const *","overlap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpheref * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXSpheref,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXSpheref const &","overlap", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSpheref const &","overlap", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXSpheref * >(argp2);
+  result = (bool)FXSpheref_overlap__SWIG_1((FXSpheref const *)arg1,(FXSpheref const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXSpheref_overlapsq___(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSpheref, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRangef, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSpheref_overlapsq_____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSpheref, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXSpheref, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSpheref_overlapsq_____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "overlaps?", 
+    "    bool overlaps?(FXRangef const &other)\n"
+    "    bool overlaps?(FXSpheref const &other)\n");
+  
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXSphered;
+
+SWIGINTERN VALUE
+_wrap_FXSphered_center_set(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = (FXSphered *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSphered, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered *","center", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","center", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","center", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  if (arg1) (arg1)->center = *arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSphered_center_get(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = (FXSphered *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec3d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSphered, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered *","center", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  result = (FXVec3d *) & ((arg1)->center);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXVec3d, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSphered_radius_set(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = (FXSphered *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSphered, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered *","radius", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","radius", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->radius = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSphered_radius_get(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = (FXSphered *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSphered, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered *","radius", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  result = (FXdouble) ((arg1)->radius);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSphered__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSphered *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (FXSphered *)new FXSphered();
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSphered__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXSphered *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXSphered,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered const &","FXSphered", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSphered const &","FXSphered", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  result = (FXSphered *)new FXSphered((FXSphered const &)*arg1);
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSphered__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXVec3d *arg1 = 0 ;
+  FXdouble arg2 = (FXdouble) 0.0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  FXSphered *result = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec3d const &","FXSphered", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","FXSphered", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXVec3d * >(argp1);
+  if (argc > 1) {
+    ecode2 = SWIG_AsVal_double(argv[1], &val2);
+    if (!SWIG_IsOK(ecode2)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","FXSphered", 2, argv[1] ));
+    } 
+    arg2 = static_cast< FXdouble >(val2);
+  }
+  result = (FXSphered *)new FXSphered((FXVec3d const &)*arg1,arg2);
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSphered__SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXdouble arg1 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  FXdouble arg4 = (FXdouble) 0.0 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  FXSphered *result = 0 ;
+  
+  if ((argc < 3) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXdouble","FXSphered", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXdouble >(val1);
+  ecode2 = SWIG_AsVal_double(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","FXSphered", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","FXSphered", 3, argv[2] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  if (argc > 3) {
+    ecode4 = SWIG_AsVal_double(argv[3], &val4);
+    if (!SWIG_IsOK(ecode4)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","FXSphered", 4, argv[3] ));
+    } 
+    arg4 = static_cast< FXdouble >(val4);
+  }
+  result = (FXSphered *)new FXSphered(arg1,arg2,arg3,arg4);
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXSphered_allocate(VALUE self)
+#else
+_wrap_FXSphered_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXSphered);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSphered__SWIG_4(int argc, VALUE *argv, VALUE self) {
+  FXRanged *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXSphered *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXRanged,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRanged const &","FXSphered", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRanged const &","FXSphered", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXRanged * >(argp1);
+  result = (FXSphered *)new FXSphered((FXRanged const &)*arg1);
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXSphered(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 4) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_FXSphered__SWIG_0(nargs, args, self);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSphered, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXSphered__SWIG_1(nargs, args, self);
+    }
+  }
+  if ((argc >= 1) && (argc <= 2)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec3d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      if (argc <= 1) {
+        return _wrap_new_FXSphered__SWIG_2(nargs, args, self);
+      }
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_FXSphered__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRanged, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXSphered__SWIG_4(nargs, args, self);
+    }
+  }
+  if ((argc >= 3) && (argc <= 4)) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXSphered__SWIG_3(nargs, args, self);
+          }
+          {
+            int res = SWIG_AsVal_double(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_new_FXSphered__SWIG_3(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXSphered.new", 
+    "    FXSphered.new()\n"
+    "    FXSphered.new(FXSphered const &sphere)\n"
+    "    FXSphered.new(FXVec3d const &cen, FXdouble rad)\n"
+    "    FXSphered.new(FXdouble x, FXdouble y, FXdouble z, FXdouble rad)\n"
+    "    FXSphered.new(FXRanged const &bounds)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSphered_diameter(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = (FXSphered *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSphered, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered const *","diameter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  result = (FXdouble)((FXSphered const *)arg1)->diameter();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXSphered.empty?
+
+  call-seq:
+    empty? -> bool
+
+Check if FXSphered is empty.
+*/
+SWIGINTERN VALUE
+_wrap_FXSphered_emptyq___(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = (FXSphered *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSphered, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered const *","empty", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  result = (bool)((FXSphered const *)arg1)->empty();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSphered_containsq_____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = (FXSphered *) 0 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  FXdouble arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSphered, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","contains", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","contains", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  ecode4 = SWIG_AsVal_double(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","contains", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXdouble >(val4);
+  result = (bool)((FXSphered const *)arg1)->contains(arg2,arg3,arg4);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSphered_containsq_____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = (FXSphered *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSphered, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","contains", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","contains", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  result = (bool)((FXSphered const *)arg1)->contains((FXVec3d const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSphered_containsq_____SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = (FXSphered *) 0 ;
+  FXRanged *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSphered, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRanged,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRanged const &","contains", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRanged const &","contains", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRanged * >(argp2);
+  result = (bool)((FXSphered const *)arg1)->contains((FXRanged const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSphered_containsq_____SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = (FXSphered *) 0 ;
+  FXSphered *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSphered, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXSphered,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXSphered const &","contains", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSphered const &","contains", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXSphered * >(argp2);
+  result = (bool)((FXSphered const *)arg1)->contains((FXSphered const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXSphered_containsq___(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 5) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSphered, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSphered_containsq_____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSphered, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRanged, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSphered_containsq_____SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSphered, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXSphered, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSphered_containsq_____SWIG_3(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSphered, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_double(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_FXSphered_containsq_____SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 5, "FXSphered.contains?", 
+    "    bool FXSphered.contains?(FXdouble x, FXdouble y, FXdouble z)\n"
+    "    bool FXSphered.contains?(FXVec3d const &p)\n"
+    "    bool FXSphered.contains?(FXRanged const &box)\n"
+    "    bool FXSphered.contains?(FXSphered const &sphere)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSphered_includeN_____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = (FXSphered *) 0 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  FXdouble arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  FXSphered *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSphered, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered *","include", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","include", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","include", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  ecode4 = SWIG_AsVal_double(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","include", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXdouble >(val4);
+  result = (FXSphered *) &(arg1)->include(arg2,arg3,arg4);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSphered, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSphered_includeN_____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = (FXSphered *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXSphered *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSphered, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered *","include", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","include", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","include", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  result = (FXSphered *) &(arg1)->include((FXVec3d const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSphered, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSphered_includeInRadiusN_____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = (FXSphered *) 0 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  FXdouble arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  FXSphered *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSphered, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered *","includeInRadius", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","includeInRadius", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","includeInRadius", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  ecode4 = SWIG_AsVal_double(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","includeInRadius", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXdouble >(val4);
+  result = (FXSphered *) &(arg1)->includeInRadius(arg2,arg3,arg4);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSphered, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSphered_includeInRadiusN_____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = (FXSphered *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXSphered *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSphered, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered *","includeInRadius", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","includeInRadius", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","includeInRadius", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  result = (FXSphered *) &(arg1)->includeInRadius((FXVec3d const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSphered, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSphered_includeN_____SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = (FXSphered *) 0 ;
+  FXRanged *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXSphered *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSphered, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered *","include", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRanged,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRanged const &","include", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRanged const &","include", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRanged * >(argp2);
+  result = (FXSphered *) &(arg1)->include((FXRanged const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSphered, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSphered_includeInRadiusN_____SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = (FXSphered *) 0 ;
+  FXRanged *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXSphered *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSphered, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered *","includeInRadius", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRanged,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRanged const &","includeInRadius", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRanged const &","includeInRadius", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRanged * >(argp2);
+  result = (FXSphered *) &(arg1)->includeInRadius((FXRanged const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSphered, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSphered_includeN_____SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = (FXSphered *) 0 ;
+  FXSphered *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXSphered *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSphered, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered *","include", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXSphered,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXSphered const &","include", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSphered const &","include", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXSphered * >(argp2);
+  result = (FXSphered *) &(arg1)->include((FXSphered const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSphered, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXSphered_includeN___(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 5) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSphered, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSphered_includeN_____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSphered, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRanged, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSphered_includeN_____SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSphered, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXSphered, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSphered_includeN_____SWIG_3(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSphered, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_double(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_FXSphered_includeN_____SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 5, "FXSphered.include!", 
+    "    FXSphered FXSphered.include!(FXdouble x, FXdouble y, FXdouble z)\n"
+    "    FXSphered FXSphered.include!(FXVec3d const &p)\n"
+    "    FXSphered FXSphered.include!(FXRanged const &box)\n"
+    "    FXSphered & FXSphered.include!(FXSphered const &sphere)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSphered_includeInRadiusN_____SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = (FXSphered *) 0 ;
+  FXSphered *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXSphered *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSphered, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered *","includeInRadius", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXSphered,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXSphered const &","includeInRadius", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSphered const &","includeInRadius", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXSphered * >(argp2);
+  result = (FXSphered *) &(arg1)->includeInRadius((FXSphered const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXSphered, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXSphered_includeInRadiusN___(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 5) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSphered, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec3d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSphered_includeInRadiusN_____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSphered, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRanged, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSphered_includeInRadiusN_____SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSphered, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXSphered, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSphered_includeInRadiusN_____SWIG_3(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSphered, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_double(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_FXSphered_includeInRadiusN_____SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 5, "FXSphered.includeInRadius!", 
+    "    FXSphered FXSphered.includeInRadius!(FXdouble x, FXdouble y, FXdouble z)\n"
+    "    FXSphered FXSphered.includeInRadius!(FXVec3d const &p)\n"
+    "    FXSphered FXSphered.includeInRadius!(FXRanged const &box)\n"
+    "    FXSphered & FXSphered.includeInRadius!(FXSphered const &sphere)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSphered_intersect(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = (FXSphered *) 0 ;
+  FXVec4d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSphered, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered const *","intersect", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec4d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec4d const &","intersect", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec4d const &","intersect", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec4d * >(argp2);
+  result = (FXint)((FXSphered const *)arg1)->intersect((FXVec4d const &)*arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSphered_intersectsq___(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = (FXSphered *) 0 ;
+  FXVec3d *arg2 = 0 ;
+  FXVec3d *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSphered, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered const *","intersect", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3d const &","intersect", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","intersect", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec3d * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXVec3d,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXVec3d const &","intersect", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3d const &","intersect", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXVec3d * >(argp3);
+  result = (bool)((FXSphered const *)arg1)->intersect((FXVec3d const &)*arg2,(FXVec3d const &)*arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSphered_overlapsq_____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = (FXSphered *) 0 ;
+  FXRanged *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSphered, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered const *","overlap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRanged,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRanged const &","overlap", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRanged const &","overlap", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRanged * >(argp2);
+  result = (bool)FXSphered_overlap__SWIG_0((FXSphered const *)arg1,(FXRanged const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSphered_overlapsq_____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXSphered *arg1 = (FXSphered *) 0 ;
+  FXSphered *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSphered, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSphered const *","overlap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSphered * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXSphered,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXSphered const &","overlap", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXSphered const &","overlap", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXSphered * >(argp2);
+  result = (bool)FXSphered_overlap__SWIG_1((FXSphered const *)arg1,(FXSphered const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXSphered_overlapsq___(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSphered, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRanged, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSphered_overlapsq_____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSphered, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXSphered, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSphered_overlapsq_____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "overlaps?", 
+    "    bool overlaps?(FXRanged const &other)\n"
+    "    bool overlaps?(FXSphered const &other)\n");
+  
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXGLVisual;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXGLVisual_allocate(VALUE self)
+#else
+_wrap_FXGLVisual_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXGLVisual);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXGLVisual(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXGLVisual *result = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXGLVisual", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  arg2 = NUM2UINT(argv[1]);
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXGLVisual *)new_FXGLVisual(arg1,arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_supported(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXGLVisual_supported", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  result = (VALUE)FXGLVisual_supported(arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_getRedSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","getRedSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXint)((FXGLVisual const *)arg1)->getRedSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_getGreenSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","getGreenSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXint)((FXGLVisual const *)arg1)->getGreenSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_getBlueSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","getBlueSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXint)((FXGLVisual const *)arg1)->getBlueSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_getAlphaSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","getAlphaSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXint)((FXGLVisual const *)arg1)->getAlphaSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_getDepthSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","getDepthSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXint)((FXGLVisual const *)arg1)->getDepthSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_getStencilSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","getStencilSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXint)((FXGLVisual const *)arg1)->getStencilSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_getAccumRedSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","getAccumRedSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXint)((FXGLVisual const *)arg1)->getAccumRedSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_getAccumGreenSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","getAccumGreenSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXint)((FXGLVisual const *)arg1)->getAccumGreenSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_getAccumBlueSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","getAccumBlueSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXint)((FXGLVisual const *)arg1)->getAccumBlueSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_getAccumAlphaSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","getAccumAlphaSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXint)((FXGLVisual const *)arg1)->getAccumAlphaSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_setRedSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual *","setRedSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setRedSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_setGreenSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual *","setGreenSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setGreenSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_setBlueSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual *","setBlueSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setBlueSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_setAlphaSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual *","setAlphaSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setAlphaSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_setDepthSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual *","setDepthSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setDepthSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_setStencilSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual *","setStencilSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setStencilSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_setAccumRedSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual *","setAccumRedSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setAccumRedSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_setAccumGreenSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual *","setAccumGreenSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setAccumGreenSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_setAccumBlueSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual *","setAccumBlueSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setAccumBlueSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_setAccumAlphaSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual *","setAccumAlphaSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setAccumAlphaSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_getActualRedSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","getActualRedSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXint)((FXGLVisual const *)arg1)->getActualRedSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_getActualGreenSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","getActualGreenSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXint)((FXGLVisual const *)arg1)->getActualGreenSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_getActualBlueSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","getActualBlueSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXint)((FXGLVisual const *)arg1)->getActualBlueSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_getActualAlphaSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","getActualAlphaSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXint)((FXGLVisual const *)arg1)->getActualAlphaSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_getActualDepthSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","getActualDepthSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXint)((FXGLVisual const *)arg1)->getActualDepthSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_getActualStencilSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","getActualStencilSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXint)((FXGLVisual const *)arg1)->getActualStencilSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_getActualAccumRedSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","getActualAccumRedSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXint)((FXGLVisual const *)arg1)->getActualAccumRedSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_getActualAccumGreenSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","getActualAccumGreenSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXint)((FXGLVisual const *)arg1)->getActualAccumGreenSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_getActualAccumBlueSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","getActualAccumBlueSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXint)((FXGLVisual const *)arg1)->getActualAccumBlueSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_getActualAccumAlphaSize(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","getActualAccumAlphaSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXint)((FXGLVisual const *)arg1)->getActualAccumAlphaSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_isDoubleBuffer(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","isDoubleBuffer", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXbool)((FXGLVisual const *)arg1)->isDoubleBuffer();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_isStereo(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","isStereo", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXbool)((FXGLVisual const *)arg1)->isStereo();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_isAccelerated(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","isAccelerated", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXbool)((FXGLVisual const *)arg1)->isAccelerated();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_isBufferSwapCopy(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","isBufferSwapCopy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  result = (FXbool)((FXGLVisual const *)arg1)->isBufferSwapCopy();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_save(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXGLVisual_save((FXGLVisual const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_load(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXGLVisual_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_create(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  FXGLVisual_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_detach(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  FXGLVisual_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLVisual_destroy(int argc, VALUE *argv, VALUE self) {
+  FXGLVisual *arg1 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLVisual *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLVisual * >(argp1);
+  FXGLVisual_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_glUseFXFont(int argc, VALUE *argv, VALUE self) {
+  FXFont *arg1 = (FXFont *) 0 ;
+  int arg2 ;
+  int arg3 ;
+  int arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  int val4 ;
+  int ecode4 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFont *","glUseFXFont", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXFont * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","glUseFXFont", 2, argv[1] ));
+  } 
+  arg2 = static_cast< int >(val2);
+  ecode3 = SWIG_AsVal_int(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","glUseFXFont", 3, argv[2] ));
+  } 
+  arg3 = static_cast< int >(val3);
+  ecode4 = SWIG_AsVal_int(argv[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","glUseFXFont", 4, argv[3] ));
+  } 
+  arg4 = static_cast< int >(val4);
+  glUseFXFont(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXGLContext;
+
+SWIGINTERN VALUE
+_wrap_new_FXGLContext__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXGLVisual *arg2 = (FXGLVisual *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXGLContext *result = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXGLContext", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXGLVisual *","FXGLContext", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXGLVisual * >(argp2);
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXGLContext *)new_FXGLContext__SWIG_0(arg1,arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXGLContext_allocate(VALUE self)
+#else
+_wrap_FXGLContext_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXGLContext);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXGLContext__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXGLVisual *arg2 = (FXGLVisual *) 0 ;
+  FXGLContext *arg3 = (FXGLContext *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXGLContext *result = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXGLContext", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXGLVisual *","FXGLContext", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXGLVisual * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXGLContext, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXGLContext *","FXGLContext", 3, argv[2] )); 
+  }
+  arg3 = reinterpret_cast< FXGLContext * >(argp3);
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXGLContext *)new_FXGLContext__SWIG_1(arg1,arg2,arg3);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXGLContext(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 3) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXGLVisual, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_FXGLContext__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXApp, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXGLVisual, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXGLContext, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_new_FXGLContext__SWIG_1(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "FXGLContext.new", 
+    "    FXGLContext.new(FXApp *a, FXGLVisual *vis)\n"
+    "    FXGLContext.new(FXApp *a, FXGLVisual *vis, FXGLContext *shared)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLContext_isShared(int argc, VALUE *argv, VALUE self) {
+  FXGLContext *arg1 = (FXGLContext *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLContext, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLContext const *","isShared", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLContext * >(argp1);
+  result = (FXbool)((FXGLContext const *)arg1)->isShared();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLContext_getVisual(int argc, VALUE *argv, VALUE self) {
+  FXGLContext *arg1 = (FXGLContext *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXGLVisual *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLContext, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLContext const *","getVisual", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLContext * >(argp1);
+  result = (FXGLVisual *)((FXGLContext const *)arg1)->getVisual();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXGLVisual, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLContext_begin(int argc, VALUE *argv, VALUE self) {
+  FXGLContext *arg1 = (FXGLContext *) 0 ;
+  FXDrawable *arg2 = (FXDrawable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLContext, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLContext *","begin", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLContext * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXDrawable, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDrawable *","begin", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXDrawable * >(argp2);
+  result = (FXbool)(arg1)->begin(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLContext_end(int argc, VALUE *argv, VALUE self) {
+  FXGLContext *arg1 = (FXGLContext *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLContext, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLContext *","end", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLContext * >(argp1);
+  result = (FXbool)(arg1)->end();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLContext_swapBuffers(int argc, VALUE *argv, VALUE self) {
+  FXGLContext *arg1 = (FXGLContext *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLContext, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLContext *","swapBuffers", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLContext * >(argp1);
+  (arg1)->swapBuffers();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLContext_swapSubBuffers(int argc, VALUE *argv, VALUE self) {
+  FXGLContext *arg1 = (FXGLContext *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLContext, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLContext *","swapSubBuffers", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLContext * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  (arg1)->swapSubBuffers(arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLContext_save(int argc, VALUE *argv, VALUE self) {
+  FXGLContext *arg1 = (FXGLContext *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLContext, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLContext const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLContext * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXGLContext_save((FXGLContext const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLContext_load(int argc, VALUE *argv, VALUE self) {
+  FXGLContext *arg1 = (FXGLContext *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLContext, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLContext *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLContext * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXGLContext_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLContext_create(int argc, VALUE *argv, VALUE self) {
+  FXGLContext *arg1 = (FXGLContext *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLContext, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLContext *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLContext * >(argp1);
+  FXGLContext_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLContext_detach(int argc, VALUE *argv, VALUE self) {
+  FXGLContext *arg1 = (FXGLContext *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLContext, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLContext *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLContext * >(argp1);
+  FXGLContext_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLContext_destroy(int argc, VALUE *argv, VALUE self) {
+  FXGLContext *arg1 = (FXGLContext *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLContext, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLContext *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLContext * >(argp1);
+  FXGLContext_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXGLCanvas;
+
+SWIGINTERN VALUE
+_wrap_new_FXGLCanvas__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXGLVisual *arg2 = (FXGLVisual *) 0 ;
+  FXObject *arg3 = (FXObject *) 0 ;
+  FXSelector arg4 = (FXSelector) 0 ;
+  FXuint arg5 = (FXuint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXGLCanvas *result = 0 ;
+  
+  if ((argc < 2) || (argc > 9)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXGLCanvas", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXGLVisual *","FXGLCanvas", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXGLVisual * >(argp2);
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXObject *","FXGLCanvas", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXObject * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXGLCanvas *)new_FXGLCanvas__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXGLCanvas_allocate(VALUE self)
+#else
+_wrap_FXGLCanvas_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXGLCanvas);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXGLCanvas__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXGLVisual *arg2 = (FXGLVisual *) 0 ;
+  FXGLCanvas *arg3 = (FXGLCanvas *) 0 ;
+  FXObject *arg4 = (FXObject *) 0 ;
+  FXSelector arg5 = (FXSelector) 0 ;
+  FXuint arg6 = (FXuint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXGLCanvas *result = 0 ;
+  
+  if ((argc < 3) || (argc > 10)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXGLCanvas", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXGLVisual *","FXGLCanvas", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXGLVisual * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXGLCanvas *","FXGLCanvas", 3, argv[2] )); 
+  }
+  arg3 = reinterpret_cast< FXGLCanvas * >(argp3);
+  if (argc > 3) {
+    res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXObject *","FXGLCanvas", 4, argv[3] )); 
+    }
+    arg4 = reinterpret_cast< FXObject * >(argp4);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2UINT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXGLCanvas *)new_FXGLCanvas__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXGLCanvas(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[10];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 10) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 2) && (argc <= 9)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComposite, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXGLVisual, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_new_FXGLCanvas__SWIG_0(nargs, args, self);
+        }
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXObject, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXGLCanvas__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXGLCanvas__SWIG_0(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXGLCanvas__SWIG_0(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXGLCanvas__SWIG_0(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  if (argc <= 7) {
+                    return _wrap_new_FXGLCanvas__SWIG_0(nargs, args, self);
+                  }
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    if (argc <= 8) {
+                      return _wrap_new_FXGLCanvas__SWIG_0(nargs, args, self);
+                    }
+                    {
+                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
+                    }
+                    if (_v) {
+                      return _wrap_new_FXGLCanvas__SWIG_0(nargs, args, self);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 3) && (argc <= 10)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComposite, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXGLVisual, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXGLCanvas, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXGLCanvas__SWIG_1(nargs, args, self);
+          }
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXObject, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXGLCanvas__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXGLCanvas__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXGLCanvas__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  if (argc <= 7) {
+                    return _wrap_new_FXGLCanvas__SWIG_1(nargs, args, self);
+                  }
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    if (argc <= 8) {
+                      return _wrap_new_FXGLCanvas__SWIG_1(nargs, args, self);
+                    }
+                    {
+                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
+                    }
+                    if (_v) {
+                      if (argc <= 9) {
+                        return _wrap_new_FXGLCanvas__SWIG_1(nargs, args, self);
+                      }
+                      {
+                        _v = (TYPE(argv[9]) == T_FIXNUM || TYPE(argv[9]) == T_BIGNUM) ? 1 : 0;
+                      }
+                      if (_v) {
+                        return _wrap_new_FXGLCanvas__SWIG_1(nargs, args, self);
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 10, "FXGLCanvas.new", 
+    "    FXGLCanvas.new(FXComposite *p, FXGLVisual *vis, FXObject *tgt, FXSelector sel, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n"
+    "    FXGLCanvas.new(FXComposite *p, FXGLVisual *vis, FXGLCanvas *sharegroup, FXObject *tgt, FXSelector sel, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_sharedq___(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas const *","isShared", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  result = (FXbool)((FXGLCanvas const *)arg1)->isShared();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_getCurrentContext(int argc, VALUE *argv, VALUE self) {
+  FXuval result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (FXuval)FXGLCanvas_getCurrentContext();
+  vresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_getContext(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuval result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas const *","getContext", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  result = (FXuval)FXGLCanvas_getContext((FXGLCanvas const *)arg1);
+  vresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_save(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXGLCanvas_save((FXGLCanvas const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_load(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXGLCanvas_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_create(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  FXGLCanvas_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_detach(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  FXGLCanvas_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_destroy(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  FXGLCanvas_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_resize(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXGLCanvas_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  result = (FXint)FXGLCanvas_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  result = (FXint)FXGLCanvas_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXGLCanvas_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXGLCanvas_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  result = (bool)FXGLCanvas_canFocus((FXGLCanvas const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  FXGLCanvas_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  FXGLCanvas_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXGLCanvas_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXGLCanvas_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_enable(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  FXGLCanvas_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_disable(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  FXGLCanvas_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  FXGLCanvas_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_lower(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  FXGLCanvas_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_move(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXGLCanvas_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_position(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXGLCanvas_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_layout(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  FXGLCanvas_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_recalc(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  FXGLCanvas_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_reparent(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXGLCanvas_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_show(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  FXGLCanvas_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_hide(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  FXGLCanvas_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  result = (bool)FXGLCanvas_isComposite((FXGLCanvas const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_contains(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXGLCanvas_contains((FXGLCanvas const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  result = (bool)FXGLCanvas_doesSaveUnder((FXGLCanvas const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXGLCanvas_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_tr(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXGLCanvas_tr((FXGLCanvas const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  FXGLCanvas_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  FXGLCanvas_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXGLCanvas_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXGLCanvas_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXGLCanvas_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXGLCanvas_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXGLCanvas, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXGLCanvas_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXGLCanvas, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXGLCanvas_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXGLCanvas, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXGLCanvas_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  FXGLCanvas_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_makeCurrent(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","makeCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  result = (FXbool)FXGLCanvas_makeCurrent(arg1);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_makeNonCurrent(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","makeNonCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  result = (FXbool)FXGLCanvas_makeNonCurrent(arg1);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_isCurrent(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas const *","isCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  result = (FXbool)FXGLCanvas_isCurrent((FXGLCanvas const *)arg1);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLCanvas_swapBuffers(int argc, VALUE *argv, VALUE self) {
+  FXGLCanvas *arg1 = (FXGLCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLCanvas *","swapBuffers", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLCanvas * >(argp1);
+  FXGLCanvas_swapBuffers(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXViewport;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXViewport_allocate(VALUE self)
+#else
+_wrap_FXViewport_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXViewport);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXViewport(int argc, VALUE *argv, VALUE self) {
+  FXViewport *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (FXViewport *)new FXViewport();
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXViewport_w_set(int argc, VALUE *argv, VALUE self) {
+  FXViewport *arg1 = (FXViewport *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXViewport, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXViewport *","w", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXViewport * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->w = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXViewport_w_get(int argc, VALUE *argv, VALUE self) {
+  FXViewport *arg1 = (FXViewport *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXViewport, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXViewport *","w", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXViewport * >(argp1);
+  result = (FXint) ((arg1)->w);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXViewport_h_set(int argc, VALUE *argv, VALUE self) {
+  FXViewport *arg1 = (FXViewport *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXViewport, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXViewport *","h", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXViewport * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->h = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXViewport_h_get(int argc, VALUE *argv, VALUE self) {
+  FXViewport *arg1 = (FXViewport *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXViewport, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXViewport *","h", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXViewport * >(argp1);
+  result = (FXint) ((arg1)->h);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXViewport_left_set(int argc, VALUE *argv, VALUE self) {
+  FXViewport *arg1 = (FXViewport *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXViewport, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXViewport *","left", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXViewport * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","left", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->left = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXViewport_left_get(int argc, VALUE *argv, VALUE self) {
+  FXViewport *arg1 = (FXViewport *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXViewport, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXViewport *","left", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXViewport * >(argp1);
+  result = (FXdouble) ((arg1)->left);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXViewport_right_set(int argc, VALUE *argv, VALUE self) {
+  FXViewport *arg1 = (FXViewport *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXViewport, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXViewport *","right", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXViewport * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","right", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->right = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXViewport_right_get(int argc, VALUE *argv, VALUE self) {
+  FXViewport *arg1 = (FXViewport *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXViewport, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXViewport *","right", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXViewport * >(argp1);
+  result = (FXdouble) ((arg1)->right);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXViewport_bottom_set(int argc, VALUE *argv, VALUE self) {
+  FXViewport *arg1 = (FXViewport *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXViewport, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXViewport *","bottom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXViewport * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","bottom", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->bottom = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXViewport_bottom_get(int argc, VALUE *argv, VALUE self) {
+  FXViewport *arg1 = (FXViewport *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXViewport, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXViewport *","bottom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXViewport * >(argp1);
+  result = (FXdouble) ((arg1)->bottom);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXViewport_top_set(int argc, VALUE *argv, VALUE self) {
+  FXViewport *arg1 = (FXViewport *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXViewport, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXViewport *","top", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXViewport * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","top", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->top = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXViewport_top_get(int argc, VALUE *argv, VALUE self) {
+  FXViewport *arg1 = (FXViewport *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXViewport, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXViewport *","top", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXViewport * >(argp1);
+  result = (FXdouble) ((arg1)->top);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXViewport_hither_set(int argc, VALUE *argv, VALUE self) {
+  FXViewport *arg1 = (FXViewport *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXViewport, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXViewport *","hither", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXViewport * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","hither", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->hither = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXViewport_hither_get(int argc, VALUE *argv, VALUE self) {
+  FXViewport *arg1 = (FXViewport *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXViewport, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXViewport *","hither", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXViewport * >(argp1);
+  result = (FXdouble) ((arg1)->hither);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXViewport_yon_set(int argc, VALUE *argv, VALUE self) {
+  FXViewport *arg1 = (FXViewport *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXViewport, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXViewport *","yon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXViewport * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","yon", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (arg1) (arg1)->yon = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXViewport_yon_get(int argc, VALUE *argv, VALUE self) {
+  FXViewport *arg1 = (FXViewport *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXViewport, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXViewport *","yon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXViewport * >(argp1);
+  result = (FXdouble) ((arg1)->yon);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXLight;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXLight_allocate(VALUE self)
+#else
+_wrap_FXLight_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXLight);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXLight(int argc, VALUE *argv, VALUE self) {
+  FXLight *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (FXLight *)new FXLight();
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLight_ambient_set(int argc, VALUE *argv, VALUE self) {
+  FXLight *arg1 = (FXLight *) 0 ;
+  FXVec4f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLight, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLight *","ambient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLight * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg2 = new FXVec4f(*p);
+    }
+  }
+  if (arg1) (arg1)->ambient = *arg2;
+  delete arg2;
+  return Qnil;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLight_ambient_get(int argc, VALUE *argv, VALUE self) {
+  FXLight *arg1 = (FXLight *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLight, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLight *","ambient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLight * >(argp1);
+  result = (FXVec4f *) & ((arg1)->ambient);
+  {
+    FXVec4f* resultptr = new FXVec4f(*result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLight_diffuse_set(int argc, VALUE *argv, VALUE self) {
+  FXLight *arg1 = (FXLight *) 0 ;
+  FXVec4f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLight, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLight *","diffuse", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLight * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg2 = new FXVec4f(*p);
+    }
+  }
+  if (arg1) (arg1)->diffuse = *arg2;
+  delete arg2;
+  return Qnil;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLight_diffuse_get(int argc, VALUE *argv, VALUE self) {
+  FXLight *arg1 = (FXLight *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLight, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLight *","diffuse", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLight * >(argp1);
+  result = (FXVec4f *) & ((arg1)->diffuse);
+  {
+    FXVec4f* resultptr = new FXVec4f(*result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLight_specular_set(int argc, VALUE *argv, VALUE self) {
+  FXLight *arg1 = (FXLight *) 0 ;
+  FXVec4f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLight, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLight *","specular", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLight * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg2 = new FXVec4f(*p);
+    }
+  }
+  if (arg1) (arg1)->specular = *arg2;
+  delete arg2;
+  return Qnil;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLight_specular_get(int argc, VALUE *argv, VALUE self) {
+  FXLight *arg1 = (FXLight *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLight, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLight *","specular", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLight * >(argp1);
+  result = (FXVec4f *) & ((arg1)->specular);
+  {
+    FXVec4f* resultptr = new FXVec4f(*result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLight_position_set(int argc, VALUE *argv, VALUE self) {
+  FXLight *arg1 = (FXLight *) 0 ;
+  FXVec4f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLight, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLight *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLight * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg2 = new FXVec4f(*p);
+    }
+  }
+  if (arg1) (arg1)->position = *arg2;
+  delete arg2;
+  return Qnil;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLight_position_get(int argc, VALUE *argv, VALUE self) {
+  FXLight *arg1 = (FXLight *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLight, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLight *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLight * >(argp1);
+  result = (FXVec4f *) & ((arg1)->position);
+  {
+    FXVec4f* resultptr = new FXVec4f(*result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLight_direction_set(int argc, VALUE *argv, VALUE self) {
+  FXLight *arg1 = (FXLight *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLight, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLight *","direction", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLight * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  if (arg1) (arg1)->direction = *arg2;
+  delete arg2;
+  return Qnil;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLight_direction_get(int argc, VALUE *argv, VALUE self) {
+  FXLight *arg1 = (FXLight *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec3f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLight, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLight *","direction", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLight * >(argp1);
+  result = (FXVec3f *) & ((arg1)->direction);
+  {
+    FXVec3f* resultptr = new FXVec3f(*result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLight_exponent_set(int argc, VALUE *argv, VALUE self) {
+  FXLight *arg1 = (FXLight *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLight, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLight *","exponent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLight * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","exponent", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  if (arg1) (arg1)->exponent = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLight_exponent_get(int argc, VALUE *argv, VALUE self) {
+  FXLight *arg1 = (FXLight *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLight, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLight *","exponent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLight * >(argp1);
+  result = (FXfloat) ((arg1)->exponent);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLight_cutoff_set(int argc, VALUE *argv, VALUE self) {
+  FXLight *arg1 = (FXLight *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLight, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLight *","cutoff", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLight * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","cutoff", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  if (arg1) (arg1)->cutoff = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLight_cutoff_get(int argc, VALUE *argv, VALUE self) {
+  FXLight *arg1 = (FXLight *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLight, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLight *","cutoff", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLight * >(argp1);
+  result = (FXfloat) ((arg1)->cutoff);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLight_c_attn_set(int argc, VALUE *argv, VALUE self) {
+  FXLight *arg1 = (FXLight *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLight, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLight *","c_attn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLight * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","c_attn", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  if (arg1) (arg1)->c_attn = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLight_c_attn_get(int argc, VALUE *argv, VALUE self) {
+  FXLight *arg1 = (FXLight *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLight, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLight *","c_attn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLight * >(argp1);
+  result = (FXfloat) ((arg1)->c_attn);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLight_l_attn_set(int argc, VALUE *argv, VALUE self) {
+  FXLight *arg1 = (FXLight *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLight, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLight *","l_attn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLight * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","l_attn", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  if (arg1) (arg1)->l_attn = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLight_l_attn_get(int argc, VALUE *argv, VALUE self) {
+  FXLight *arg1 = (FXLight *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLight, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLight *","l_attn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLight * >(argp1);
+  result = (FXfloat) ((arg1)->l_attn);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLight_q_attn_set(int argc, VALUE *argv, VALUE self) {
+  FXLight *arg1 = (FXLight *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLight, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLight *","q_attn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLight * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","q_attn", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  if (arg1) (arg1)->q_attn = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLight_q_attn_get(int argc, VALUE *argv, VALUE self) {
+  FXLight *arg1 = (FXLight *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLight, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLight *","q_attn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLight * >(argp1);
+  result = (FXfloat) ((arg1)->q_attn);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMaterial;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMaterial_allocate(VALUE self)
+#else
+_wrap_FXMaterial_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMaterial);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMaterial(int argc, VALUE *argv, VALUE self) {
+  FXMaterial *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (FXMaterial *)new FXMaterial();
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMaterial_ambient_set(int argc, VALUE *argv, VALUE self) {
+  FXMaterial *arg1 = (FXMaterial *) 0 ;
+  FXVec4f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMaterial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMaterial *","ambient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMaterial * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg2 = new FXVec4f(*p);
+    }
+  }
+  if (arg1) (arg1)->ambient = *arg2;
+  delete arg2;
+  return Qnil;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMaterial_ambient_get(int argc, VALUE *argv, VALUE self) {
+  FXMaterial *arg1 = (FXMaterial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMaterial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMaterial *","ambient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMaterial * >(argp1);
+  result = (FXVec4f *) & ((arg1)->ambient);
+  {
+    FXVec4f* resultptr = new FXVec4f(*result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMaterial_diffuse_set(int argc, VALUE *argv, VALUE self) {
+  FXMaterial *arg1 = (FXMaterial *) 0 ;
+  FXVec4f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMaterial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMaterial *","diffuse", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMaterial * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg2 = new FXVec4f(*p);
+    }
+  }
+  if (arg1) (arg1)->diffuse = *arg2;
+  delete arg2;
+  return Qnil;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMaterial_diffuse_get(int argc, VALUE *argv, VALUE self) {
+  FXMaterial *arg1 = (FXMaterial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMaterial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMaterial *","diffuse", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMaterial * >(argp1);
+  result = (FXVec4f *) & ((arg1)->diffuse);
+  {
+    FXVec4f* resultptr = new FXVec4f(*result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMaterial_specular_set(int argc, VALUE *argv, VALUE self) {
+  FXMaterial *arg1 = (FXMaterial *) 0 ;
+  FXVec4f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMaterial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMaterial *","specular", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMaterial * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg2 = new FXVec4f(*p);
+    }
+  }
+  if (arg1) (arg1)->specular = *arg2;
+  delete arg2;
+  return Qnil;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMaterial_specular_get(int argc, VALUE *argv, VALUE self) {
+  FXMaterial *arg1 = (FXMaterial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMaterial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMaterial *","specular", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMaterial * >(argp1);
+  result = (FXVec4f *) & ((arg1)->specular);
+  {
+    FXVec4f* resultptr = new FXVec4f(*result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMaterial_emission_set(int argc, VALUE *argv, VALUE self) {
+  FXMaterial *arg1 = (FXMaterial *) 0 ;
+  FXVec4f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMaterial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMaterial *","emission", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMaterial * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg2 = new FXVec4f(*p);
+    }
+  }
+  if (arg1) (arg1)->emission = *arg2;
+  delete arg2;
+  return Qnil;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMaterial_emission_get(int argc, VALUE *argv, VALUE self) {
+  FXMaterial *arg1 = (FXMaterial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMaterial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMaterial *","emission", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMaterial * >(argp1);
+  result = (FXVec4f *) & ((arg1)->emission);
+  {
+    FXVec4f* resultptr = new FXVec4f(*result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMaterial_shininess_set(int argc, VALUE *argv, VALUE self) {
+  FXMaterial *arg1 = (FXMaterial *) 0 ;
+  FXfloat arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMaterial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMaterial *","shininess", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMaterial * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","shininess", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  if (arg1) (arg1)->shininess = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMaterial_shininess_get(int argc, VALUE *argv, VALUE self) {
+  FXMaterial *arg1 = (FXMaterial *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMaterial, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMaterial *","shininess", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMaterial * >(argp1);
+  result = (FXfloat) ((arg1)->shininess);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXGLViewer;
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_objectType_get(VALUE self) {
+  VALUE _val;
+  
+  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(FXGLViewer::objectType));
+  return _val;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_objectType_set(VALUE self, VALUE _val) {
+  {
+    unsigned int val;
+    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""FXGLViewer::objectType""' of type '""FXDragType""'");
+    }
+    FXGLViewer::objectType = static_cast< FXDragType >(val);
+  }
+  return _val;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onEnter(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onLeave(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onMouseWheel(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onMouseWheel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMouseWheel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMouseWheel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onChanged(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onChanged", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onChanged", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onChanged", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onChanged(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onPick(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onPick", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPick", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onPick", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onPick(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onClicked(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onClicked", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onDoubleClicked(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onDoubleClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDoubleClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onDoubleClicked", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onDoubleClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onTripleClicked(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onTripleClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTripleClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onTripleClicked", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onTripleClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onLassoed(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onLassoed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLassoed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLassoed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onSelected(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSelected", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onSelected(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onDeselected(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onDeselected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDeselected", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onDeselected(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onInserted(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onInserted", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onInserted", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onInserted(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onDeleted(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onDeleted", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDeleted", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onDeleted(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onMiddleBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onMiddleBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMiddleBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMiddleBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onMiddleBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onMiddleBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMiddleBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMiddleBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onRightBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onRightBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onRightBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onRightBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onRightBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onRightBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onFocusIn(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onFocusIn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusIn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusIn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onFocusOut(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onFocusOut", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusOut", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusOut(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onClipboardLost(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onClipboardLost", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClipboardLost", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onClipboardLost(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onClipboardGained(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onClipboardGained", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClipboardGained", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onClipboardGained(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onClipboardRequest(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onClipboardRequest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClipboardRequest", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onClipboardRequest(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdPerspective(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdPerspective", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdPerspective", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdPerspective(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdPerspective(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdPerspective", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdPerspective", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdPerspective(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdParallel(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdParallel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdParallel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdParallel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdParallel(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdParallel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdParallel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdParallel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdFront(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdFront", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdFront", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdFront(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdFront(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdFront", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdFront", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdFront(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdBack(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdBack", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdBack", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdBack(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdBack(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdBack", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdBack", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdBack(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdLeft(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdLeft", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdLeft(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdLeft(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdLeft", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdLeft(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdRight(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdRight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdRight(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdRight(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdRight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdRight(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdTop(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdTop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdTop", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdTop(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdTop(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdTop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdTop", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdTop(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdBottom(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdBottom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdBottom", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdBottom(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdBottom(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdBottom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdBottom", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdBottom(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdResetView(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdResetView", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdResetView", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdResetView(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdFitView(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdFitView", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdFitView", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdFitView(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onDNDEnter(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onDNDEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onDNDLeave(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onDNDLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onDNDMotion(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onDNDMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onDNDDrop(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onDNDDrop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDDrop", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDDrop(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onTipTimer(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onTipTimer", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTipTimer", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onTipTimer(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdXYZDial(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdXYZDial", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdXYZDial", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdXYZDial(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdXYZDial(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdXYZDial", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdXYZDial", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdXYZDial(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdRollPitchYaw(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdRollPitchYaw", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdRollPitchYaw", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdRollPitchYaw(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdRollPitchYaw(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdRollPitchYaw", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdRollPitchYaw", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdRollPitchYaw(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdXYZScale(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdXYZScale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdXYZScale", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdXYZScale(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdXYZScale(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdXYZScale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdXYZScale", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdXYZScale(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdCurrent(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdCurrent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdCurrent(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdCutSel(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdCutSel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCutSel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCutSel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdCopySel(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdCopySel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCopySel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCopySel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdPasteSel(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdPasteSel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdPasteSel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdPasteSel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdDeleteSel(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdDeleteSel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDeleteSel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDeleteSel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdDeleteSel(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdDeleteSel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdDeleteSel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdDeleteSel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdBackColor(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdBackColor", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2UINT(argv[2]));
+  result = (long)(arg1)->onCmdBackColor(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdBackColor(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdBackColor", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdBackColor(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdGradientBackColor(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdGradientBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGradientBackColor", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2UINT(argv[2]));
+  result = (long)(arg1)->onCmdGradientBackColor(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdGradientBackColor(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdGradientBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdGradientBackColor", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdGradientBackColor(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdAmbientColor(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdAmbientColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdAmbientColor", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2UINT(argv[2]));
+  result = (long)(arg1)->onCmdAmbientColor(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdAmbientColor(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdAmbientColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdAmbientColor", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdAmbientColor(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdLighting(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdLighting", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdLighting", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdLighting(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdLighting(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdLighting", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdLighting", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdLighting(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdFog(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdFog", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdFog", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdFog(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdFog(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdFog", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdFog", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdFog(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdDither(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdDither", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDither", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDither(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdDither(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdDither", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdDither", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdDither(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdFov(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdFov", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdFov", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdFov(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdFov(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdFov", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdFov", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdFov(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdZoom(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdZoom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdZoom", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdZoom(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdZoom(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdZoom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdZoom", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdZoom(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdLightAmbient(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdLightAmbient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdLightAmbient", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2UINT(argv[2]));
+  result = (long)(arg1)->onCmdLightAmbient(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdLightAmbient(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdLightAmbient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdLightAmbient", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdLightAmbient(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdLightDiffuse(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdLightDiffuse", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdLightDiffuse", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2UINT(argv[2]));
+  result = (long)(arg1)->onCmdLightDiffuse(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdLightDiffuse(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdLightDiffuse", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdLightDiffuse", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdLightDiffuse(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdLightSpecular(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdLightSpecular", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdLightSpecular", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2UINT(argv[2]));
+  result = (long)(arg1)->onCmdLightSpecular(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdLightSpecular(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdLightSpecular", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdLightSpecular", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdLightSpecular(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdTurbo(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdTurbo", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdTurbo", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdTurbo(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onUpdTurbo(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onUpdTurbo", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdTurbo", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdTurbo(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdPrintImage(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdPrintImage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdPrintImage", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdPrintImage(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdPrintVector(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdPrintVector", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdPrintVector", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdPrintVector(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdLassoZoom(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdLassoZoom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdLassoZoom", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdLassoZoom(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onCmdLassoSelect(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onCmdLassoSelect", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdLassoSelect", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdLassoSelect(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_objectTypeName(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXGLViewer_objectTypeName();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXGLViewer__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXGLVisual *arg2 = (FXGLVisual *) 0 ;
+  FXObject *arg3 = (FXObject *) 0 ;
+  FXSelector arg4 = (FXSelector) 0 ;
+  FXuint arg5 = (FXuint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXGLViewer *result = 0 ;
+  
+  if ((argc < 2) || (argc > 9)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXGLViewer", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXGLVisual *","FXGLViewer", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXGLVisual * >(argp2);
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXObject *","FXGLViewer", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXObject * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXGLViewer *)new_FXGLViewer__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXGLViewer_allocate(VALUE self)
+#else
+_wrap_FXGLViewer_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXGLViewer);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXGLViewer__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXGLVisual *arg2 = (FXGLVisual *) 0 ;
+  FXGLViewer *arg3 = (FXGLViewer *) 0 ;
+  FXObject *arg4 = (FXObject *) 0 ;
+  FXSelector arg5 = (FXSelector) 0 ;
+  FXuint arg6 = (FXuint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXGLViewer *result = 0 ;
+  
+  if ((argc < 3) || (argc > 10)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXGLViewer", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXGLVisual, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXGLVisual *","FXGLViewer", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXGLVisual * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXGLViewer *","FXGLViewer", 3, argv[2] )); 
+  }
+  arg3 = reinterpret_cast< FXGLViewer * >(argp3);
+  if (argc > 3) {
+    res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXObject *","FXGLViewer", 4, argv[3] )); 
+    }
+    arg4 = reinterpret_cast< FXObject * >(argp4);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2UINT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXGLViewer *)new_FXGLViewer__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXGLViewer(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[10];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 10) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 2) && (argc <= 9)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComposite, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXGLVisual, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_new_FXGLViewer__SWIG_0(nargs, args, self);
+        }
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXObject, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXGLViewer__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXGLViewer__SWIG_0(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXGLViewer__SWIG_0(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXGLViewer__SWIG_0(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  if (argc <= 7) {
+                    return _wrap_new_FXGLViewer__SWIG_0(nargs, args, self);
+                  }
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    if (argc <= 8) {
+                      return _wrap_new_FXGLViewer__SWIG_0(nargs, args, self);
+                    }
+                    {
+                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
+                    }
+                    if (_v) {
+                      return _wrap_new_FXGLViewer__SWIG_0(nargs, args, self);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 3) && (argc <= 10)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComposite, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXGLVisual, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXGLViewer, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXGLViewer__SWIG_1(nargs, args, self);
+          }
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXObject, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXGLViewer__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXGLViewer__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXGLViewer__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  if (argc <= 7) {
+                    return _wrap_new_FXGLViewer__SWIG_1(nargs, args, self);
+                  }
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    if (argc <= 8) {
+                      return _wrap_new_FXGLViewer__SWIG_1(nargs, args, self);
+                    }
+                    {
+                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
+                    }
+                    if (_v) {
+                      if (argc <= 9) {
+                        return _wrap_new_FXGLViewer__SWIG_1(nargs, args, self);
+                      }
+                      {
+                        _v = (TYPE(argv[9]) == T_FIXNUM || TYPE(argv[9]) == T_BIGNUM) ? 1 : 0;
+                      }
+                      if (_v) {
+                        return _wrap_new_FXGLViewer__SWIG_1(nargs, args, self);
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 10, "FXGLViewer.new", 
+    "    FXGLViewer.new(FXComposite *p, FXGLVisual *vis, FXObject *tgt, FXSelector sel, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n"
+    "    FXGLViewer.new(FXComposite *p, FXGLVisual *vis, FXGLViewer *sharegroup, FXObject *tgt, FXSelector sel, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_worldPix(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","worldPix", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXdouble)((FXGLViewer const *)arg1)->worldPix();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_modelPix(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","modelPix", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXdouble)((FXGLViewer const *)arg1)->modelPix();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_lasso(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","lasso", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  result = (VALUE)FXGLViewer_lasso(arg1,arg2,arg3,arg4,arg5);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_fitToBounds(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXRangef *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","fitToBounds", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRangef,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRangef const &","fitToBounds", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRangef const &","fitToBounds", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRangef * >(argp2);
+  result = (FXbool)(arg1)->fitToBounds((FXRangef const &)*arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getViewport(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXViewport result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getViewport", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = FXGLViewer_getViewport((FXGLViewer const *)arg1);
+  {
+    FXViewport* resultptr = new FXViewport(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXViewport *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_eyeToScreen(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  SwigValueWrapper< FXVec3f > arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","eyeToScreen", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3f,  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3f","eyeToScreen", 2, argv[0] )); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3f","eyeToScreen", 2, argv[0]));
+    } else {
+      arg2 = *(reinterpret_cast< FXVec3f * >(argp2));
+    }
+  }
+  result = (VALUE)FXGLViewer_eyeToScreen(arg1,arg2);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_screenToEye(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXfloat arg4 = (FXfloat) 0.0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","screenToEye", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    ecode4 = SWIG_AsVal_float(argv[2], &val4);
+    if (!SWIG_IsOK(ecode4)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","screenToEye", 4, argv[2] ));
+    } 
+    arg4 = static_cast< FXfloat >(val4);
+  }
+  result = (arg1)->screenToEye(arg2,arg3,arg4);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_screenToTarget(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","screenToTarget", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (arg1)->screenToTarget(arg2,arg3);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_worldToEye(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  SwigValueWrapper< FXVec3f > arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","worldToEye", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3f,  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3f","worldToEye", 2, argv[0] )); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3f","worldToEye", 2, argv[0]));
+    } else {
+      arg2 = *(reinterpret_cast< FXVec3f * >(argp2));
+    }
+  }
+  result = (arg1)->worldToEye(arg2);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_worldToEyeZ(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  SwigValueWrapper< FXVec3f > arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","worldToEyeZ", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3f,  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3f","worldToEyeZ", 2, argv[0] )); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3f","worldToEyeZ", 2, argv[0]));
+    } else {
+      arg2 = *(reinterpret_cast< FXVec3f * >(argp2));
+    }
+  }
+  result = (FXfloat)(arg1)->worldToEyeZ(arg2);
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_eyeToWorld(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  SwigValueWrapper< FXVec3f > arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","eyeToWorld", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3f,  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3f","eyeToWorld", 2, argv[0] )); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3f","eyeToWorld", 2, argv[0]));
+    } else {
+      arg2 = *(reinterpret_cast< FXVec3f * >(argp2));
+    }
+  }
+  result = (arg1)->eyeToWorld(arg2);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_worldVector(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","worldVector", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  result = (arg1)->worldVector(arg2,arg3,arg4,arg5);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setMaterial(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXMaterial *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setMaterial", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXMaterial,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXMaterial const &","setMaterial", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMaterial const &","setMaterial", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXMaterial * >(argp2);
+  (arg1)->setMaterial((FXMaterial const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getMaterial(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMaterial result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getMaterial", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = FXGLViewer_getMaterial((FXGLViewer const *)arg1);
+  {
+    FXMaterial *resultptr = new FXMaterial(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXMaterial *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setFieldOfView(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setFieldOfView", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","setFieldOfView", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  (arg1)->setFieldOfView(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getFieldOfView(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getFieldOfView", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXdouble)((FXGLViewer const *)arg1)->getFieldOfView();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setZoom(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setZoom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","setZoom", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  (arg1)->setZoom(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getZoom(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getZoom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXdouble)((FXGLViewer const *)arg1)->getZoom();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setDistance(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setDistance", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","setDistance", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  (arg1)->setDistance(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getDistance(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getDistance", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXdouble)((FXGLViewer const *)arg1)->getDistance();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setScale(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  SwigValueWrapper< FXVec3f > arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setScale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3f,  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3f","setScale", 2, argv[0] )); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3f","setScale", 2, argv[0]));
+    } else {
+      arg2 = *(reinterpret_cast< FXVec3f * >(argp2));
+    }
+  }
+  (arg1)->setScale(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getScale(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec3f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getScale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXVec3f *) &((FXGLViewer const *)arg1)->getScale();
+  {
+    FXVec3f* resultptr = new FXVec3f(*result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setOrientation(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXQuatf arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setOrientation", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXQuatf,  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXQuatf","setOrientation", 2, argv[0] )); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXQuatf","setOrientation", 2, argv[0]));
+    } else {
+      arg2 = *(reinterpret_cast< FXQuatf * >(argp2));
+    }
+  }
+  (arg1)->setOrientation(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getOrientation(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXQuatf *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getOrientation", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXQuatf *) &((FXGLViewer const *)arg1)->getOrientation();
+  vresult = FXRbGetRubyObj(result, "FXQuatf *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setCenter(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  SwigValueWrapper< FXVec3f > arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setCenter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3f,  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3f","setCenter", 2, argv[0] )); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3f","setCenter", 2, argv[0]));
+    } else {
+      arg2 = *(reinterpret_cast< FXVec3f * >(argp2));
+    }
+  }
+  (arg1)->setCenter(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getCenter(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec3f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getCenter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXVec3f *) &((FXGLViewer const *)arg1)->getCenter();
+  {
+    FXVec3f* resultptr = new FXVec3f(*result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_translate(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  SwigValueWrapper< FXVec3f > arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","translate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec3f,  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec3f","translate", 2, argv[0] )); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec3f","translate", 2, argv[0]));
+    } else {
+      arg2 = *(reinterpret_cast< FXVec3f * >(argp2));
+    }
+  }
+  (arg1)->translate(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getBoreVector(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","getBoreVector", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (VALUE)FXGLViewer_getBoreVector(arg1,arg2,arg3);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getEyeVector(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getEyeVector", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = ((FXGLViewer const *)arg1)->getEyeVector();
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getEyePosition(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getEyePosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = ((FXGLViewer const *)arg1)->getEyePosition();
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXString *) &((FXGLViewer const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setTipText(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getTipText(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXString *) &((FXGLViewer const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getTransform(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMat4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getTransform", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXMat4f *) &((FXGLViewer const *)arg1)->getTransform();
+  vresult = FXRbGetRubyObj(result, "FXMat4f *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getInvTransform(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMat4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getInvTransform", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXMat4f *) &((FXGLViewer const *)arg1)->getInvTransform();
+  vresult = FXRbGetRubyObj(result, "FXMat4f *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setScene(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXGLObject *arg2 = (FXGLObject *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setScene", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXGLObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXGLObject *","setScene", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXGLObject * >(argp2);
+  (arg1)->setScene(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getScene(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXGLObject *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getScene", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXGLObject *)((FXGLViewer const *)arg1)->getScene();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXGLObject, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setSelection(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXGLObject *arg2 = (FXGLObject *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXGLObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXGLObject *","setSelection", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXGLObject * >(argp2);
+  (arg1)->setSelection(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getSelection(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXGLObject *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXGLObject *)((FXGLViewer const *)arg1)->getSelection();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXGLObject, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setProjection(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setProjection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setProjection(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getProjection(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getProjection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXuint)((FXGLViewer const *)arg1)->getProjection();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setBackgroundColor(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXVec4f *arg2 = 0 ;
+  FXbool arg3 = (FXbool) 2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setBackgroundColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg2 = new FXVec4f(*p);
+    }
+  }
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setBackgroundColor((FXVec4f const &)*arg2,arg3);
+  delete arg2;
+  return Qnil;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getBackgroundColor(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getBackgroundColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXVec4f *) &((FXGLViewer const *)arg1)->getBackgroundColor(arg2);
+  {
+    FXVec4f* resultptr = new FXVec4f(*result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setAmbientColor(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXVec4f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setAmbientColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec4f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)), NUM2DBL(rb_ary_entry(argv[0], 3)));
+    } else {
+      FXVec4f *p;
+      SWIG_ConvertPtr(argv[0],(void **)&p,SWIGTYPE_p_FXVec4f,1);
+      arg2 = new FXVec4f(*p);
+    }
+  }
+  (arg1)->setAmbientColor((FXVec4f const &)*arg2);
+  delete arg2;
+  return Qnil;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getAmbientColor(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec4f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getAmbientColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXVec4f *) &((FXGLViewer const *)arg1)->getAmbientColor();
+  {
+    FXVec4f* resultptr = new FXVec4f(*result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec4f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_readPixels(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","readPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  result = (VALUE)FXGLViewer_readPixels(arg1,arg2,arg3,arg4,arg5);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_readFeedback(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","readFeedback", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  result = (VALUE)FXGLViewer_readFeedback(arg1,arg2,arg3,arg4,arg5);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setZSortFunc(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setZSortFunc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  arg2 = argv[0];
+  FXGLViewer_setZSortFunc(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getZSortFunc(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getZSortFunc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (VALUE)FXGLViewer_getZSortFunc((FXGLViewer const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setMaxHits(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setMaxHits", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setMaxHits(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getMaxHits(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getMaxHits", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXint)((FXGLViewer const *)arg1)->getMaxHits();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_doesTurbo(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","doesTurbo", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXbool)((FXGLViewer const *)arg1)->doesTurbo();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getTurboMode(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getTurboMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXbool)((FXGLViewer const *)arg1)->getTurboMode();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setTurboMode(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setTurboMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->setTurboMode(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getLight(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXLight result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","getLight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = FXGLViewer_getLight((FXGLViewer const *)arg1);
+  {
+    FXLight *resultptr = new FXLight(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXLight *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setLight(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXLight *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setLight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXLight,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXLight const &","setLight", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXLight const &","setLight", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXLight * >(argp2);
+  (arg1)->setLight((FXLight const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_save(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXGLViewer_save((FXGLViewer const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_load(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXGLViewer_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_create(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  FXGLViewer_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_detach(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  FXGLViewer_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_destroy(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  FXGLViewer_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_resize(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXGLViewer_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXint)FXGLViewer_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXint)FXGLViewer_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXGLViewer_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXGLViewer_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (bool)FXGLViewer_canFocus((FXGLViewer const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  FXGLViewer_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  FXGLViewer_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXGLViewer_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXGLViewer_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_enable(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  FXGLViewer_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_disable(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  FXGLViewer_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  FXGLViewer_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_lower(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  FXGLViewer_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_move(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXGLViewer_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_position(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXGLViewer_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_layout(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  FXGLViewer_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_recalc(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  FXGLViewer_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_reparent(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXGLViewer_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_show(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  FXGLViewer_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_hide(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  FXGLViewer_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (bool)FXGLViewer_isComposite((FXGLViewer const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_contains(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXGLViewer_contains((FXGLViewer const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (bool)FXGLViewer_doesSaveUnder((FXGLViewer const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXGLViewer_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_tr(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXGLViewer_tr((FXGLViewer const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  FXGLViewer_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  FXGLViewer_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXGLViewer_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXGLViewer_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXGLViewer_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXGLViewer_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXGLViewer, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXGLViewer_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXGLViewer, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXGLViewer_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXGLViewer, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXGLViewer_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  FXGLViewer_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_makeCurrent(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","makeCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXbool)FXGLViewer_makeCurrent(arg1);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_makeNonCurrent(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","makeNonCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXbool)FXGLViewer_makeNonCurrent(arg1);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_isCurrent(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer const *","isCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  result = (FXbool)FXGLViewer_isCurrent((FXGLViewer const *)arg1);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_swapBuffers(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","swapBuffers", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  FXGLViewer_swapBuffers(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXGLViewer.select
+
+  call-seq:
+    select(x, y, w, h) -> FXGLObject **
+
+Iterate thru each element in the FXGLViewer and select those that match a condition.  A block must be provided.
+*/
+SWIGINTERN VALUE
+_wrap_FXGLViewer_select(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXGLObject **result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","select", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  result = (FXGLObject **)FXGLViewer_select(arg1,arg2,arg3,arg4,arg5);
+  {
+    vresult=Qnil;
+    if(result){
+      vresult=rb_ary_new();
+      register FXGLObject** p=result;
+      while(*p){
+        rb_ary_push(vresult,to_ruby(*p));
+        p++;
+      }
+      FXFREE(&result);
+    }
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_pick(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXGLObject *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","pick", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXGLObject *)FXGLViewer_pick(arg1,arg2,arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXGLObject, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLViewer_setBounds(int argc, VALUE *argv, VALUE self) {
+  FXGLViewer *arg1 = (FXGLViewer *) 0 ;
+  FXRangef *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLViewer *","setBounds", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLViewer * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRangef,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRangef const &","setBounds", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRangef const &","setBounds", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRangef * >(argp2);
+  result = (FXbool)FXGLViewer_setBounds(arg1,(FXRangef const &)*arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXGLObject;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXGLObject_allocate(VALUE self)
+#else
+_wrap_FXGLObject_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXGLObject);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXGLObject(int argc, VALUE *argv, VALUE self) {
+  FXGLObject *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  {
+    result = (FXGLObject *)new_FXGLObject();
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLObject_identify(int argc, VALUE *argv, VALUE self) {
+  FXGLObject *arg1 = (FXGLObject *) 0 ;
+  FXuint *arg2 = (FXuint *) 0 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXGLObject *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLObject, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLObject *","identify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLObject * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    FXMALLOC(&arg2,FXuint,RARRAY_LEN(argv[0]));
+    arg3=static_cast<FXint>(RARRAY_LEN(argv[0]));
+    for(FXint i=0; i<arg3; i++){
+      arg2[i]=NUM2UINT(rb_ary_entry(argv[0],i));
+    }
+  }
+  result = (FXGLObject *)FXGLObject_identify(arg1,arg2,arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXGLObject, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  {
+    FXFREE(&arg2);
+  }
+  return vresult;
+fail:
+  {
+    FXFREE(&arg2);
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLObject_save(int argc, VALUE *argv, VALUE self) {
+  FXGLObject *arg1 = (FXGLObject *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLObject, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLObject const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLObject * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXGLObject_save((FXGLObject const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLObject_load(int argc, VALUE *argv, VALUE self) {
+  FXGLObject *arg1 = (FXGLObject *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLObject, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLObject *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLObject * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXGLObject_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLObject_copy(int argc, VALUE *argv, VALUE self) {
+  FXGLObject *arg1 = (FXGLObject *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXGLObject *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLObject, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLObject *","copy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLObject * >(argp1);
+  result = (FXGLObject *)FXGLObject_copy(arg1);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXGLObject, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLObject_bounds(int argc, VALUE *argv, VALUE self) {
+  FXGLObject *arg1 = (FXGLObject *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXRangef result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLObject, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLObject *","bounds", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLObject * >(argp1);
+  result = FXGLObject_bounds(arg1);
+  {
+    FXRangef* resultptr = new FXRangef(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXRangef *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLObject_draw(int argc, VALUE *argv, VALUE self) {
+  FXGLObject *arg1 = (FXGLObject *) 0 ;
+  FXGLViewer *arg2 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLObject, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLObject *","draw", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLObject * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXGLViewer *","draw", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXGLViewer * >(argp2);
+  FXGLObject_draw(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLObject_hit(int argc, VALUE *argv, VALUE self) {
+  FXGLObject *arg1 = (FXGLObject *) 0 ;
+  FXGLViewer *arg2 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLObject, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLObject *","hit", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLObject * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXGLViewer *","hit", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXGLViewer * >(argp2);
+  FXGLObject_hit(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLObject_canDrag(int argc, VALUE *argv, VALUE self) {
+  FXGLObject *arg1 = (FXGLObject *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLObject, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLObject const *","canDrag", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLObject * >(argp1);
+  result = (FXbool)FXGLObject_canDrag((FXGLObject const *)arg1);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLObject_canDelete(int argc, VALUE *argv, VALUE self) {
+  FXGLObject *arg1 = (FXGLObject *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLObject, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLObject const *","canDelete", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLObject * >(argp1);
+  result = (FXbool)FXGLObject_canDelete((FXGLObject const *)arg1);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLObject_drag(int argc, VALUE *argv, VALUE self) {
+  FXGLObject *arg1 = (FXGLObject *) 0 ;
+  FXGLViewer *arg2 = (FXGLViewer *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 5) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLObject, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLObject *","drag", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLObject * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXGLViewer *","drag", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXGLViewer * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  result = (FXbool)FXGLObject_drag(arg1,arg2,arg3,arg4,arg5,arg6);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXGLShape;
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_onDNDDrop(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","onDNDDrop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDDrop", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onDNDDrop", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onDNDDrop(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_onDNDMotion(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","onDNDMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onQueryTip", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_onCmdShadeOff(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","onCmdShadeOff", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdShadeOff", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdShadeOff", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdShadeOff(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_onUpdShadeOff(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","onUpdShadeOff", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdShadeOff", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onUpdShadeOff", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onUpdShadeOff(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_onCmdShadeOn(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","onCmdShadeOn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdShadeOn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdShadeOn", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdShadeOn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_onUpdShadeOn(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","onUpdShadeOn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdShadeOn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onUpdShadeOn", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onUpdShadeOn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_onCmdShadeSmooth(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","onCmdShadeSmooth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdShadeSmooth", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdShadeSmooth", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdShadeSmooth(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_onUpdShadeSmooth(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","onUpdShadeSmooth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdShadeSmooth", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onUpdShadeSmooth", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onUpdShadeSmooth(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_onCmdFrontMaterial(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","onCmdFrontMaterial", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdFrontMaterial", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdFrontMaterial", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdFrontMaterial(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_onUpdFrontMaterial(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","onUpdFrontMaterial", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdFrontMaterial", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onUpdFrontMaterial", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onUpdFrontMaterial(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_onCmdBackMaterial(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","onCmdBackMaterial", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdBackMaterial", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdBackMaterial", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdBackMaterial(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_onUpdBackMaterial(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","onUpdBackMaterial", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdBackMaterial", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onUpdBackMaterial", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onUpdBackMaterial(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_onCmdDrawingStyle(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","onCmdDrawingStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDrawingStyle", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdDrawingStyle", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdDrawingStyle(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_onUpdDrawingStyle(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","onUpdDrawingStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdDrawingStyle", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onUpdDrawingStyle", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onUpdDrawingStyle(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXGLShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXfloat arg1 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  FXuint arg4 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  FXGLShape *result = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_float(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXfloat","FXGLShape", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXfloat >(val1);
+  ecode2 = SWIG_AsVal_float(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","FXGLShape", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","FXGLShape", 3, argv[2] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  arg4 = NUM2UINT(argv[3]);
+  {
+    result = (FXGLShape *)new_FXGLShape__SWIG_0(arg1,arg2,arg3,arg4);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXGLShape_allocate(VALUE self)
+#else
+_wrap_FXGLShape_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXGLShape);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXGLShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXfloat arg1 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  FXuint arg4 ;
+  FXMaterial *arg5 = 0 ;
+  FXMaterial *arg6 = 0 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  void *argp5 ;
+  int res5 = 0 ;
+  void *argp6 ;
+  int res6 = 0 ;
+  FXGLShape *result = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_float(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXfloat","FXGLShape", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXfloat >(val1);
+  ecode2 = SWIG_AsVal_float(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","FXGLShape", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","FXGLShape", 3, argv[2] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  arg4 = NUM2UINT(argv[3]);
+  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_FXMaterial,  0 );
+  if (!SWIG_IsOK(res5)) {
+    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXMaterial const &","FXGLShape", 5, argv[4] )); 
+  }
+  if (!argp5) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMaterial const &","FXGLShape", 5, argv[4])); 
+  }
+  arg5 = reinterpret_cast< FXMaterial * >(argp5);
+  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_FXMaterial,  0 );
+  if (!SWIG_IsOK(res6)) {
+    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "FXMaterial const &","FXGLShape", 6, argv[5] )); 
+  }
+  if (!argp6) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMaterial const &","FXGLShape", 6, argv[5])); 
+  }
+  arg6 = reinterpret_cast< FXMaterial * >(argp6);
+  {
+    result = (FXGLShape *)new_FXGLShape__SWIG_1(arg1,arg2,arg3,arg4,(FXMaterial const &)*arg5,(FXMaterial const &)*arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXGLShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 6) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 4) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_new_FXGLShape__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  if (argc == 6) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            void *vptr = 0;
+            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_FXMaterial, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              void *vptr = 0;
+              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_FXMaterial, 0);
+              _v = SWIG_CheckState(res);
+              if (_v) {
+                return _wrap_new_FXGLShape__SWIG_1(nargs, args, self);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "FXGLShape.new", 
+    "    FXGLShape.new(FXfloat x, FXfloat y, FXfloat z, FXuint opts)\n"
+    "    FXGLShape.new(FXfloat x, FXfloat y, FXfloat z, FXuint opts, FXMaterial const &front, FXMaterial const &back)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_identify(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXuint *arg2 = (FXuint *) 0 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXGLObject *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","identify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  {
+    Check_Type(argv[0], T_ARRAY);
+    FXMALLOC(&arg2,FXuint,RARRAY_LEN(argv[0]));
+    arg3=static_cast<FXint>(RARRAY_LEN(argv[0]));
+    for(FXint i=0; i<arg3; i++){
+      arg2[i]=NUM2UINT(rb_ary_entry(argv[0],i));
+    }
+  }
+  result = (FXGLObject *)FXGLShape_identify(arg1,arg2,arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXGLObject, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  {
+    FXFREE(&arg2);
+  }
+  return vresult;
+fail:
+  {
+    FXFREE(&arg2);
+  }
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_setTipText(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_getTipText(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  result = (FXString *) &((FXGLShape const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_setMaterial(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXint arg2 ;
+  FXMaterial *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","setMaterial", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXMaterial,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXMaterial const &","setMaterial", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXMaterial const &","setMaterial", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXMaterial * >(argp3);
+  (arg1)->setMaterial(arg2,(FXMaterial const &)*arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_getPosition(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXVec3f > result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape const *","getPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  result = FXGLShape_getPosition((FXGLShape const *)arg1);
+  {
+    FXVec3f* resultptr = new FXVec3f(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXVec3f *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_setPosition(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXVec3f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","setPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  {
+    if (TYPE(argv[0]) == T_ARRAY) {
+      arg2 = new FXVec3f(NUM2DBL(rb_ary_entry(argv[0], 0)), NUM2DBL(rb_ary_entry(argv[0], 1)), NUM2DBL(rb_ary_entry(argv[0], 2)));
+    } else {
+      FXVec3f *p;
+      SWIG_ConvertPtr(argv[0], (void **)&p, SWIGTYPE_p_FXVec3f, 1);
+      arg2 = new FXVec3f(*p);
+    }
+  }
+  FXGLShape_setPosition(arg1,(FXVec3f const &)*arg2);
+  delete arg2;
+  return Qnil;
+fail:
+  delete arg2;
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_getMaterial(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMaterial result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape const *","getMaterial", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = FXGLShape_getMaterial((FXGLShape const *)arg1,arg2);
+  {
+    FXMaterial *resultptr = new FXMaterial(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXMaterial *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_setRange(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXRangef *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","setRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRangef,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRangef const &","setRange", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRangef const &","setRange", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRangef * >(argp2);
+  FXGLShape_setRange(arg1,(FXRangef const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_save(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXGLShape_save((FXGLShape const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_load(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXGLShape_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_copy(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXGLObject *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","copy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  result = (FXGLObject *)FXGLShape_copy(arg1);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXGLObject, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_bounds(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXRangef result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","bounds", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  result = FXGLShape_bounds(arg1);
+  {
+    FXRangef* resultptr = new FXRangef(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXRangef *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_draw(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXGLViewer *arg2 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","draw", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXGLViewer *","draw", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXGLViewer * >(argp2);
+  FXGLShape_draw(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_hit(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXGLViewer *arg2 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","hit", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXGLViewer *","hit", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXGLViewer * >(argp2);
+  FXGLShape_hit(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_canDrag(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape const *","canDrag", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  result = (FXbool)FXGLShape_canDrag((FXGLShape const *)arg1);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_canDelete(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape const *","canDelete", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  result = (FXbool)FXGLShape_canDelete((FXGLShape const *)arg1);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_drag(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXGLViewer *arg2 = (FXGLViewer *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 5) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","drag", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXGLViewer *","drag", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXGLViewer * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  result = (FXbool)FXGLShape_drag(arg1,arg2,arg3,arg4,arg5,arg6);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGLShape_drawshape(int argc, VALUE *argv, VALUE self) {
+  FXGLShape *arg1 = (FXGLShape *) 0 ;
+  FXGLViewer *arg2 = (FXGLViewer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGLShape, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGLShape *","drawshape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGLShape * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXGLViewer, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXGLViewer *","drawshape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXGLViewer * >(argp2);
+  FXGLShape_drawshape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXExtentf;
+
+SWIGINTERN VALUE
+_wrap_FXExtentf_lower_set(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  FXVec2f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2f,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2f const &","lower", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2f const &","lower", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2f * >(argp2);
+  if (arg1) (arg1)->lower = *arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentf_lower_get(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec2f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  result = (FXVec2f *) & ((arg1)->lower);
+  vresult = FXRbGetRubyObj(result, "FXVec2f *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentf_upper_set(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  FXVec2f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf *","upper", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2f,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2f const &","upper", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2f const &","upper", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2f * >(argp2);
+  if (arg1) (arg1)->upper = *arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentf_upper_get(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec2f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf *","upper", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  result = (FXVec2f *) & ((arg1)->upper);
+  vresult = FXRbGetRubyObj(result, "FXVec2f *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXExtentf__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (FXExtentf *)new FXExtentf();
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXExtentf__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXExtentf *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXExtentf,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf const &","FXExtentf", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXExtentf const &","FXExtentf", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  result = (FXExtentf *)new FXExtentf((FXExtentf const &)*arg1);
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXExtentf__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXVec2f *arg1 = 0 ;
+  FXVec2f *arg2 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXExtentf *result = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXVec2f,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2f const &","FXExtentf", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2f const &","FXExtentf", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXVec2f * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FXVec2f,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2f const &","FXExtentf", 2, argv[1] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2f const &","FXExtentf", 2, argv[1])); 
+  }
+  arg2 = reinterpret_cast< FXVec2f * >(argp2);
+  result = (FXExtentf *)new FXExtentf((FXVec2f const &)*arg1,(FXVec2f const &)*arg2);
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXExtentf_allocate(VALUE self)
+#else
+_wrap_FXExtentf_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXExtentf);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXExtentf__SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXfloat arg1 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  FXfloat arg4 ;
+  float val1 ;
+  int ecode1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  float val4 ;
+  int ecode4 = 0 ;
+  FXExtentf *result = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_float(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXfloat","FXExtentf", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXfloat >(val1);
+  ecode2 = SWIG_AsVal_float(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","FXExtentf", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","FXExtentf", 3, argv[2] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  ecode4 = SWIG_AsVal_float(argv[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXfloat","FXExtentf", 4, argv[3] ));
+  } 
+  arg4 = static_cast< FXfloat >(val4);
+  result = (FXExtentf *)new FXExtentf(arg1,arg2,arg3,arg4);
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXExtentf(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 4) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_FXExtentf__SWIG_0(nargs, args, self);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXExtentf, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXExtentf__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec2f, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec2f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_FXExtentf__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    {
+      int res = SWIG_AsVal_float(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_float(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_float(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_float(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_new_FXExtentf__SWIG_3(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXExtentf.new", 
+    "    FXExtentf.new()\n"
+    "    FXExtentf.new(FXExtentf const &ext)\n"
+    "    FXExtentf.new(FXVec2f const &lo, FXVec2f const &hi)\n"
+    "    FXExtentf.new(FXfloat xlo, FXfloat xhi, FXfloat ylo, FXfloat yhi)\n");
+  
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXExtentf.[]=
+
+  call-seq:
+    []=(i, v) -> FXVec2f
+
+Element setter/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXExtentf___setitem__(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  FXint arg2 ;
+  FXVec2f *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXVec2f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf *","__setitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXVec2f,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXVec2f &","__setitem__", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2f &","__setitem__", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXVec2f * >(argp3);
+  result = (FXVec2f *) &FXExtentf___setitem__(arg1,arg2,*arg3);
+  vresult = FXRbGetRubyObj(result, "FXVec2f *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXExtentf.[]
+
+  call-seq:
+    [](i) -> FXVec2f
+
+Element accessor/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXExtentf___getitem__(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec2f *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf const *","__getitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXVec2f *) &FXExtentf___getitem__((FXExtentf const *)arg1,arg2);
+  vresult = FXRbGetRubyObj(result, "FXVec2f *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentf_width(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf const *","width", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  result = (FXfloat)((FXExtentf const *)arg1)->width();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentf_height(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf const *","height", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  result = (FXfloat)((FXExtentf const *)arg1)->height();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentf_longest(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf const *","longest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  result = (FXfloat)((FXExtentf const *)arg1)->longest();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentf_shortest(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf const *","shortest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  result = (FXfloat)((FXExtentf const *)arg1)->shortest();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentf_diameter(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf const *","diameter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  result = (FXfloat)((FXExtentf const *)arg1)->diameter();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentf_radius(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXfloat result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf const *","radius", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  result = (FXfloat)((FXExtentf const *)arg1)->radius();
+  vresult = SWIG_From_float(static_cast< float >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentf_diagonal(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec2f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf const *","diagonal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  result = ((FXExtentf const *)arg1)->diagonal();
+  vresult = SWIG_NewPointerObj((new FXVec2f(static_cast< const FXVec2f& >(result))), SWIGTYPE_p_FXVec2f, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentf_center(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec2f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf const *","center", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  result = ((FXExtentf const *)arg1)->center();
+  vresult = SWIG_NewPointerObj((new FXVec2f(static_cast< const FXVec2f& >(result))), SWIGTYPE_p_FXVec2f, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXExtentf.empty?
+
+  call-seq:
+    empty? -> bool
+
+Check if FXExtentf is empty.
+*/
+SWIGINTERN VALUE
+_wrap_FXExtentf_emptyq___(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf const *","empty", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  result = (bool)((FXExtentf const *)arg1)->empty();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentf_contains(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","contains", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","contains", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  result = (bool)((FXExtentf const *)arg1)->contains(arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentf_containsq_____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  FXVec2f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2f,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2f const &","contains", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2f const &","contains", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2f * >(argp2);
+  result = (bool)((FXExtentf const *)arg1)->contains((FXVec2f const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentf_containsq_____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  FXExtentf *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXExtentf,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXExtentf const &","contains", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXExtentf const &","contains", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXExtentf * >(argp2);
+  result = (bool)((FXExtentf const *)arg1)->contains((FXExtentf const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXExtentf_containsq___(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXExtentf, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec2f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXExtentf_containsq_____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXExtentf, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXExtentf, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXExtentf_containsq_____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "FXExtentf.contains?", 
+    "    bool FXExtentf.contains?(FXVec2f const &p)\n"
+    "    bool FXExtentf.contains?(FXExtentf const &ext)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentf_include(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  FXfloat arg2 ;
+  FXfloat arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  float val2 ;
+  int ecode2 = 0 ;
+  float val3 ;
+  int ecode3 = 0 ;
+  FXExtentf *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf *","include", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  ecode2 = SWIG_AsVal_float(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXfloat","include", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXfloat >(val2);
+  ecode3 = SWIG_AsVal_float(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXfloat","include", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXfloat >(val3);
+  result = (FXExtentf *) &(arg1)->include(arg2,arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXExtentf, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentf_includeN_____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  FXVec2f *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXExtentf *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf *","include", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2f,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2f const &","include", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2f const &","include", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2f * >(argp2);
+  result = (FXExtentf *) &(arg1)->include((FXVec2f const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXExtentf, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentf_includeN_____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  FXExtentf *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXExtentf *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf *","include", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXExtentf,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXExtentf const &","include", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXExtentf const &","include", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXExtentf * >(argp2);
+  result = (FXExtentf *) &(arg1)->include((FXExtentf const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXExtentf, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXExtentf_includeN___(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXExtentf, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec2f, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXExtentf_includeN_____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXExtentf, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXExtentf, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXExtentf_includeN_____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "FXExtentf.include!", 
+    "    FXExtentf FXExtentf.include!(FXVec2f const &v)\n"
+    "    FXExtentf & FXExtentf.include!(FXExtentf const &ext)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentf_corner(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec2f result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf const *","corner", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = ((FXExtentf const *)arg1)->corner(arg2);
+  vresult = SWIG_NewPointerObj((new FXVec2f(static_cast< const FXVec2f& >(result))), SWIGTYPE_p_FXVec2f, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentf_overlapq___(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  FXExtentf *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf const *","overlap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXExtentf,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXExtentf const &","overlap", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXExtentf const &","overlap", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXExtentf * >(argp2);
+  result = (bool)FXExtentf_overlap((FXExtentf const *)arg1,(FXExtentf const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentf_unite_with(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  FXExtentf *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXExtentf result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf const *","unite_with", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXExtentf,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXExtentf const &","unite_with", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXExtentf const &","unite_with", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXExtentf * >(argp2);
+  result = FXExtentf_unite_with((FXExtentf const *)arg1,(FXExtentf const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXExtentf(static_cast< const FXExtentf& >(result))), SWIGTYPE_p_FXExtentf, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentf_intersect_with(int argc, VALUE *argv, VALUE self) {
+  FXExtentf *arg1 = (FXExtentf *) 0 ;
+  FXExtentf *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXExtentf result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentf, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentf const *","intersect_with", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentf * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXExtentf,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXExtentf const &","intersect_with", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXExtentf const &","intersect_with", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXExtentf * >(argp2);
+  result = FXExtentf_intersect_with((FXExtentf const *)arg1,(FXExtentf const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXExtentf(static_cast< const FXExtentf& >(result))), SWIGTYPE_p_FXExtentf, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXExtentd;
+
+SWIGINTERN VALUE
+_wrap_FXExtentd_lower_set(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  FXVec2d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2d const &","lower", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2d const &","lower", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2d * >(argp2);
+  if (arg1) (arg1)->lower = *arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentd_lower_get(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec2d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  result = (FXVec2d *) & ((arg1)->lower);
+  vresult = FXRbGetRubyObj(result, "FXVec2d *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentd_upper_set(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  FXVec2d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd *","upper", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2d const &","upper", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2d const &","upper", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2d * >(argp2);
+  if (arg1) (arg1)->upper = *arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentd_upper_get(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec2d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd *","upper", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  result = (FXVec2d *) & ((arg1)->upper);
+  vresult = FXRbGetRubyObj(result, "FXVec2d *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXExtentd__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (FXExtentd *)new FXExtentd();
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXExtentd__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  FXExtentd *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXExtentd,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd const &","FXExtentd", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXExtentd const &","FXExtentd", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  result = (FXExtentd *)new FXExtentd((FXExtentd const &)*arg1);
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXExtentd__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXVec2d *arg1 = 0 ;
+  FXVec2d *arg2 = 0 ;
+  void *argp1 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXExtentd *result = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXVec2d,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVec2d const &","FXExtentd", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2d const &","FXExtentd", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXVec2d * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_FXVec2d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2d const &","FXExtentd", 2, argv[1] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2d const &","FXExtentd", 2, argv[1])); 
+  }
+  arg2 = reinterpret_cast< FXVec2d * >(argp2);
+  result = (FXExtentd *)new FXExtentd((FXVec2d const &)*arg1,(FXVec2d const &)*arg2);
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXExtentd_allocate(VALUE self)
+#else
+_wrap_FXExtentd_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXExtentd);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXExtentd__SWIG_3(int argc, VALUE *argv, VALUE self) {
+  FXdouble arg1 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  FXdouble arg4 ;
+  double val1 ;
+  int ecode1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  double val4 ;
+  int ecode4 = 0 ;
+  FXExtentd *result = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_double(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "FXdouble","FXExtentd", 1, argv[0] ));
+  } 
+  arg1 = static_cast< FXdouble >(val1);
+  ecode2 = SWIG_AsVal_double(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","FXExtentd", 2, argv[1] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","FXExtentd", 3, argv[2] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  ecode4 = SWIG_AsVal_double(argv[3], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXdouble","FXExtentd", 4, argv[3] ));
+  } 
+  arg4 = static_cast< FXdouble >(val4);
+  result = (FXExtentd *)new FXExtentd(arg1,arg2,arg3,arg4);
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXExtentd(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 4) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 0) {
+    return _wrap_new_FXExtentd__SWIG_0(nargs, args, self);
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXExtentd, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FXExtentd__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVec2d, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec2d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_FXExtentd__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_double(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_new_FXExtentd__SWIG_3(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "FXExtentd.new", 
+    "    FXExtentd.new()\n"
+    "    FXExtentd.new(FXExtentd const &ext)\n"
+    "    FXExtentd.new(FXVec2d const &lo, FXVec2d const &hi)\n"
+    "    FXExtentd.new(FXdouble xlo, FXdouble xhi, FXdouble ylo, FXdouble yhi)\n");
+  
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXExtentd.[]=
+
+  call-seq:
+    []=(i, v) -> FXVec2d
+
+Element setter/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXExtentd___setitem__(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  FXint arg2 ;
+  FXVec2d *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXVec2d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd *","__setitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXVec2d,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXVec2d &","__setitem__", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2d &","__setitem__", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXVec2d * >(argp3);
+  result = (FXVec2d *) &FXExtentd___setitem__(arg1,arg2,*arg3);
+  vresult = FXRbGetRubyObj(result, "FXVec2d *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXExtentd.[]
+
+  call-seq:
+    [](i) -> FXVec2d
+
+Element accessor/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXExtentd___getitem__(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec2d *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd const *","__getitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXVec2d *) &FXExtentd___getitem__((FXExtentd const *)arg1,arg2);
+  vresult = FXRbGetRubyObj(result, "FXVec2d *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentd_width(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd const *","width", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  result = (FXdouble)((FXExtentd const *)arg1)->width();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentd_height(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd const *","height", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  result = (FXdouble)((FXExtentd const *)arg1)->height();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentd_longest(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd const *","longest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  result = (FXdouble)((FXExtentd const *)arg1)->longest();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentd_shortest(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd const *","shortest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  result = (FXdouble)((FXExtentd const *)arg1)->shortest();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentd_diameter(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd const *","diameter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  result = (FXdouble)((FXExtentd const *)arg1)->diameter();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentd_radius(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd const *","radius", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  result = (FXdouble)((FXExtentd const *)arg1)->radius();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentd_diagonal(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec2d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd const *","diagonal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  result = ((FXExtentd const *)arg1)->diagonal();
+  vresult = SWIG_NewPointerObj((new FXVec2d(static_cast< const FXVec2d& >(result))), SWIGTYPE_p_FXVec2d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentd_center(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec2d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd const *","center", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  result = ((FXExtentd const *)arg1)->center();
+  vresult = SWIG_NewPointerObj((new FXVec2d(static_cast< const FXVec2d& >(result))), SWIGTYPE_p_FXVec2d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Fx3d::FXExtentd.empty?
+
+  call-seq:
+    empty? -> bool
+
+Check if FXExtentd is empty.
+*/
+SWIGINTERN VALUE
+_wrap_FXExtentd_emptyq___(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd const *","empty", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  result = (bool)((FXExtentd const *)arg1)->empty();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentd_contains(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","contains", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","contains", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  result = (bool)((FXExtentd const *)arg1)->contains(arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentd_containsq_____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  FXVec2d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2d const &","contains", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2d const &","contains", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2d * >(argp2);
+  result = (bool)((FXExtentd const *)arg1)->contains((FXVec2d const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentd_containsq_____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  FXExtentd *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXExtentd,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXExtentd const &","contains", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXExtentd const &","contains", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXExtentd * >(argp2);
+  result = (bool)((FXExtentd const *)arg1)->contains((FXExtentd const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXExtentd_containsq___(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXExtentd, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec2d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXExtentd_containsq_____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXExtentd, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXExtentd, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXExtentd_containsq_____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "FXExtentd.contains?", 
+    "    bool FXExtentd.contains?(FXVec2d const &p)\n"
+    "    bool FXExtentd.contains?(FXExtentd const &ext)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentd_include(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  FXdouble arg2 ;
+  FXdouble arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  double val3 ;
+  int ecode3 = 0 ;
+  FXExtentd *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd *","include", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","include", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  ecode3 = SWIG_AsVal_double(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXdouble","include", 3, argv[1] ));
+  } 
+  arg3 = static_cast< FXdouble >(val3);
+  result = (FXExtentd *) &(arg1)->include(arg2,arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXExtentd, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentd_includeN_____SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  FXVec2d *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXExtentd *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd *","include", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXVec2d,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXVec2d const &","include", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXVec2d const &","include", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXVec2d * >(argp2);
+  result = (FXExtentd *) &(arg1)->include((FXVec2d const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXExtentd, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentd_includeN_____SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  FXExtentd *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXExtentd *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd *","include", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXExtentd,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXExtentd const &","include", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXExtentd const &","include", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXExtentd * >(argp2);
+  result = (FXExtentd *) &(arg1)->include((FXExtentd const &)*arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXExtentd, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXExtentd_includeN___(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXExtentd, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXVec2d, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXExtentd_includeN_____SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXExtentd, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXExtentd, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXExtentd_includeN_____SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "FXExtentd.include!", 
+    "    FXExtentd FXExtentd.include!(FXVec2d const &v)\n"
+    "    FXExtentd & FXExtentd.include!(FXExtentd const &ext)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentd_corner(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVec2d result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd const *","corner", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = ((FXExtentd const *)arg1)->corner(arg2);
+  vresult = SWIG_NewPointerObj((new FXVec2d(static_cast< const FXVec2d& >(result))), SWIGTYPE_p_FXVec2d, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentd_overlapq___(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  FXExtentd *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd const *","overlap", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXExtentd,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXExtentd const &","overlap", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXExtentd const &","overlap", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXExtentd * >(argp2);
+  result = (bool)FXExtentd_overlap((FXExtentd const *)arg1,(FXExtentd const &)*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentd_unite_with(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  FXExtentd *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXExtentd result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd const *","unite_with", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXExtentd,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXExtentd const &","unite_with", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXExtentd const &","unite_with", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXExtentd * >(argp2);
+  result = FXExtentd_unite_with((FXExtentd const *)arg1,(FXExtentd const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXExtentd(static_cast< const FXExtentd& >(result))), SWIGTYPE_p_FXExtentd, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXExtentd_intersect_with(int argc, VALUE *argv, VALUE self) {
+  FXExtentd *arg1 = (FXExtentd *) 0 ;
+  FXExtentd *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  FXExtentd result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXExtentd, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXExtentd const *","intersect_with", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXExtentd * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXExtentd,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXExtentd const &","intersect_with", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXExtentd const &","intersect_with", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXExtentd * >(argp2);
+  result = FXExtentd_intersect_with((FXExtentd const *)arg1,(FXExtentd const &)*arg2);
+  vresult = SWIG_NewPointerObj((new FXExtentd(static_cast< const FXExtentd& >(result))), SWIGTYPE_p_FXExtentd, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_FXQuatdTo_p_FXVec4d(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXVec4d *)  ((FXQuatd *) x));
+}
+static void *_p_FXQuatfTo_p_FXVec4f(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXVec4f *)  ((FXQuatf *) x));
+}
+static void *_p_FXGradientBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShutterItemTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXMatrixTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXGLViewerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXCanvas *)(FXGLCanvas *) ((FXGLViewer *) x));
+}
+static void *_p_FXPopupTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXHeaderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXSplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSpringTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXProgressBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXToolTipTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXDockSiteTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXGLCanvasTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXCanvas *) ((FXGLCanvas *) x));
+}
+static void *_p_FXCanvasTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXColorWheelTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXScrollBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXComboBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStatusBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXKnobTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXRulerViewTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXStatusLineTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *)  ((FXWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXDockBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXToolBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXDirBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXToolBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolTipTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXTabBookTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXShell *) x));
+}
+static void *_p_FXStatusBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXScrollArea *) x));
+}
+static void *_p_FXPopupTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXComboBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FX4SplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXSplitter *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXPackerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXPacker *) x));
+}
+static void *_p_FXDirBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXSwitcherTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXShutterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXDockSiteTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXRulerViewTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXMatrixTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXShutterItemTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXDockBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXImageViewTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXSpringTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXGLViewerTo_p_FXGLCanvas(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXGLCanvas *)  ((FXGLViewer *) x));
+}
+static void *_p_FXGLCanvasTo_p_FXCanvas(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXCanvas *)  ((FXGLCanvas *) x));
+}
+static void *_p_FXGLViewerTo_p_FXCanvas(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXCanvas *) (FXGLCanvas *) ((FXGLViewer *) x));
+}
+static void *_p_FXGLVisualTo_p_FXVisual(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXVisual *)  ((FXGLVisual *) x));
+}
+static void *_p_FXGradientBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShutterItemTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXMatrixTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXGLViewerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXCanvas *)(FXGLCanvas *) ((FXGLViewer *) x));
+}
+static void *_p_FXPopupTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXDrawableTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXDrawable *) x));
+}
+static void *_p_FXHeaderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXSplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSpringTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXProgressBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXGLContextTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXGLContext *) x));
+}
+static void *_p_FXToolTipTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXDockSiteTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXCanvasTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXGLCanvasTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXCanvas *) ((FXGLCanvas *) x));
+}
+static void *_p_FXColorWheelTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXVisualTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXVisual *) x));
+}
+static void *_p_FXScrollBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXGLVisualTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXVisual *) ((FXGLVisual *) x));
+}
+static void *_p_FXFontTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXFont *) x));
+}
+static void *_p_FXComboBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStatusBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXCursor *) x));
+}
+static void *_p_FXKnobTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRulerViewTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXStatusLineTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXMainWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXDockBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXToolBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDirBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXGLShapeTo_p_FXGLObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXGLObject *)  ((FXGLShape *) x));
+}
+static void *_p_FXDocumentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDocument *) x));
+}
+static void *_p_FXGradientBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXRegistryTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *)(FXSettings *) ((FXRegistry *) x));
+}
+static void *_p_FXHeaderItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXHeaderItem *) x));
+}
+static void *_p_FXShutterItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXIconDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXIconDict *) x));
+}
+static void *_p_FXMatrixTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXFileDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXFileDict *) x));
+}
+static void *_p_FXRecentFilesTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXRecentFiles *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXGLViewerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXCanvas *)(FXGLCanvas *) ((FXGLViewer *) x));
+}
+static void *_p_FXPopupTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXDrawableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXDrawable *) x));
+}
+static void *_p_FXAppTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXApp *) x));
+}
+static void *_p_FXHeaderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXTranslatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXTranslator *) x));
+}
+static void *_p_FX4SplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FXSpringTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXIdTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXId *) x));
+}
+static void *_p_FXGLShapeTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXGLObject *) ((FXGLShape *) x));
+}
+static void *_p_FXProgressBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXGLContextTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXGLContext *) x));
+}
+static void *_p_FXToolTipTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXSettingsTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXSettings *) x));
+}
+static void *_p_FXDockSiteTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDebugTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDebugTarget *) x));
+}
+static void *_p_FXDataTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDataTarget *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXCanvasTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXListBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXGLCanvasTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXCanvas *) ((FXGLCanvas *) x));
+}
+static void *_p_FXColorWheelTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXVisualTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXVisual *) x));
+}
+static void *_p_FXScrollBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXGLVisualTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXVisual *) ((FXGLVisual *) x));
+}
+static void *_p_FXFontTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXFont *) x));
+}
+static void *_p_FXComboBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStringDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXStringDict *) x));
+}
+static void *_p_FXStatusBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXDelegatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDelegator *) x));
+}
+static void *_p_FXAccelTableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXAccelTable *) x));
+}
+static void *_p_FXCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXGLObjectTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXGLObject *) x));
+}
+static void *_p_FXKnobTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRulerViewTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXStatusLineTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXDockBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDict *) x));
+}
+static void *_p_FXShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXToolBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDirBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXFileStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXFileStream *) x));
+}
+static void *_p_FXMemoryStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXMemoryStream *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXToolBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXCompositeTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXComposite *) x));
+}
+static void *_p_FXToolTipTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXTextFieldTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXTabBookTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXGLViewerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXCanvas *)(FXGLCanvas *) ((FXGLViewer *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXStatusBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXPopupTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXRulerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXCanvasTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXCanvas *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXScrollCorner *) x));
+}
+static void *_p_FXGLCanvasTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXCanvas *) ((FXGLCanvas *) x));
+}
+static void *_p_FXSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXStatusLineTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXComboBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXKnobTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FX4SplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FXPackerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXSpinnerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXScrollBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXScrollBar *) x));
+}
+static void *_p_FXColorWheelTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXGradientBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXDirBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXImageFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXDragCornerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXDragCorner *) x));
+}
+static void *_p_FXSwitcherTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXShutterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXProgressBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXDockSiteTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXDockTitleTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXRulerViewTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXListBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXHeaderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXMatrixTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXColorWellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXShutterItemTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXDialTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDockBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXFrame *) x));
+}
+static void *_p_FXTabBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FX7SegmentTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXImageViewTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXSliderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXRealSliderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSpringTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXColorRingTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXColorBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static swig_type_info _swigt__p_FXApp = {"_p_FXApp", "FXApp *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXBitmap = {"_p_FXBitmap", "FXBitmap *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXCanvas = {"_p_FXCanvas", "FXCanvas *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXComposite = {"_p_FXComposite", "FXComposite *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDriveBox = {"_p_FXDriveBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBar = {"_p_FXToolBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolTip = {"_p_FXToolTip", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTabBook = {"_p_FXTabBook", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGroupBox = {"_p_FXGroupBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShell = {"_p_FXShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusBar = {"_p_FXStatusBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollArea = {"_p_FXScrollArea", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPopup = {"_p_FXPopup", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMainWindow = {"_p_FXMainWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplashWindow = {"_p_FXSplashWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollWindow = {"_p_FXScrollWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRootWindow = {"_p_FXRootWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTopWindow = {"_p_FXTopWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXComboBox = {"_p_FXComboBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalFrame = {"_p_FXHorizontalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalFrame = {"_p_FXVerticalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FX4Splitter = {"_p_FX4Splitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplitter = {"_p_FXSplitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRealSpinner = {"_p_FXRealSpinner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSpinner = {"_p_FXSpinner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPacker = {"_p_FXPacker", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDirBox = {"_p_FXDirBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSwitcher = {"_p_FXSwitcher", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDirSelector = {"_p_FXDirSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileSelector = {"_p_FXFileSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorSelector = {"_p_FXColorSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFontSelector = {"_p_FXFontSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutter = {"_p_FXShutter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockSite = {"_p_FXDockSite", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRulerView = {"_p_FXRulerView", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTreeListBox = {"_p_FXTreeListBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXListBox = {"_p_FXListBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMatrix = {"_p_FXMatrix", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutterItem = {"_p_FXShutterItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockBar = {"_p_FXDockBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTabBar = {"_p_FXTabBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImageView = {"_p_FXImageView", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSpring = {"_p_FXSpring", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarShell = {"_p_FXToolBarShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDrawable = {"_p_FXDrawable", "FXDrawable *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGradientBar = {"_p_FXGradientBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorBar = {"_p_FXColorBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTextField = {"_p_FXTextField", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarTab = {"_p_FXToolBarTab", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollCorner = {"_p_FXScrollCorner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXArrowButton = {"_p_FXArrowButton", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHeader = {"_p_FXHeader", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImageFrame = {"_p_FXImageFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalSeparator = {"_p_FXVerticalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalSeparator = {"_p_FXHorizontalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSeparator = {"_p_FXSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXKnob = {"_p_FXKnob", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXProgressBar = {"_p_FXProgressBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXBitmapFrame = {"_p_FXBitmapFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSlider = {"_p_FXSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRealSlider = {"_p_FXRealSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorRing = {"_p_FXColorRing", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockHandler = {"_p_FXDockHandler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWheel = {"_p_FXColorWheel", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDial = {"_p_FXDial", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarGrip = {"_p_FXToolBarGrip", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollBar = {"_p_FXScrollBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFrame = {"_p_FXFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FX7Segment = {"_p_FX7Segment", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockTitle = {"_p_FXDockTitle", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusLine = {"_p_FXStatusLine", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWell = {"_p_FXColorWell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDragCorner = {"_p_FXDragCorner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRuler = {"_p_FXRuler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXExtentd = {"_p_FXExtentd", "FXExtentd *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXExtentf = {"_p_FXExtentf", "FXExtentf *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFont = {"_p_FXFont", "FXFont *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGLCanvas = {"_p_FXGLCanvas", "FXGLCanvas *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGLContext = {"_p_FXGLContext", "FXGLContext *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGLObject = {"_p_FXGLObject", "FXGLObject *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGLShape = {"_p_FXGLShape", "FXGLShape *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGLViewer = {"_p_FXGLViewer", "FXGLViewer *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGLVisual = {"_p_FXGLVisual", "FXGLVisual *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXIcon = {"_p_FXIcon", "FXIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXId = {"_p_FXId", "FXId *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXCursor = {"_p_FXCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCURCursor = {"_p_FXCURCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGIFCursor = {"_p_FXGIFCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXLight = {"_p_FXLight", "FXLight *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMat3d = {"_p_FXMat3d", "FXMat3d *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMat3f = {"_p_FXMat3f", "FXMat3f *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMat4d = {"_p_FXMat4d", "FXMat4d *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMat4f = {"_p_FXMat4f", "FXMat4f *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMaterial = {"_p_FXMaterial", "FXMaterial *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXObject = {"_p_FXObject", "FXObject *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDocument = {"_p_FXDocument", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRegistry = {"_p_FXRegistry", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHeaderItem = {"_p_FXHeaderItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXIconDict = {"_p_FXIconDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileDict = {"_p_FXFileDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRecentFiles = {"_p_FXRecentFiles", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTranslator = {"_p_FXTranslator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDict = {"_p_FXDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSettings = {"_p_FXSettings", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDataTarget = {"_p_FXDataTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDebugTarget = {"_p_FXDebugTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStringDict = {"_p_FXStringDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDelegator = {"_p_FXDelegator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXAccelTable = {"_p_FXAccelTable", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXQuatd = {"_p_FXQuatd", "FXQuatd *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXQuatf = {"_p_FXQuatf", "FXQuatf *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRanged = {"_p_FXRanged", "FXRanged *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRangef = {"_p_FXRangef", "FXRangef *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRegion = {"_p_FXRegion", "FXRegion *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXSphered = {"_p_FXSphered", "FXSphered *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXSpheref = {"_p_FXSpheref", "FXSpheref *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXStream = {"_p_FXStream", "FXStream *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFileStream = {"_p_FXFileStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMemoryStream = {"_p_FXMemoryStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVec2d = {"_p_FXVec2d", "FXVec2d *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXVec2f = {"_p_FXVec2f", "FXVec2f *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXVec3d = {"_p_FXVec3d", "FXVec3d *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXVec3f = {"_p_FXVec3f", "FXVec3f *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXVec4d = {"_p_FXVec4d", "FXVec4d *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXVec4f = {"_p_FXVec4f", "FXVec4f *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXViewport = {"_p_FXViewport", "FXViewport *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXVisual = {"_p_FXVisual", "FXVisual *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXWindow = {"_p_FXWindow", "FXWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_char = {"_p_char", "char *|FXchar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "double *|FXdouble *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_float = {"_p_float", "float *|FXfloat *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "FXint *|int *|FXInputHandle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_long = {"_p_long", "long *|FXTime *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_short = {"_p_short", "short *|FXshort *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "FXuchar *|unsigned char *|FXbool *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "FXwchar *|FXDragType *|unsigned int *|FXuint *|FXColor *|FXSelector *|FXHotKey *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|FXuval *|FXPixel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|FXushort *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_FX4Splitter,
+  &_swigt__p_FX7Segment,
+  &_swigt__p_FXAccelTable,
+  &_swigt__p_FXApp,
+  &_swigt__p_FXArrowButton,
+  &_swigt__p_FXBitmap,
+  &_swigt__p_FXBitmapFrame,
+  &_swigt__p_FXCURCursor,
+  &_swigt__p_FXCanvas,
+  &_swigt__p_FXColorBar,
+  &_swigt__p_FXColorRing,
+  &_swigt__p_FXColorSelector,
+  &_swigt__p_FXColorWell,
+  &_swigt__p_FXColorWheel,
+  &_swigt__p_FXComboBox,
+  &_swigt__p_FXComposite,
+  &_swigt__p_FXCursor,
+  &_swigt__p_FXDataTarget,
+  &_swigt__p_FXDebugTarget,
+  &_swigt__p_FXDelegator,
+  &_swigt__p_FXDial,
+  &_swigt__p_FXDict,
+  &_swigt__p_FXDirBox,
+  &_swigt__p_FXDirSelector,
+  &_swigt__p_FXDockBar,
+  &_swigt__p_FXDockHandler,
+  &_swigt__p_FXDockSite,
+  &_swigt__p_FXDockTitle,
+  &_swigt__p_FXDocument,
+  &_swigt__p_FXDragCorner,
+  &_swigt__p_FXDrawable,
+  &_swigt__p_FXDriveBox,
+  &_swigt__p_FXExtentd,
+  &_swigt__p_FXExtentf,
+  &_swigt__p_FXFileDict,
+  &_swigt__p_FXFileSelector,
+  &_swigt__p_FXFileStream,
+  &_swigt__p_FXFont,
+  &_swigt__p_FXFontSelector,
+  &_swigt__p_FXFrame,
+  &_swigt__p_FXGIFCursor,
+  &_swigt__p_FXGLCanvas,
+  &_swigt__p_FXGLContext,
+  &_swigt__p_FXGLObject,
+  &_swigt__p_FXGLShape,
+  &_swigt__p_FXGLViewer,
+  &_swigt__p_FXGLVisual,
+  &_swigt__p_FXGradientBar,
+  &_swigt__p_FXGroupBox,
+  &_swigt__p_FXHeader,
+  &_swigt__p_FXHeaderItem,
+  &_swigt__p_FXHorizontalFrame,
+  &_swigt__p_FXHorizontalSeparator,
+  &_swigt__p_FXIcon,
+  &_swigt__p_FXIconDict,
+  &_swigt__p_FXId,
+  &_swigt__p_FXImageFrame,
+  &_swigt__p_FXImageView,
+  &_swigt__p_FXKnob,
+  &_swigt__p_FXLight,
+  &_swigt__p_FXListBox,
+  &_swigt__p_FXMainWindow,
+  &_swigt__p_FXMat3d,
+  &_swigt__p_FXMat3f,
+  &_swigt__p_FXMat4d,
+  &_swigt__p_FXMat4f,
+  &_swigt__p_FXMaterial,
+  &_swigt__p_FXMatrix,
+  &_swigt__p_FXMemoryStream,
+  &_swigt__p_FXObject,
+  &_swigt__p_FXPacker,
+  &_swigt__p_FXPopup,
+  &_swigt__p_FXProgressBar,
+  &_swigt__p_FXQuatd,
+  &_swigt__p_FXQuatf,
+  &_swigt__p_FXRanged,
+  &_swigt__p_FXRangef,
+  &_swigt__p_FXRealSlider,
+  &_swigt__p_FXRealSpinner,
+  &_swigt__p_FXRecentFiles,
+  &_swigt__p_FXRegion,
+  &_swigt__p_FXRegistry,
+  &_swigt__p_FXRootWindow,
+  &_swigt__p_FXRuler,
+  &_swigt__p_FXRulerView,
+  &_swigt__p_FXScrollArea,
+  &_swigt__p_FXScrollBar,
+  &_swigt__p_FXScrollCorner,
+  &_swigt__p_FXScrollWindow,
+  &_swigt__p_FXSeparator,
+  &_swigt__p_FXSettings,
+  &_swigt__p_FXShell,
+  &_swigt__p_FXShutter,
+  &_swigt__p_FXShutterItem,
+  &_swigt__p_FXSlider,
+  &_swigt__p_FXSphered,
+  &_swigt__p_FXSpheref,
+  &_swigt__p_FXSpinner,
+  &_swigt__p_FXSplashWindow,
+  &_swigt__p_FXSplitter,
+  &_swigt__p_FXSpring,
+  &_swigt__p_FXStatusBar,
+  &_swigt__p_FXStatusLine,
+  &_swigt__p_FXStream,
+  &_swigt__p_FXStringDict,
+  &_swigt__p_FXSwitcher,
+  &_swigt__p_FXTabBar,
+  &_swigt__p_FXTabBook,
+  &_swigt__p_FXTextField,
+  &_swigt__p_FXToolBar,
+  &_swigt__p_FXToolBarGrip,
+  &_swigt__p_FXToolBarShell,
+  &_swigt__p_FXToolBarTab,
+  &_swigt__p_FXToolTip,
+  &_swigt__p_FXTopWindow,
+  &_swigt__p_FXTranslator,
+  &_swigt__p_FXTreeListBox,
+  &_swigt__p_FXVec2d,
+  &_swigt__p_FXVec2f,
+  &_swigt__p_FXVec3d,
+  &_swigt__p_FXVec3f,
+  &_swigt__p_FXVec4d,
+  &_swigt__p_FXVec4f,
+  &_swigt__p_FXVerticalFrame,
+  &_swigt__p_FXVerticalSeparator,
+  &_swigt__p_FXViewport,
+  &_swigt__p_FXVisual,
+  &_swigt__p_FXWindow,
+  &_swigt__p_char,
+  &_swigt__p_double,
+  &_swigt__p_float,
+  &_swigt__p_int,
+  &_swigt__p_long,
+  &_swigt__p_short,
+  &_swigt__p_unsigned_char,
+  &_swigt__p_unsigned_int,
+  &_swigt__p_unsigned_long,
+  &_swigt__p_unsigned_short,
+};
+
+static swig_cast_info _swigc__p_FXApp[] = {  {&_swigt__p_FXApp, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBitmap[] = {  {&_swigt__p_FXBitmap, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCanvas[] = {  {&_swigt__p_FXCanvas, 0, 0, 0},  {&_swigt__p_FXGLCanvas, _p_FXGLCanvasTo_p_FXCanvas, 0, 0},  {&_swigt__p_FXGLViewer, _p_FXGLViewerTo_p_FXCanvas, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDriveBox[] = {{&_swigt__p_FXDriveBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBar[] = {{&_swigt__p_FXToolBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolTip[] = {{&_swigt__p_FXToolTip, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabBook[] = {{&_swigt__p_FXTabBook, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGroupBox[] = {{&_swigt__p_FXGroupBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShell[] = {{&_swigt__p_FXShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusBar[] = {{&_swigt__p_FXStatusBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollArea[] = {{&_swigt__p_FXScrollArea, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPopup[] = {{&_swigt__p_FXPopup, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMainWindow[] = {{&_swigt__p_FXMainWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplashWindow[] = {{&_swigt__p_FXSplashWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollWindow[] = {{&_swigt__p_FXScrollWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRootWindow[] = {{&_swigt__p_FXRootWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTopWindow[] = {{&_swigt__p_FXTopWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComboBox[] = {{&_swigt__p_FXComboBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalFrame[] = {{&_swigt__p_FXHorizontalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalFrame[] = {{&_swigt__p_FXVerticalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FX4Splitter[] = {{&_swigt__p_FX4Splitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplitter[] = {{&_swigt__p_FXSplitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSpinner[] = {{&_swigt__p_FXRealSpinner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpinner[] = {{&_swigt__p_FXSpinner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPacker[] = {{&_swigt__p_FXPacker, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirBox[] = {{&_swigt__p_FXDirBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSwitcher[] = {{&_swigt__p_FXSwitcher, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirSelector[] = {{&_swigt__p_FXDirSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileSelector[] = {{&_swigt__p_FXFileSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorSelector[] = {{&_swigt__p_FXColorSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFontSelector[] = {{&_swigt__p_FXFontSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutter[] = {{&_swigt__p_FXShutter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockSite[] = {{&_swigt__p_FXDockSite, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRulerView[] = {{&_swigt__p_FXRulerView, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTreeListBox[] = {{&_swigt__p_FXTreeListBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXListBox[] = {{&_swigt__p_FXListBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMatrix[] = {{&_swigt__p_FXMatrix, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutterItem[] = {{&_swigt__p_FXShutterItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockBar[] = {{&_swigt__p_FXDockBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabBar[] = {{&_swigt__p_FXTabBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageView[] = {{&_swigt__p_FXImageView, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpring[] = {{&_swigt__p_FXSpring, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarShell[] = {{&_swigt__p_FXToolBarShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComposite[] = {  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXComposite, 0, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXComposite, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXComposite, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXComposite, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXComposite, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGradientBar[] = {{&_swigt__p_FXGradientBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorBar[] = {{&_swigt__p_FXColorBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTextField[] = {{&_swigt__p_FXTextField, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarTab[] = {{&_swigt__p_FXToolBarTab, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollCorner[] = {{&_swigt__p_FXScrollCorner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXArrowButton[] = {{&_swigt__p_FXArrowButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeader[] = {{&_swigt__p_FXHeader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageFrame[] = {{&_swigt__p_FXImageFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalSeparator[] = {{&_swigt__p_FXVerticalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalSeparator[] = {{&_swigt__p_FXHorizontalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSeparator[] = {{&_swigt__p_FXSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXKnob[] = {{&_swigt__p_FXKnob, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXProgressBar[] = {{&_swigt__p_FXProgressBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBitmapFrame[] = {{&_swigt__p_FXBitmapFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSlider[] = {{&_swigt__p_FXSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSlider[] = {{&_swigt__p_FXRealSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorRing[] = {{&_swigt__p_FXColorRing, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockHandler[] = {{&_swigt__p_FXDockHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWheel[] = {{&_swigt__p_FXColorWheel, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDial[] = {{&_swigt__p_FXDial, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarGrip[] = {{&_swigt__p_FXToolBarGrip, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollBar[] = {{&_swigt__p_FXScrollBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFrame[] = {{&_swigt__p_FXFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FX7Segment[] = {{&_swigt__p_FX7Segment, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockTitle[] = {{&_swigt__p_FXDockTitle, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusLine[] = {{&_swigt__p_FXStatusLine, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWell[] = {{&_swigt__p_FXColorWell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDragCorner[] = {{&_swigt__p_FXDragCorner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRuler[] = {{&_swigt__p_FXRuler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDrawable[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXGLViewer, _p_FXGLViewerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDrawable, 0, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXGLCanvas, _p_FXGLCanvasTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXDrawable, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXExtentd[] = {  {&_swigt__p_FXExtentd, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXExtentf[] = {  {&_swigt__p_FXExtentf, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFont[] = {  {&_swigt__p_FXFont, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGLCanvas[] = {  {&_swigt__p_FXGLCanvas, 0, 0, 0},  {&_swigt__p_FXGLViewer, _p_FXGLViewerTo_p_FXGLCanvas, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGLContext[] = {  {&_swigt__p_FXGLContext, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGLObject[] = {  {&_swigt__p_FXGLShape, _p_FXGLShapeTo_p_FXGLObject, 0, 0},  {&_swigt__p_FXGLObject, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGLShape[] = {  {&_swigt__p_FXGLShape, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGLViewer[] = {  {&_swigt__p_FXGLViewer, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGLVisual[] = {  {&_swigt__p_FXGLVisual, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIcon[] = {  {&_swigt__p_FXIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCursor[] = {{&_swigt__p_FXCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCURCursor[] = {{&_swigt__p_FXCURCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGIFCursor[] = {{&_swigt__p_FXGIFCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXId[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXId, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXId, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXId, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXId, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXId, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXId, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXGLViewer, _p_FXGLViewerTo_p_FXId, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXId, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXId, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXId, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXId, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXId, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXId, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXId, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXId, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXId, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXId, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXId, 0, 0},  {&_swigt__p_FXGLContext, _p_FXGLContextTo_p_FXId, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXId, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXId, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXId, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXId, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXId, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXGLCanvas, _p_FXGLCanvasTo_p_FXId, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXId, 0, 0},  {&_swigt__p_FXId, 0, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXId, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXId, 0, 0},  {&_swigt__p_FXGLVisual, _p_FXGLVisualTo_p_FXId, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXId, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXId, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXId, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXId, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXId, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXId, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXId, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXId, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXId, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXId, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXId, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXId, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXLight[] = {  {&_swigt__p_FXLight, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMat3d[] = {  {&_swigt__p_FXMat3d, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMat3f[] = {  {&_swigt__p_FXMat3f, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMat4d[] = {  {&_swigt__p_FXMat4d, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMat4f[] = {  {&_swigt__p_FXMat4f, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMaterial[] = {  {&_swigt__p_FXMaterial, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDocument[] = {{&_swigt__p_FXDocument, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegistry[] = {{&_swigt__p_FXRegistry, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeaderItem[] = {{&_swigt__p_FXHeaderItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIconDict[] = {{&_swigt__p_FXIconDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileDict[] = {{&_swigt__p_FXFileDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRecentFiles[] = {{&_swigt__p_FXRecentFiles, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTranslator[] = {{&_swigt__p_FXTranslator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDict[] = {{&_swigt__p_FXDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSettings[] = {{&_swigt__p_FXSettings, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDataTarget[] = {{&_swigt__p_FXDataTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDebugTarget[] = {{&_swigt__p_FXDebugTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStringDict[] = {{&_swigt__p_FXStringDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDelegator[] = {{&_swigt__p_FXDelegator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXAccelTable[] = {{&_swigt__p_FXAccelTable, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXObject[] = {  {&_swigt__p_FXDocument, _p_FXDocumentTo_p_FXObject, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXRegistry, _p_FXRegistryTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeaderItem, _p_FXHeaderItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXObject, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXObject, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXIconDict, _p_FXIconDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileDict, _p_FXFileDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXRecentFiles, _p_FXRecentFilesTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXObject, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXGLViewer, _p_FXGLViewerTo_p_FXObject, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXObject, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXObject, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FXTranslator, _p_FXTranslatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXObject, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXObject, 0, 0},  {&_swigt__p_FXApp, _p_FXAppTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXObject, 0, 0},  {&_swigt__p_FXGLShape, _p_FXGLShapeTo_p_FXObject, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXObject, 0, 0},  {&_swigt__p_FXGLContext, _p_FXGLContextTo_p_FXObject, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXObject, 0, 0},  {&_swigt__p_FXDict, _p_FXDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXSettings, _p_FXSettingsTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXObject, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXObject, 0, 0},  {&_swigt__p_FXDataTarget, _p_FXDataTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDebugTarget, _p_FXDebugTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXObject, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXGLCanvas, _p_FXGLCanvasTo_p_FXObject, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXObject, 0, 0},  {&_swigt__p_FXId, _p_FXIdTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXObject, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXGLVisual, _p_FXGLVisualTo_p_FXObject, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXObject, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXStringDict, _p_FXStringDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXDelegator, _p_FXDelegatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXAccelTable, _p_FXAccelTableTo_p_FXObject, 0, 0},  {&_swigt__p_FXObject, 0, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXGLObject, _p_FXGLObjectTo_p_FXObject, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXObject, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXObject, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXObject, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXObject, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXObject, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXQuatd[] = {  {&_swigt__p_FXQuatd, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXQuatf[] = {  {&_swigt__p_FXQuatf, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRanged[] = {  {&_swigt__p_FXRanged, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRangef[] = {  {&_swigt__p_FXRangef, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegion[] = {  {&_swigt__p_FXRegion, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSphered[] = {  {&_swigt__p_FXSphered, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpheref[] = {  {&_swigt__p_FXSpheref, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileStream[] = {{&_swigt__p_FXFileStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMemoryStream[] = {{&_swigt__p_FXMemoryStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStream[] = {  {&_swigt__p_FXFileStream, _p_FXFileStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXMemoryStream, _p_FXMemoryStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVec2d[] = {  {&_swigt__p_FXVec2d, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVec2f[] = {  {&_swigt__p_FXVec2f, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVec3d[] = {  {&_swigt__p_FXVec3d, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVec3f[] = {  {&_swigt__p_FXVec3f, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVec4d[] = {  {&_swigt__p_FXQuatd, _p_FXQuatdTo_p_FXVec4d, 0, 0},  {&_swigt__p_FXVec4d, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVec4f[] = {  {&_swigt__p_FXVec4f, 0, 0, 0},  {&_swigt__p_FXQuatf, _p_FXQuatfTo_p_FXVec4f, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXViewport[] = {  {&_swigt__p_FXViewport, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVisual[] = {  {&_swigt__p_FXVisual, 0, 0, 0},  {&_swigt__p_FXGLVisual, _p_FXGLVisualTo_p_FXVisual, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXWindow[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXGLViewer, _p_FXGLViewerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXWindow, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXWindow, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXWindow, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXWindow, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXWindow, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXWindow, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXGLCanvas, _p_FXGLCanvasTo_p_FXWindow, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXWindow, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXWindow, 0, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXWindow, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
+
+static swig_cast_info *swig_cast_initial[] = {
+  _swigc__p_FX4Splitter,
+  _swigc__p_FX7Segment,
+  _swigc__p_FXAccelTable,
+  _swigc__p_FXApp,
+  _swigc__p_FXArrowButton,
+  _swigc__p_FXBitmap,
+  _swigc__p_FXBitmapFrame,
+  _swigc__p_FXCURCursor,
+  _swigc__p_FXCanvas,
+  _swigc__p_FXColorBar,
+  _swigc__p_FXColorRing,
+  _swigc__p_FXColorSelector,
+  _swigc__p_FXColorWell,
+  _swigc__p_FXColorWheel,
+  _swigc__p_FXComboBox,
+  _swigc__p_FXComposite,
+  _swigc__p_FXCursor,
+  _swigc__p_FXDataTarget,
+  _swigc__p_FXDebugTarget,
+  _swigc__p_FXDelegator,
+  _swigc__p_FXDial,
+  _swigc__p_FXDict,
+  _swigc__p_FXDirBox,
+  _swigc__p_FXDirSelector,
+  _swigc__p_FXDockBar,
+  _swigc__p_FXDockHandler,
+  _swigc__p_FXDockSite,
+  _swigc__p_FXDockTitle,
+  _swigc__p_FXDocument,
+  _swigc__p_FXDragCorner,
+  _swigc__p_FXDrawable,
+  _swigc__p_FXDriveBox,
+  _swigc__p_FXExtentd,
+  _swigc__p_FXExtentf,
+  _swigc__p_FXFileDict,
+  _swigc__p_FXFileSelector,
+  _swigc__p_FXFileStream,
+  _swigc__p_FXFont,
+  _swigc__p_FXFontSelector,
+  _swigc__p_FXFrame,
+  _swigc__p_FXGIFCursor,
+  _swigc__p_FXGLCanvas,
+  _swigc__p_FXGLContext,
+  _swigc__p_FXGLObject,
+  _swigc__p_FXGLShape,
+  _swigc__p_FXGLViewer,
+  _swigc__p_FXGLVisual,
+  _swigc__p_FXGradientBar,
+  _swigc__p_FXGroupBox,
+  _swigc__p_FXHeader,
+  _swigc__p_FXHeaderItem,
+  _swigc__p_FXHorizontalFrame,
+  _swigc__p_FXHorizontalSeparator,
+  _swigc__p_FXIcon,
+  _swigc__p_FXIconDict,
+  _swigc__p_FXId,
+  _swigc__p_FXImageFrame,
+  _swigc__p_FXImageView,
+  _swigc__p_FXKnob,
+  _swigc__p_FXLight,
+  _swigc__p_FXListBox,
+  _swigc__p_FXMainWindow,
+  _swigc__p_FXMat3d,
+  _swigc__p_FXMat3f,
+  _swigc__p_FXMat4d,
+  _swigc__p_FXMat4f,
+  _swigc__p_FXMaterial,
+  _swigc__p_FXMatrix,
+  _swigc__p_FXMemoryStream,
+  _swigc__p_FXObject,
+  _swigc__p_FXPacker,
+  _swigc__p_FXPopup,
+  _swigc__p_FXProgressBar,
+  _swigc__p_FXQuatd,
+  _swigc__p_FXQuatf,
+  _swigc__p_FXRanged,
+  _swigc__p_FXRangef,
+  _swigc__p_FXRealSlider,
+  _swigc__p_FXRealSpinner,
+  _swigc__p_FXRecentFiles,
+  _swigc__p_FXRegion,
+  _swigc__p_FXRegistry,
+  _swigc__p_FXRootWindow,
+  _swigc__p_FXRuler,
+  _swigc__p_FXRulerView,
+  _swigc__p_FXScrollArea,
+  _swigc__p_FXScrollBar,
+  _swigc__p_FXScrollCorner,
+  _swigc__p_FXScrollWindow,
+  _swigc__p_FXSeparator,
+  _swigc__p_FXSettings,
+  _swigc__p_FXShell,
+  _swigc__p_FXShutter,
+  _swigc__p_FXShutterItem,
+  _swigc__p_FXSlider,
+  _swigc__p_FXSphered,
+  _swigc__p_FXSpheref,
+  _swigc__p_FXSpinner,
+  _swigc__p_FXSplashWindow,
+  _swigc__p_FXSplitter,
+  _swigc__p_FXSpring,
+  _swigc__p_FXStatusBar,
+  _swigc__p_FXStatusLine,
+  _swigc__p_FXStream,
+  _swigc__p_FXStringDict,
+  _swigc__p_FXSwitcher,
+  _swigc__p_FXTabBar,
+  _swigc__p_FXTabBook,
+  _swigc__p_FXTextField,
+  _swigc__p_FXToolBar,
+  _swigc__p_FXToolBarGrip,
+  _swigc__p_FXToolBarShell,
+  _swigc__p_FXToolBarTab,
+  _swigc__p_FXToolTip,
+  _swigc__p_FXTopWindow,
+  _swigc__p_FXTranslator,
+  _swigc__p_FXTreeListBox,
+  _swigc__p_FXVec2d,
+  _swigc__p_FXVec2f,
+  _swigc__p_FXVec3d,
+  _swigc__p_FXVec3f,
+  _swigc__p_FXVec4d,
+  _swigc__p_FXVec4f,
+  _swigc__p_FXVerticalFrame,
+  _swigc__p_FXVerticalSeparator,
+  _swigc__p_FXViewport,
+  _swigc__p_FXVisual,
+  _swigc__p_FXWindow,
+  _swigc__p_char,
+  _swigc__p_double,
+  _swigc__p_float,
+  _swigc__p_int,
+  _swigc__p_long,
+  _swigc__p_short,
+  _swigc__p_unsigned_char,
+  _swigc__p_unsigned_int,
+  _swigc__p_unsigned_long,
+  _swigc__p_unsigned_short,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned statically to an initial
+ * array. We just loop through that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded.
+ * There are three cases to handle:
+ *  1) If the cast->type has already been loaded AND the type we are adding
+ *     casting info to has not been loaded (it is in this module), THEN we
+ *     replace the cast->type pointer with the type pointer that has already
+ *     been loaded.
+ *  2) If BOTH types (the one we are adding casting info to, and the
+ *     cast->type) are loaded, THEN the cast info has already been loaded by
+ *     the previous module so we just ignore it.
+ *  3) Finally, if cast->type has not already been loaded, then we add that
+ *     swig_cast_info to the linked list (because the cast->type) pointer will
+ *     be correct.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* c-mode */
+#endif
+#endif
+
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+  size_t i;
+  swig_module_info *module_head, *iter;
+  int init;
+
+  /* check to see if the circular list has been setup, if not, set it up */
+  if (swig_module.next==0) {
+    /* Initialize the swig_module */
+    swig_module.type_initial = swig_type_initial;
+    swig_module.cast_initial = swig_cast_initial;
+    swig_module.next = &swig_module;
+    init = 1;
+  } else {
+    init = 0;
+  }
+
+  /* Try and load any already created modules */
+  module_head = SWIG_GetModule(clientdata);
+  if (!module_head) {
+    /* This is the first module loaded for this interpreter */
+    /* so set the swig module into the interpreter */
+    SWIG_SetModule(clientdata, &swig_module);
+  } else {
+    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+    iter=module_head;
+    do {
+      if (iter==&swig_module) {
+        /* Our module is already in the list, so there's nothing more to do. */
+        return;
+      }
+      iter=iter->next;
+    } while (iter!= module_head);
+
+    /* otherwise we must add our module into the list */
+    swig_module.next = module_head->next;
+    module_head->next = &swig_module;
+  }
+
+  /* When multiple interpreters are used, a module could have already been initialized in
+     a different interpreter, but not yet have a pointer in this interpreter.
+     In this case, we do not want to continue adding types... everything should be
+     set up already */
+  if (init == 0) return;
+
+  /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+  for (i = 0; i < swig_module.size; ++i) {
+    swig_type_info *type = 0;
+    swig_type_info *ret;
+    swig_cast_info *cast;
+
+#ifdef SWIGRUNTIME_DEBUG
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+
+    /* if there is another module already loaded */
+    if (swig_module.next != &swig_module) {
+      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
+    }
+    if (type) {
+      /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+      if (swig_module.type_initial[i]->clientdata) {
+	type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+      }
+    } else {
+      type = swig_module.type_initial[i];
+    }
+
+    /* Insert casting types */
+    cast = swig_module.cast_initial[i];
+    while (cast->type) {
+
+      /* Don't need to add information already in the list */
+      ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+      if (swig_module.next != &swig_module) {
+        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+      }
+      if (ret) {
+	if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+	  cast->type = ret;
+	  ret = 0;
+	} else {
+	  /* Check for casting already in the list */
+	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+	  if (!ocast) ret = 0;
+	}
+      }
+
+      if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+        if (type->cast) {
+          type->cast->prev = cast;
+          cast->next = type->cast;
+        }
+        type->cast = cast;
+      }
+      cast++;
+    }
+    /* Set entry in modules->types array equal to the type */
+    swig_module.types[i] = type;
+  }
+  swig_module.types[i] = 0;
+
+#ifdef SWIGRUNTIME_DEBUG
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+  for (i = 0; i < swig_module.size; ++i) {
+    int j = 0;
+    swig_cast_info *cast = swig_module.cast_initial[i];
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    while (cast->type) {
+      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+      cast++;
+      ++j;
+    }
+  printf("---- Total casts: %d\n",j);
+  }
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types.  It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+  size_t i;
+  swig_cast_info *equiv;
+  static int init_run = 0;
+
+  if (init_run) return;
+  init_run = 1;
+
+  for (i = 0; i < swig_module.size; i++) {
+    if (swig_module.types[i]->clientdata) {
+      equiv = swig_module.types[i]->cast;
+      while (equiv) {
+        if (!equiv->converter) {
+          if (equiv->type && !equiv->type->clientdata)
+            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+        }
+        equiv = equiv->next;
+      }
+    }
+  }
+}
+
+#ifdef __cplusplus
+#if 0
+{ /* c-mode */
+#endif
+}
+#endif
+
+/*
+
+*/
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void Init_fx3d(void) {
+  size_t i;
+  
+  SWIG_InitRuntime();
+  
+  
+  SWIG_InitializeModule(0);
+  for (i = 0; i < swig_module.size; i++) {
+    SWIG_define_class(swig_module.types[i]);
+  }
+  
+  SWIG_RubyInitializeTrackings();
+  
+  
+  
+  
+  
+  SwigClassFXVec2f.klass = rb_define_class_under(mFox, "FXVec2f", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXVec2f, (void *) &SwigClassFXVec2f);
+  rb_define_alloc_func(SwigClassFXVec2f.klass, _wrap_FXVec2f_allocate);
+  rb_define_method(SwigClassFXVec2f.klass, "initialize", VALUEFUNC(_wrap_new_FXVec2f), -1);
+  rb_define_method(SwigClassFXVec2f.klass, "x=", VALUEFUNC(_wrap_FXVec2f_x_set), -1);
+  rb_define_method(SwigClassFXVec2f.klass, "x", VALUEFUNC(_wrap_FXVec2f_x_get), -1);
+  rb_define_method(SwigClassFXVec2f.klass, "y=", VALUEFUNC(_wrap_FXVec2f_y_set), -1);
+  rb_define_method(SwigClassFXVec2f.klass, "y", VALUEFUNC(_wrap_FXVec2f_y_get), -1);
+  rb_define_method(SwigClassFXVec2f.klass, "length2", VALUEFUNC(_wrap_FXVec2f_length2), -1);
+  rb_define_method(SwigClassFXVec2f.klass, "length", VALUEFUNC(_wrap_FXVec2f_length), -1);
+  rb_define_method(SwigClassFXVec2f.klass, "[]", VALUEFUNC(_wrap_FXVec2f___getitem__), -1);
+  rb_define_method(SwigClassFXVec2f.klass, "[]=", VALUEFUNC(_wrap_FXVec2f___setitem__), -1);
+  rb_define_method(SwigClassFXVec2f.klass, "-@", VALUEFUNC(_wrap_FXVec2f___neg__), -1);
+  rb_define_method(SwigClassFXVec2f.klass, "+", VALUEFUNC(_wrap_FXVec2f___add__), -1);
+  rb_define_method(SwigClassFXVec2f.klass, "-", VALUEFUNC(_wrap_FXVec2f___sub__), -1);
+  rb_define_method(SwigClassFXVec2f.klass, "/", VALUEFUNC(_wrap_FXVec2f___div__), -1);
+  rb_define_method(SwigClassFXVec2f.klass, "*", VALUEFUNC(_wrap_FXVec2f___mul__), -1);
+  rb_define_method(SwigClassFXVec2f.klass, "dot", VALUEFUNC(_wrap_FXVec2f_dot), -1);
+  rb_define_method(SwigClassFXVec2f.klass, "==", VALUEFUNC(_wrap_FXVec2f___eq__), -1);
+  rb_define_method(SwigClassFXVec2f.klass, "normalize", VALUEFUNC(_wrap_FXVec2f_normalize), -1);
+  rb_define_method(SwigClassFXVec2f.klass, "lo", VALUEFUNC(_wrap_FXVec2f_lo), -1);
+  rb_define_method(SwigClassFXVec2f.klass, "hi", VALUEFUNC(_wrap_FXVec2f_hi), -1);
+  rb_define_method(SwigClassFXVec2f.klass, "clamp", VALUEFUNC(_wrap_FXVec2f_clamp), -1);
+  SwigClassFXVec2f.mark = 0;
+  SwigClassFXVec2f.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXVec2f.trackObjects = 0;
+  
+  SwigClassFXVec2d.klass = rb_define_class_under(mFox, "FXVec2d", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXVec2d, (void *) &SwigClassFXVec2d);
+  rb_define_alloc_func(SwigClassFXVec2d.klass, _wrap_FXVec2d_allocate);
+  rb_define_method(SwigClassFXVec2d.klass, "initialize", VALUEFUNC(_wrap_new_FXVec2d), -1);
+  rb_define_method(SwigClassFXVec2d.klass, "x=", VALUEFUNC(_wrap_FXVec2d_x_set), -1);
+  rb_define_method(SwigClassFXVec2d.klass, "x", VALUEFUNC(_wrap_FXVec2d_x_get), -1);
+  rb_define_method(SwigClassFXVec2d.klass, "y=", VALUEFUNC(_wrap_FXVec2d_y_set), -1);
+  rb_define_method(SwigClassFXVec2d.klass, "y", VALUEFUNC(_wrap_FXVec2d_y_get), -1);
+  rb_define_method(SwigClassFXVec2d.klass, "length2", VALUEFUNC(_wrap_FXVec2d_length2), -1);
+  rb_define_method(SwigClassFXVec2d.klass, "length", VALUEFUNC(_wrap_FXVec2d_length), -1);
+  rb_define_method(SwigClassFXVec2d.klass, "[]", VALUEFUNC(_wrap_FXVec2d___getitem__), -1);
+  rb_define_method(SwigClassFXVec2d.klass, "[]=", VALUEFUNC(_wrap_FXVec2d___setitem__), -1);
+  rb_define_method(SwigClassFXVec2d.klass, "-@", VALUEFUNC(_wrap_FXVec2d___neg__), -1);
+  rb_define_method(SwigClassFXVec2d.klass, "+", VALUEFUNC(_wrap_FXVec2d___add__), -1);
+  rb_define_method(SwigClassFXVec2d.klass, "-", VALUEFUNC(_wrap_FXVec2d___sub__), -1);
+  rb_define_method(SwigClassFXVec2d.klass, "/", VALUEFUNC(_wrap_FXVec2d___div__), -1);
+  rb_define_method(SwigClassFXVec2d.klass, "*", VALUEFUNC(_wrap_FXVec2d___mul__), -1);
+  rb_define_method(SwigClassFXVec2d.klass, "dot", VALUEFUNC(_wrap_FXVec2d_dot), -1);
+  rb_define_method(SwigClassFXVec2d.klass, "==", VALUEFUNC(_wrap_FXVec2d___eq__), -1);
+  rb_define_method(SwigClassFXVec2d.klass, "normalize", VALUEFUNC(_wrap_FXVec2d_normalize), -1);
+  rb_define_method(SwigClassFXVec2d.klass, "lo", VALUEFUNC(_wrap_FXVec2d_lo), -1);
+  rb_define_method(SwigClassFXVec2d.klass, "hi", VALUEFUNC(_wrap_FXVec2d_hi), -1);
+  rb_define_method(SwigClassFXVec2d.klass, "clamp", VALUEFUNC(_wrap_FXVec2d_clamp), -1);
+  SwigClassFXVec2d.mark = 0;
+  SwigClassFXVec2d.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXVec2d.trackObjects = 0;
+  
+  SwigClassFXVec3f.klass = rb_define_class_under(mFox, "FXVec3f", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXVec3f, (void *) &SwigClassFXVec3f);
+  rb_define_alloc_func(SwigClassFXVec3f.klass, _wrap_FXVec3f_allocate);
+  rb_define_method(SwigClassFXVec3f.klass, "initialize", VALUEFUNC(_wrap_new_FXVec3f), -1);
+  rb_define_method(SwigClassFXVec3f.klass, "x=", VALUEFUNC(_wrap_FXVec3f_x_set), -1);
+  rb_define_method(SwigClassFXVec3f.klass, "x", VALUEFUNC(_wrap_FXVec3f_x_get), -1);
+  rb_define_method(SwigClassFXVec3f.klass, "y=", VALUEFUNC(_wrap_FXVec3f_y_set), -1);
+  rb_define_method(SwigClassFXVec3f.klass, "y", VALUEFUNC(_wrap_FXVec3f_y_get), -1);
+  rb_define_method(SwigClassFXVec3f.klass, "z=", VALUEFUNC(_wrap_FXVec3f_z_set), -1);
+  rb_define_method(SwigClassFXVec3f.klass, "z", VALUEFUNC(_wrap_FXVec3f_z_get), -1);
+  rb_define_method(SwigClassFXVec3f.klass, "length2", VALUEFUNC(_wrap_FXVec3f_length2), -1);
+  rb_define_method(SwigClassFXVec3f.klass, "length", VALUEFUNC(_wrap_FXVec3f_length), -1);
+  rb_define_method(SwigClassFXVec3f.klass, "[]", VALUEFUNC(_wrap_FXVec3f___getitem__), -1);
+  rb_define_method(SwigClassFXVec3f.klass, "[]=", VALUEFUNC(_wrap_FXVec3f___setitem__), -1);
+  rb_define_method(SwigClassFXVec3f.klass, "-@", VALUEFUNC(_wrap_FXVec3f___neg__), -1);
+  rb_define_method(SwigClassFXVec3f.klass, "+", VALUEFUNC(_wrap_FXVec3f___add__), -1);
+  rb_define_method(SwigClassFXVec3f.klass, "-", VALUEFUNC(_wrap_FXVec3f___sub__), -1);
+  rb_define_method(SwigClassFXVec3f.klass, "/", VALUEFUNC(_wrap_FXVec3f___div__), -1);
+  rb_define_method(SwigClassFXVec3f.klass, "*", VALUEFUNC(_wrap_FXVec3f___mul__), -1);
+  rb_define_method(SwigClassFXVec3f.klass, "dot", VALUEFUNC(_wrap_FXVec3f_dot), -1);
+  rb_define_method(SwigClassFXVec3f.klass, "^", VALUEFUNC(_wrap_FXVec3f___xor__), -1);
+  rb_define_method(SwigClassFXVec3f.klass, "cross", VALUEFUNC(_wrap_FXVec3f_cross), -1);
+  rb_define_method(SwigClassFXVec3f.klass, "==", VALUEFUNC(_wrap_FXVec3f___eq__), -1);
+  rb_define_method(SwigClassFXVec3f.klass, "normalize", VALUEFUNC(_wrap_FXVec3f_normalize), -1);
+  rb_define_method(SwigClassFXVec3f.klass, "lo", VALUEFUNC(_wrap_FXVec3f_lo), -1);
+  rb_define_method(SwigClassFXVec3f.klass, "hi", VALUEFUNC(_wrap_FXVec3f_hi), -1);
+  rb_define_singleton_method(SwigClassFXVec3f.klass, "normal", VALUEFUNC(_wrap_FXVec3f_normal), -1);
+  rb_define_method(SwigClassFXVec3f.klass, "clamp", VALUEFUNC(_wrap_FXVec3f_clamp), -1);
+  SwigClassFXVec3f.mark = 0;
+  SwigClassFXVec3f.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXVec3f.trackObjects = 0;
+  
+  SwigClassFXVec3d.klass = rb_define_class_under(mFox, "FXVec3d", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXVec3d, (void *) &SwigClassFXVec3d);
+  rb_define_alloc_func(SwigClassFXVec3d.klass, _wrap_FXVec3d_allocate);
+  rb_define_method(SwigClassFXVec3d.klass, "initialize", VALUEFUNC(_wrap_new_FXVec3d), -1);
+  rb_define_method(SwigClassFXVec3d.klass, "x=", VALUEFUNC(_wrap_FXVec3d_x_set), -1);
+  rb_define_method(SwigClassFXVec3d.klass, "x", VALUEFUNC(_wrap_FXVec3d_x_get), -1);
+  rb_define_method(SwigClassFXVec3d.klass, "y=", VALUEFUNC(_wrap_FXVec3d_y_set), -1);
+  rb_define_method(SwigClassFXVec3d.klass, "y", VALUEFUNC(_wrap_FXVec3d_y_get), -1);
+  rb_define_method(SwigClassFXVec3d.klass, "z=", VALUEFUNC(_wrap_FXVec3d_z_set), -1);
+  rb_define_method(SwigClassFXVec3d.klass, "z", VALUEFUNC(_wrap_FXVec3d_z_get), -1);
+  rb_define_method(SwigClassFXVec3d.klass, "length2", VALUEFUNC(_wrap_FXVec3d_length2), -1);
+  rb_define_method(SwigClassFXVec3d.klass, "length", VALUEFUNC(_wrap_FXVec3d_length), -1);
+  rb_define_method(SwigClassFXVec3d.klass, "[]", VALUEFUNC(_wrap_FXVec3d___getitem__), -1);
+  rb_define_method(SwigClassFXVec3d.klass, "[]=", VALUEFUNC(_wrap_FXVec3d___setitem__), -1);
+  rb_define_method(SwigClassFXVec3d.klass, "-@", VALUEFUNC(_wrap_FXVec3d___neg__), -1);
+  rb_define_method(SwigClassFXVec3d.klass, "+", VALUEFUNC(_wrap_FXVec3d___add__), -1);
+  rb_define_method(SwigClassFXVec3d.klass, "-", VALUEFUNC(_wrap_FXVec3d___sub__), -1);
+  rb_define_method(SwigClassFXVec3d.klass, "/", VALUEFUNC(_wrap_FXVec3d___div__), -1);
+  rb_define_method(SwigClassFXVec3d.klass, "*", VALUEFUNC(_wrap_FXVec3d___mul__), -1);
+  rb_define_method(SwigClassFXVec3d.klass, "dot", VALUEFUNC(_wrap_FXVec3d_dot), -1);
+  rb_define_method(SwigClassFXVec3d.klass, "^", VALUEFUNC(_wrap_FXVec3d___xor__), -1);
+  rb_define_method(SwigClassFXVec3d.klass, "cross", VALUEFUNC(_wrap_FXVec3d_cross), -1);
+  rb_define_method(SwigClassFXVec3d.klass, "==", VALUEFUNC(_wrap_FXVec3d___eq__), -1);
+  rb_define_method(SwigClassFXVec3d.klass, "normalize", VALUEFUNC(_wrap_FXVec3d_normalize), -1);
+  rb_define_method(SwigClassFXVec3d.klass, "lo", VALUEFUNC(_wrap_FXVec3d_lo), -1);
+  rb_define_method(SwigClassFXVec3d.klass, "hi", VALUEFUNC(_wrap_FXVec3d_hi), -1);
+  rb_define_singleton_method(SwigClassFXVec3d.klass, "normal", VALUEFUNC(_wrap_FXVec3d_normal), -1);
+  rb_define_method(SwigClassFXVec3d.klass, "clamp", VALUEFUNC(_wrap_FXVec3d_clamp), -1);
+  SwigClassFXVec3d.mark = 0;
+  SwigClassFXVec3d.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXVec3d.trackObjects = 0;
+  
+  SwigClassFXVec4f.klass = rb_define_class_under(mFox, "FXVec4f", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXVec4f, (void *) &SwigClassFXVec4f);
+  rb_define_alloc_func(SwigClassFXVec4f.klass, _wrap_FXVec4f_allocate);
+  rb_define_method(SwigClassFXVec4f.klass, "initialize", VALUEFUNC(_wrap_new_FXVec4f), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "x=", VALUEFUNC(_wrap_FXVec4f_x_set), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "x", VALUEFUNC(_wrap_FXVec4f_x_get), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "y=", VALUEFUNC(_wrap_FXVec4f_y_set), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "y", VALUEFUNC(_wrap_FXVec4f_y_get), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "z=", VALUEFUNC(_wrap_FXVec4f_z_set), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "z", VALUEFUNC(_wrap_FXVec4f_z_get), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "w=", VALUEFUNC(_wrap_FXVec4f_w_set), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "w", VALUEFUNC(_wrap_FXVec4f_w_get), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "distance", VALUEFUNC(_wrap_FXVec4f_distance), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "crosses?", VALUEFUNC(_wrap_FXVec4f_crossesq___), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "length", VALUEFUNC(_wrap_FXVec4f_length), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "length2", VALUEFUNC(_wrap_FXVec4f_length2), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "[]", VALUEFUNC(_wrap_FXVec4f___getitem__), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "[]=", VALUEFUNC(_wrap_FXVec4f___setitem__), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "-@", VALUEFUNC(_wrap_FXVec4f___neg__), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "+", VALUEFUNC(_wrap_FXVec4f___add__), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "-", VALUEFUNC(_wrap_FXVec4f___sub__), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "/", VALUEFUNC(_wrap_FXVec4f___div__), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "*", VALUEFUNC(_wrap_FXVec4f___mul__), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "dot", VALUEFUNC(_wrap_FXVec4f_dot), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "==", VALUEFUNC(_wrap_FXVec4f___eq__), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "normalize", VALUEFUNC(_wrap_FXVec4f_normalize), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "lo", VALUEFUNC(_wrap_FXVec4f_lo), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "hi", VALUEFUNC(_wrap_FXVec4f_hi), -1);
+  rb_define_singleton_method(SwigClassFXVec4f.klass, "plane", VALUEFUNC(_wrap_FXVec4f_plane), -1);
+  rb_define_method(SwigClassFXVec4f.klass, "clamp", VALUEFUNC(_wrap_FXVec4f_clamp), -1);
+  SwigClassFXVec4f.mark = 0;
+  SwigClassFXVec4f.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXVec4f.trackObjects = 0;
+  
+  SwigClassFXVec4d.klass = rb_define_class_under(mFox, "FXVec4d", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXVec4d, (void *) &SwigClassFXVec4d);
+  rb_define_alloc_func(SwigClassFXVec4d.klass, _wrap_FXVec4d_allocate);
+  rb_define_method(SwigClassFXVec4d.klass, "initialize", VALUEFUNC(_wrap_new_FXVec4d), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "x=", VALUEFUNC(_wrap_FXVec4d_x_set), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "x", VALUEFUNC(_wrap_FXVec4d_x_get), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "y=", VALUEFUNC(_wrap_FXVec4d_y_set), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "y", VALUEFUNC(_wrap_FXVec4d_y_get), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "z=", VALUEFUNC(_wrap_FXVec4d_z_set), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "z", VALUEFUNC(_wrap_FXVec4d_z_get), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "w=", VALUEFUNC(_wrap_FXVec4d_w_set), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "w", VALUEFUNC(_wrap_FXVec4d_w_get), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "distance", VALUEFUNC(_wrap_FXVec4d_distance), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "crosses?", VALUEFUNC(_wrap_FXVec4d_crossesq___), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "length2", VALUEFUNC(_wrap_FXVec4d_length2), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "length", VALUEFUNC(_wrap_FXVec4d_length), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "[]", VALUEFUNC(_wrap_FXVec4d___getitem__), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "[]=", VALUEFUNC(_wrap_FXVec4d___setitem__), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "-@", VALUEFUNC(_wrap_FXVec4d___neg__), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "+", VALUEFUNC(_wrap_FXVec4d___add__), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "-", VALUEFUNC(_wrap_FXVec4d___sub__), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "/", VALUEFUNC(_wrap_FXVec4d___div__), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "*", VALUEFUNC(_wrap_FXVec4d___mul__), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "dot", VALUEFUNC(_wrap_FXVec4d_dot), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "==", VALUEFUNC(_wrap_FXVec4d___eq__), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "normalize", VALUEFUNC(_wrap_FXVec4d_normalize), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "lo", VALUEFUNC(_wrap_FXVec4d_lo), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "hi", VALUEFUNC(_wrap_FXVec4d_hi), -1);
+  rb_define_singleton_method(SwigClassFXVec4d.klass, "plane", VALUEFUNC(_wrap_FXVec4d_plane), -1);
+  rb_define_method(SwigClassFXVec4d.klass, "clamp", VALUEFUNC(_wrap_FXVec4d_clamp), -1);
+  SwigClassFXVec4d.mark = 0;
+  SwigClassFXVec4d.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXVec4d.trackObjects = 0;
+  
+  SwigClassFXQuatf.klass = rb_define_class_under(mFox, "FXQuatf", ((swig_class *) SWIGTYPE_p_FXVec4f->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXQuatf, (void *) &SwigClassFXQuatf);
+  rb_define_alloc_func(SwigClassFXQuatf.klass, _wrap_FXQuatf_allocate);
+  rb_define_method(SwigClassFXQuatf.klass, "initialize", VALUEFUNC(_wrap_new_FXQuatf), -1);
+  rb_define_method(SwigClassFXQuatf.klass, "adjust!", VALUEFUNC(_wrap_FXQuatf_adjustN___), -1);
+  rb_define_method(SwigClassFXQuatf.klass, "setAxisAngle", VALUEFUNC(_wrap_FXQuatf_setAxisAngle), -1);
+  rb_define_method(SwigClassFXQuatf.klass, "getAxisAngle", VALUEFUNC(_wrap_FXQuatf_getAxisAngle), -1);
+  rb_define_method(SwigClassFXQuatf.klass, "setRollPitchYaw", VALUEFUNC(_wrap_FXQuatf_setRollPitchYaw), -1);
+  rb_define_method(SwigClassFXQuatf.klass, "setAxes", VALUEFUNC(_wrap_FXQuatf_setAxes), -1);
+  rb_define_method(SwigClassFXQuatf.klass, "getXAxis", VALUEFUNC(_wrap_FXQuatf_getXAxis), -1);
+  rb_define_method(SwigClassFXQuatf.klass, "getYAxis", VALUEFUNC(_wrap_FXQuatf_getYAxis), -1);
+  rb_define_method(SwigClassFXQuatf.klass, "getZAxis", VALUEFUNC(_wrap_FXQuatf_getZAxis), -1);
+  rb_define_method(SwigClassFXQuatf.klass, "exp", VALUEFUNC(_wrap_FXQuatf_exp), -1);
+  rb_define_method(SwigClassFXQuatf.klass, "log", VALUEFUNC(_wrap_FXQuatf_log), -1);
+  rb_define_method(SwigClassFXQuatf.klass, "invert", VALUEFUNC(_wrap_FXQuatf_invert), -1);
+  rb_define_method(SwigClassFXQuatf.klass, "unitinvert", VALUEFUNC(_wrap_FXQuatf_unitinvert), -1);
+  rb_define_method(SwigClassFXQuatf.klass, "conj", VALUEFUNC(_wrap_FXQuatf_conj), -1);
+  rb_define_method(SwigClassFXQuatf.klass, "arc!", VALUEFUNC(_wrap_FXQuatf_arcN___), -1);
+  rb_define_method(SwigClassFXQuatf.klass, "lerp!", VALUEFUNC(_wrap_FXQuatf_lerpN___), -1);
+  rb_define_method(SwigClassFXQuatf.klass, "getRollPitchYaw", VALUEFUNC(_wrap_FXQuatf_getRollPitchYaw), -1);
+  rb_define_method(SwigClassFXQuatf.klass, "getAxes", VALUEFUNC(_wrap_FXQuatf_getAxes), -1);
+  rb_define_method(SwigClassFXQuatf.klass, "*", VALUEFUNC(_wrap_FXQuatf___mul__), -1);
+  SwigClassFXQuatf.mark = 0;
+  SwigClassFXQuatf.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXQuatf.trackObjects = 0;
+  
+  SwigClassFXQuatd.klass = rb_define_class_under(mFox, "FXQuatd", ((swig_class *) SWIGTYPE_p_FXVec4d->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXQuatd, (void *) &SwigClassFXQuatd);
+  rb_define_alloc_func(SwigClassFXQuatd.klass, _wrap_FXQuatd_allocate);
+  rb_define_method(SwigClassFXQuatd.klass, "initialize", VALUEFUNC(_wrap_new_FXQuatd), -1);
+  rb_define_method(SwigClassFXQuatd.klass, "adjust!", VALUEFUNC(_wrap_FXQuatd_adjustN___), -1);
+  rb_define_method(SwigClassFXQuatd.klass, "setAxisAngle", VALUEFUNC(_wrap_FXQuatd_setAxisAngle), -1);
+  rb_define_method(SwigClassFXQuatd.klass, "getAxisAngle", VALUEFUNC(_wrap_FXQuatd_getAxisAngle), -1);
+  rb_define_method(SwigClassFXQuatd.klass, "setRollPitchYaw", VALUEFUNC(_wrap_FXQuatd_setRollPitchYaw), -1);
+  rb_define_method(SwigClassFXQuatd.klass, "exp", VALUEFUNC(_wrap_FXQuatd_exp), -1);
+  rb_define_method(SwigClassFXQuatd.klass, "log", VALUEFUNC(_wrap_FXQuatd_log), -1);
+  rb_define_method(SwigClassFXQuatd.klass, "invert", VALUEFUNC(_wrap_FXQuatd_invert), -1);
+  rb_define_method(SwigClassFXQuatd.klass, "unitinvert", VALUEFUNC(_wrap_FXQuatd_unitinvert), -1);
+  rb_define_method(SwigClassFXQuatd.klass, "conj", VALUEFUNC(_wrap_FXQuatd_conj), -1);
+  rb_define_method(SwigClassFXQuatd.klass, "arc!", VALUEFUNC(_wrap_FXQuatd_arcN___), -1);
+  rb_define_method(SwigClassFXQuatd.klass, "lerp!", VALUEFUNC(_wrap_FXQuatd_lerpN___), -1);
+  rb_define_method(SwigClassFXQuatd.klass, "getRollPitchYaw", VALUEFUNC(_wrap_FXQuatd_getRollPitchYaw), -1);
+  rb_define_method(SwigClassFXQuatd.klass, "*", VALUEFUNC(_wrap_FXQuatd___mul__), -1);
+  rb_define_method(SwigClassFXQuatd.klass, "setAxes", VALUEFUNC(_wrap_FXQuatd_setAxes), -1);
+  rb_define_method(SwigClassFXQuatd.klass, "getAxes", VALUEFUNC(_wrap_FXQuatd_getAxes), -1);
+  rb_define_method(SwigClassFXQuatd.klass, "getXAxis", VALUEFUNC(_wrap_FXQuatd_getXAxis), -1);
+  rb_define_method(SwigClassFXQuatd.klass, "getYAxis", VALUEFUNC(_wrap_FXQuatd_getYAxis), -1);
+  rb_define_method(SwigClassFXQuatd.klass, "getZAxis", VALUEFUNC(_wrap_FXQuatd_getZAxis), -1);
+  SwigClassFXQuatd.mark = 0;
+  SwigClassFXQuatd.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXQuatd.trackObjects = 0;
+  
+  SwigClassFXMat3f.klass = rb_define_class_under(mFox, "FXMat3f", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMat3f, (void *) &SwigClassFXMat3f);
+  rb_define_alloc_func(SwigClassFXMat3f.klass, _wrap_FXMat3f_allocate);
+  rb_define_method(SwigClassFXMat3f.klass, "initialize", VALUEFUNC(_wrap_new_FXMat3f), -1);
+  rb_define_method(SwigClassFXMat3f.klass, "[]", VALUEFUNC(_wrap_FXMat3f___getitem__), -1);
+  rb_define_method(SwigClassFXMat3f.klass, "[]=", VALUEFUNC(_wrap_FXMat3f___setitem__), -1);
+  rb_define_method(SwigClassFXMat3f.klass, "+", VALUEFUNC(_wrap_FXMat3f___add__), -1);
+  rb_define_method(SwigClassFXMat3f.klass, "-", VALUEFUNC(_wrap_FXMat3f___sub__), -1);
+  rb_define_method(SwigClassFXMat3f.klass, "-@", VALUEFUNC(_wrap_FXMat3f___neg__), -1);
+  rb_define_method(SwigClassFXMat3f.klass, "/", VALUEFUNC(_wrap_FXMat3f___div__), -1);
+  rb_define_method(SwigClassFXMat3f.klass, "*", VALUEFUNC(_wrap_FXMat3f___mul__), -1);
+  rb_define_method(SwigClassFXMat3f.klass, "eye", VALUEFUNC(_wrap_FXMat3f_eye), -1);
+  rb_define_method(SwigClassFXMat3f.klass, "rot", VALUEFUNC(_wrap_FXMat3f_rot), -1);
+  rb_define_method(SwigClassFXMat3f.klass, "trans", VALUEFUNC(_wrap_FXMat3f_trans), -1);
+  rb_define_method(SwigClassFXMat3f.klass, "scale", VALUEFUNC(_wrap_FXMat3f_scale), -1);
+  rb_define_method(SwigClassFXMat3f.klass, "det", VALUEFUNC(_wrap_FXMat3f_det), -1);
+  rb_define_method(SwigClassFXMat3f.klass, "transpose", VALUEFUNC(_wrap_FXMat3f_transpose), -1);
+  rb_define_method(SwigClassFXMat3f.klass, "invert", VALUEFUNC(_wrap_FXMat3f_invert), -1);
+  SwigClassFXMat3f.mark = 0;
+  SwigClassFXMat3f.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXMat3f.trackObjects = 0;
+  
+  SwigClassFXMat3d.klass = rb_define_class_under(mFox, "FXMat3d", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMat3d, (void *) &SwigClassFXMat3d);
+  rb_define_alloc_func(SwigClassFXMat3d.klass, _wrap_FXMat3d_allocate);
+  rb_define_method(SwigClassFXMat3d.klass, "initialize", VALUEFUNC(_wrap_new_FXMat3d), -1);
+  rb_define_method(SwigClassFXMat3d.klass, "[]", VALUEFUNC(_wrap_FXMat3d___getitem__), -1);
+  rb_define_method(SwigClassFXMat3d.klass, "[]=", VALUEFUNC(_wrap_FXMat3d___setitem__), -1);
+  rb_define_method(SwigClassFXMat3d.klass, "+", VALUEFUNC(_wrap_FXMat3d___add__), -1);
+  rb_define_method(SwigClassFXMat3d.klass, "-", VALUEFUNC(_wrap_FXMat3d___sub__), -1);
+  rb_define_method(SwigClassFXMat3d.klass, "-@", VALUEFUNC(_wrap_FXMat3d___neg__), -1);
+  rb_define_method(SwigClassFXMat3d.klass, "/", VALUEFUNC(_wrap_FXMat3d___div__), -1);
+  rb_define_method(SwigClassFXMat3d.klass, "*", VALUEFUNC(_wrap_FXMat3d___mul__), -1);
+  rb_define_method(SwigClassFXMat3d.klass, "eye", VALUEFUNC(_wrap_FXMat3d_eye), -1);
+  rb_define_method(SwigClassFXMat3d.klass, "rot", VALUEFUNC(_wrap_FXMat3d_rot), -1);
+  rb_define_method(SwigClassFXMat3d.klass, "trans", VALUEFUNC(_wrap_FXMat3d_trans), -1);
+  rb_define_method(SwigClassFXMat3d.klass, "scale", VALUEFUNC(_wrap_FXMat3d_scale), -1);
+  rb_define_method(SwigClassFXMat3d.klass, "det", VALUEFUNC(_wrap_FXMat3d_det), -1);
+  rb_define_method(SwigClassFXMat3d.klass, "transpose", VALUEFUNC(_wrap_FXMat3d_transpose), -1);
+  rb_define_method(SwigClassFXMat3d.klass, "invert", VALUEFUNC(_wrap_FXMat3d_invert), -1);
+  SwigClassFXMat3d.mark = 0;
+  SwigClassFXMat3d.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXMat3d.trackObjects = 0;
+  
+  SwigClassFXMat4f.klass = rb_define_class_under(mFox, "FXMat4f", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMat4f, (void *) &SwigClassFXMat4f);
+  rb_define_alloc_func(SwigClassFXMat4f.klass, _wrap_FXMat4f_allocate);
+  rb_define_method(SwigClassFXMat4f.klass, "initialize", VALUEFUNC(_wrap_new_FXMat4f), -1);
+  rb_define_method(SwigClassFXMat4f.klass, "det", VALUEFUNC(_wrap_FXMat4f_det), -1);
+  rb_define_method(SwigClassFXMat4f.klass, "transpose", VALUEFUNC(_wrap_FXMat4f_transpose), -1);
+  rb_define_method(SwigClassFXMat4f.klass, "invert", VALUEFUNC(_wrap_FXMat4f_invert), -1);
+  rb_define_method(SwigClassFXMat4f.klass, "[]", VALUEFUNC(_wrap_FXMat4f___getitem__), -1);
+  rb_define_method(SwigClassFXMat4f.klass, "[]=", VALUEFUNC(_wrap_FXMat4f___setitem__), -1);
+  rb_define_method(SwigClassFXMat4f.klass, "+", VALUEFUNC(_wrap_FXMat4f___add__), -1);
+  rb_define_method(SwigClassFXMat4f.klass, "-", VALUEFUNC(_wrap_FXMat4f___sub__), -1);
+  rb_define_method(SwigClassFXMat4f.klass, "*", VALUEFUNC(_wrap_FXMat4f___mul__), -1);
+  rb_define_method(SwigClassFXMat4f.klass, "/", VALUEFUNC(_wrap_FXMat4f___div__), -1);
+  rb_define_method(SwigClassFXMat4f.klass, "-@", VALUEFUNC(_wrap_FXMat4f___neg__), -1);
+  rb_define_method(SwigClassFXMat4f.klass, "to_s", VALUEFUNC(_wrap_FXMat4f_to_s), -1);
+  rb_define_method(SwigClassFXMat4f.klass, "eye", VALUEFUNC(_wrap_FXMat4f_eye), -1);
+  rb_define_method(SwigClassFXMat4f.klass, "ortho", VALUEFUNC(_wrap_FXMat4f_ortho), -1);
+  rb_define_method(SwigClassFXMat4f.klass, "frustum", VALUEFUNC(_wrap_FXMat4f_frustum), -1);
+  rb_define_method(SwigClassFXMat4f.klass, "left", VALUEFUNC(_wrap_FXMat4f_left), -1);
+  rb_define_method(SwigClassFXMat4f.klass, "rot", VALUEFUNC(_wrap_FXMat4f_rot), -1);
+  rb_define_method(SwigClassFXMat4f.klass, "xrot", VALUEFUNC(_wrap_FXMat4f_xrot), -1);
+  rb_define_method(SwigClassFXMat4f.klass, "yrot", VALUEFUNC(_wrap_FXMat4f_yrot), -1);
+  rb_define_method(SwigClassFXMat4f.klass, "zrot", VALUEFUNC(_wrap_FXMat4f_zrot), -1);
+  rb_define_method(SwigClassFXMat4f.klass, "look", VALUEFUNC(_wrap_FXMat4f_look), -1);
+  rb_define_method(SwigClassFXMat4f.klass, "trans", VALUEFUNC(_wrap_FXMat4f_trans), -1);
+  rb_define_method(SwigClassFXMat4f.klass, "scale", VALUEFUNC(_wrap_FXMat4f_scale), -1);
+  SwigClassFXMat4f.mark = 0;
+  SwigClassFXMat4f.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXMat4f.trackObjects = 0;
+  
+  SwigClassFXMat4d.klass = rb_define_class_under(mFox, "FXMat4d", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMat4d, (void *) &SwigClassFXMat4d);
+  rb_define_alloc_func(SwigClassFXMat4d.klass, _wrap_FXMat4d_allocate);
+  rb_define_method(SwigClassFXMat4d.klass, "initialize", VALUEFUNC(_wrap_new_FXMat4d), -1);
+  rb_define_method(SwigClassFXMat4d.klass, "[]", VALUEFUNC(_wrap_FXMat4d___getitem__), -1);
+  rb_define_method(SwigClassFXMat4d.klass, "[]=", VALUEFUNC(_wrap_FXMat4d___setitem__), -1);
+  rb_define_method(SwigClassFXMat4d.klass, "+", VALUEFUNC(_wrap_FXMat4d___add__), -1);
+  rb_define_method(SwigClassFXMat4d.klass, "-", VALUEFUNC(_wrap_FXMat4d___sub__), -1);
+  rb_define_method(SwigClassFXMat4d.klass, "-@", VALUEFUNC(_wrap_FXMat4d___neg__), -1);
+  rb_define_method(SwigClassFXMat4d.klass, "/", VALUEFUNC(_wrap_FXMat4d___div__), -1);
+  rb_define_method(SwigClassFXMat4d.klass, "*", VALUEFUNC(_wrap_FXMat4d___mul__), -1);
+  rb_define_method(SwigClassFXMat4d.klass, "eye", VALUEFUNC(_wrap_FXMat4d_eye), -1);
+  rb_define_method(SwigClassFXMat4d.klass, "ortho", VALUEFUNC(_wrap_FXMat4d_ortho), -1);
+  rb_define_method(SwigClassFXMat4d.klass, "frustum", VALUEFUNC(_wrap_FXMat4d_frustum), -1);
+  rb_define_method(SwigClassFXMat4d.klass, "left", VALUEFUNC(_wrap_FXMat4d_left), -1);
+  rb_define_method(SwigClassFXMat4d.klass, "rot", VALUEFUNC(_wrap_FXMat4d_rot), -1);
+  rb_define_method(SwigClassFXMat4d.klass, "xrot", VALUEFUNC(_wrap_FXMat4d_xrot), -1);
+  rb_define_method(SwigClassFXMat4d.klass, "yrot", VALUEFUNC(_wrap_FXMat4d_yrot), -1);
+  rb_define_method(SwigClassFXMat4d.klass, "zrot", VALUEFUNC(_wrap_FXMat4d_zrot), -1);
+  rb_define_method(SwigClassFXMat4d.klass, "look", VALUEFUNC(_wrap_FXMat4d_look), -1);
+  rb_define_method(SwigClassFXMat4d.klass, "trans", VALUEFUNC(_wrap_FXMat4d_trans), -1);
+  rb_define_method(SwigClassFXMat4d.klass, "scale", VALUEFUNC(_wrap_FXMat4d_scale), -1);
+  rb_define_method(SwigClassFXMat4d.klass, "det", VALUEFUNC(_wrap_FXMat4d_det), -1);
+  rb_define_method(SwigClassFXMat4d.klass, "transpose", VALUEFUNC(_wrap_FXMat4d_transpose), -1);
+  rb_define_method(SwigClassFXMat4d.klass, "invert", VALUEFUNC(_wrap_FXMat4d_invert), -1);
+  SwigClassFXMat4d.mark = 0;
+  SwigClassFXMat4d.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXMat4d.trackObjects = 0;
+  
+  SwigClassFXRangef.klass = rb_define_class_under(mFox, "FXRangef", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXRangef, (void *) &SwigClassFXRangef);
+  rb_define_alloc_func(SwigClassFXRangef.klass, _wrap_FXRangef_allocate);
+  rb_define_method(SwigClassFXRangef.klass, "initialize", VALUEFUNC(_wrap_new_FXRangef), -1);
+  rb_define_method(SwigClassFXRangef.klass, "[]", VALUEFUNC(_wrap_FXRangef___getitem__), -1);
+  rb_define_method(SwigClassFXRangef.klass, "[]=", VALUEFUNC(_wrap_FXRangef___setitem__), -1);
+  rb_define_method(SwigClassFXRangef.klass, "upper", VALUEFUNC(_wrap_FXRangef_upper), -1);
+  rb_define_method(SwigClassFXRangef.klass, "lower", VALUEFUNC(_wrap_FXRangef_lower), -1);
+  rb_define_method(SwigClassFXRangef.klass, "width", VALUEFUNC(_wrap_FXRangef_width), -1);
+  rb_define_method(SwigClassFXRangef.klass, "height", VALUEFUNC(_wrap_FXRangef_height), -1);
+  rb_define_method(SwigClassFXRangef.klass, "depth", VALUEFUNC(_wrap_FXRangef_depth), -1);
+  rb_define_method(SwigClassFXRangef.klass, "longest", VALUEFUNC(_wrap_FXRangef_longest), -1);
+  rb_define_method(SwigClassFXRangef.klass, "shortest", VALUEFUNC(_wrap_FXRangef_shortest), -1);
+  rb_define_method(SwigClassFXRangef.klass, "diameter", VALUEFUNC(_wrap_FXRangef_diameter), -1);
+  rb_define_method(SwigClassFXRangef.klass, "radius", VALUEFUNC(_wrap_FXRangef_radius), -1);
+  rb_define_method(SwigClassFXRangef.klass, "diagonal", VALUEFUNC(_wrap_FXRangef_diagonal), -1);
+  rb_define_method(SwigClassFXRangef.klass, "center", VALUEFUNC(_wrap_FXRangef_center), -1);
+  rb_define_method(SwigClassFXRangef.klass, "empty?", VALUEFUNC(_wrap_FXRangef_emptyq___), -1);
+  rb_define_method(SwigClassFXRangef.klass, "contains?", VALUEFUNC(_wrap_FXRangef_containsq___), -1);
+  rb_define_method(SwigClassFXRangef.klass, "include!", VALUEFUNC(_wrap_FXRangef_includeN___), -1);
+  rb_define_method(SwigClassFXRangef.klass, "intersect", VALUEFUNC(_wrap_FXRangef_intersect), -1);
+  rb_define_method(SwigClassFXRangef.klass, "overlaps?", VALUEFUNC(_wrap_FXRangef_overlapsq___), -1);
+  rb_define_method(SwigClassFXRangef.klass, "corner", VALUEFUNC(_wrap_FXRangef_corner), -1);
+  rb_define_method(SwigClassFXRangef.klass, "union", VALUEFUNC(_wrap_FXRangef_union), -1);
+  rb_define_method(SwigClassFXRangef.klass, "intersection", VALUEFUNC(_wrap_FXRangef_intersection), -1);
+  SwigClassFXRangef.mark = 0;
+  SwigClassFXRangef.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXRangef.trackObjects = 0;
+  
+  SwigClassFXRanged.klass = rb_define_class_under(mFox, "FXRanged", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXRanged, (void *) &SwigClassFXRanged);
+  rb_define_alloc_func(SwigClassFXRanged.klass, _wrap_FXRanged_allocate);
+  rb_define_method(SwigClassFXRanged.klass, "initialize", VALUEFUNC(_wrap_new_FXRanged), -1);
+  rb_define_method(SwigClassFXRanged.klass, "lower=", VALUEFUNC(_wrap_FXRanged_lower_set), -1);
+  rb_define_method(SwigClassFXRanged.klass, "lower", VALUEFUNC(_wrap_FXRanged_lower_get), -1);
+  rb_define_method(SwigClassFXRanged.klass, "upper=", VALUEFUNC(_wrap_FXRanged_upper_set), -1);
+  rb_define_method(SwigClassFXRanged.klass, "upper", VALUEFUNC(_wrap_FXRanged_upper_get), -1);
+  rb_define_method(SwigClassFXRanged.klass, "[]", VALUEFUNC(_wrap_FXRanged___getitem__), -1);
+  rb_define_method(SwigClassFXRanged.klass, "[]=", VALUEFUNC(_wrap_FXRanged___setitem__), -1);
+  rb_define_method(SwigClassFXRanged.klass, "width", VALUEFUNC(_wrap_FXRanged_width), -1);
+  rb_define_method(SwigClassFXRanged.klass, "height", VALUEFUNC(_wrap_FXRanged_height), -1);
+  rb_define_method(SwigClassFXRanged.klass, "depth", VALUEFUNC(_wrap_FXRanged_depth), -1);
+  rb_define_method(SwigClassFXRanged.klass, "longest", VALUEFUNC(_wrap_FXRanged_longest), -1);
+  rb_define_method(SwigClassFXRanged.klass, "shortest", VALUEFUNC(_wrap_FXRanged_shortest), -1);
+  rb_define_method(SwigClassFXRanged.klass, "diameter", VALUEFUNC(_wrap_FXRanged_diameter), -1);
+  rb_define_method(SwigClassFXRanged.klass, "radius", VALUEFUNC(_wrap_FXRanged_radius), -1);
+  rb_define_method(SwigClassFXRanged.klass, "diagonal", VALUEFUNC(_wrap_FXRanged_diagonal), -1);
+  rb_define_method(SwigClassFXRanged.klass, "center", VALUEFUNC(_wrap_FXRanged_center), -1);
+  rb_define_method(SwigClassFXRanged.klass, "empty?", VALUEFUNC(_wrap_FXRanged_emptyq___), -1);
+  rb_define_method(SwigClassFXRanged.klass, "contains", VALUEFUNC(_wrap_FXRanged_contains), -1);
+  rb_define_method(SwigClassFXRanged.klass, "contains?", VALUEFUNC(_wrap_FXRanged_containsq___), -1);
+  rb_define_method(SwigClassFXRanged.klass, "include", VALUEFUNC(_wrap_FXRanged_include), -1);
+  rb_define_method(SwigClassFXRanged.klass, "intersect", VALUEFUNC(_wrap_FXRanged_intersect), -1);
+  rb_define_method(SwigClassFXRanged.klass, "overlaps?", VALUEFUNC(_wrap_FXRanged_overlapsq___), -1);
+  rb_define_method(SwigClassFXRanged.klass, "corner", VALUEFUNC(_wrap_FXRanged_corner), -1);
+  rb_define_method(SwigClassFXRanged.klass, "union", VALUEFUNC(_wrap_FXRanged_union), -1);
+  rb_define_method(SwigClassFXRanged.klass, "intersection", VALUEFUNC(_wrap_FXRanged_intersection), -1);
+  SwigClassFXRanged.mark = 0;
+  SwigClassFXRanged.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXRanged.trackObjects = 0;
+  
+  SwigClassFXSpheref.klass = rb_define_class_under(mFox, "FXSpheref", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXSpheref, (void *) &SwigClassFXSpheref);
+  rb_define_alloc_func(SwigClassFXSpheref.klass, _wrap_FXSpheref_allocate);
+  rb_define_method(SwigClassFXSpheref.klass, "initialize", VALUEFUNC(_wrap_new_FXSpheref), -1);
+  rb_define_method(SwigClassFXSpheref.klass, "center=", VALUEFUNC(_wrap_FXSpheref_center_set), -1);
+  rb_define_method(SwigClassFXSpheref.klass, "center", VALUEFUNC(_wrap_FXSpheref_center_get), -1);
+  rb_define_method(SwigClassFXSpheref.klass, "radius=", VALUEFUNC(_wrap_FXSpheref_radius_set), -1);
+  rb_define_method(SwigClassFXSpheref.klass, "radius", VALUEFUNC(_wrap_FXSpheref_radius_get), -1);
+  rb_define_method(SwigClassFXSpheref.klass, "diameter", VALUEFUNC(_wrap_FXSpheref_diameter), -1);
+  rb_define_method(SwigClassFXSpheref.klass, "empty?", VALUEFUNC(_wrap_FXSpheref_emptyq___), -1);
+  rb_define_method(SwigClassFXSpheref.klass, "contains?", VALUEFUNC(_wrap_FXSpheref_containsq___), -1);
+  rb_define_method(SwigClassFXSpheref.klass, "include!", VALUEFUNC(_wrap_FXSpheref_includeN___), -1);
+  rb_define_method(SwigClassFXSpheref.klass, "includeInRadius!", VALUEFUNC(_wrap_FXSpheref_includeInRadiusN___), -1);
+  rb_define_method(SwigClassFXSpheref.klass, "intersect", VALUEFUNC(_wrap_FXSpheref_intersect), -1);
+  rb_define_method(SwigClassFXSpheref.klass, "intersects?", VALUEFUNC(_wrap_FXSpheref_intersectsq___), -1);
+  rb_define_method(SwigClassFXSpheref.klass, "overlaps?", VALUEFUNC(_wrap_FXSpheref_overlapsq___), -1);
+  SwigClassFXSpheref.mark = 0;
+  SwigClassFXSpheref.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXSpheref.trackObjects = 0;
+  
+  SwigClassFXSphered.klass = rb_define_class_under(mFox, "FXSphered", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXSphered, (void *) &SwigClassFXSphered);
+  rb_define_alloc_func(SwigClassFXSphered.klass, _wrap_FXSphered_allocate);
+  rb_define_method(SwigClassFXSphered.klass, "initialize", VALUEFUNC(_wrap_new_FXSphered), -1);
+  rb_define_method(SwigClassFXSphered.klass, "center=", VALUEFUNC(_wrap_FXSphered_center_set), -1);
+  rb_define_method(SwigClassFXSphered.klass, "center", VALUEFUNC(_wrap_FXSphered_center_get), -1);
+  rb_define_method(SwigClassFXSphered.klass, "radius=", VALUEFUNC(_wrap_FXSphered_radius_set), -1);
+  rb_define_method(SwigClassFXSphered.klass, "radius", VALUEFUNC(_wrap_FXSphered_radius_get), -1);
+  rb_define_method(SwigClassFXSphered.klass, "diameter", VALUEFUNC(_wrap_FXSphered_diameter), -1);
+  rb_define_method(SwigClassFXSphered.klass, "empty?", VALUEFUNC(_wrap_FXSphered_emptyq___), -1);
+  rb_define_method(SwigClassFXSphered.klass, "contains?", VALUEFUNC(_wrap_FXSphered_containsq___), -1);
+  rb_define_method(SwigClassFXSphered.klass, "include!", VALUEFUNC(_wrap_FXSphered_includeN___), -1);
+  rb_define_method(SwigClassFXSphered.klass, "includeInRadius!", VALUEFUNC(_wrap_FXSphered_includeInRadiusN___), -1);
+  rb_define_method(SwigClassFXSphered.klass, "intersect", VALUEFUNC(_wrap_FXSphered_intersect), -1);
+  rb_define_method(SwigClassFXSphered.klass, "intersects?", VALUEFUNC(_wrap_FXSphered_intersectsq___), -1);
+  rb_define_method(SwigClassFXSphered.klass, "overlaps?", VALUEFUNC(_wrap_FXSphered_overlapsq___), -1);
+  SwigClassFXSphered.mark = 0;
+  SwigClassFXSphered.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXSphered.trackObjects = 0;
+  
+  SwigClassFXGLVisual.klass = rb_define_class_under(mFox, "FXGLVisual", ((swig_class *) SWIGTYPE_p_FXVisual->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXGLVisual, (void *) &SwigClassFXGLVisual);
+  rb_define_alloc_func(SwigClassFXGLVisual.klass, _wrap_FXGLVisual_allocate);
+  rb_define_method(SwigClassFXGLVisual.klass, "initialize", VALUEFUNC(_wrap_new_FXGLVisual), -1);
+  rb_define_singleton_method(SwigClassFXGLVisual.klass, "supported", VALUEFUNC(_wrap_FXGLVisual_supported), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "getRedSize", VALUEFUNC(_wrap_FXGLVisual_getRedSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "getGreenSize", VALUEFUNC(_wrap_FXGLVisual_getGreenSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "getBlueSize", VALUEFUNC(_wrap_FXGLVisual_getBlueSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "getAlphaSize", VALUEFUNC(_wrap_FXGLVisual_getAlphaSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "getDepthSize", VALUEFUNC(_wrap_FXGLVisual_getDepthSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "getStencilSize", VALUEFUNC(_wrap_FXGLVisual_getStencilSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "getAccumRedSize", VALUEFUNC(_wrap_FXGLVisual_getAccumRedSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "getAccumGreenSize", VALUEFUNC(_wrap_FXGLVisual_getAccumGreenSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "getAccumBlueSize", VALUEFUNC(_wrap_FXGLVisual_getAccumBlueSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "getAccumAlphaSize", VALUEFUNC(_wrap_FXGLVisual_getAccumAlphaSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "setRedSize", VALUEFUNC(_wrap_FXGLVisual_setRedSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "setGreenSize", VALUEFUNC(_wrap_FXGLVisual_setGreenSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "setBlueSize", VALUEFUNC(_wrap_FXGLVisual_setBlueSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "setAlphaSize", VALUEFUNC(_wrap_FXGLVisual_setAlphaSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "setDepthSize", VALUEFUNC(_wrap_FXGLVisual_setDepthSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "setStencilSize", VALUEFUNC(_wrap_FXGLVisual_setStencilSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "setAccumRedSize", VALUEFUNC(_wrap_FXGLVisual_setAccumRedSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "setAccumGreenSize", VALUEFUNC(_wrap_FXGLVisual_setAccumGreenSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "setAccumBlueSize", VALUEFUNC(_wrap_FXGLVisual_setAccumBlueSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "setAccumAlphaSize", VALUEFUNC(_wrap_FXGLVisual_setAccumAlphaSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "getActualRedSize", VALUEFUNC(_wrap_FXGLVisual_getActualRedSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "getActualGreenSize", VALUEFUNC(_wrap_FXGLVisual_getActualGreenSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "getActualBlueSize", VALUEFUNC(_wrap_FXGLVisual_getActualBlueSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "getActualAlphaSize", VALUEFUNC(_wrap_FXGLVisual_getActualAlphaSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "getActualDepthSize", VALUEFUNC(_wrap_FXGLVisual_getActualDepthSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "getActualStencilSize", VALUEFUNC(_wrap_FXGLVisual_getActualStencilSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "getActualAccumRedSize", VALUEFUNC(_wrap_FXGLVisual_getActualAccumRedSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "getActualAccumGreenSize", VALUEFUNC(_wrap_FXGLVisual_getActualAccumGreenSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "getActualAccumBlueSize", VALUEFUNC(_wrap_FXGLVisual_getActualAccumBlueSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "getActualAccumAlphaSize", VALUEFUNC(_wrap_FXGLVisual_getActualAccumAlphaSize), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "isDoubleBuffer", VALUEFUNC(_wrap_FXGLVisual_isDoubleBuffer), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "isStereo", VALUEFUNC(_wrap_FXGLVisual_isStereo), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "isAccelerated", VALUEFUNC(_wrap_FXGLVisual_isAccelerated), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "isBufferSwapCopy", VALUEFUNC(_wrap_FXGLVisual_isBufferSwapCopy), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "save", VALUEFUNC(_wrap_FXGLVisual_save), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "load", VALUEFUNC(_wrap_FXGLVisual_load), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "create", VALUEFUNC(_wrap_FXGLVisual_create), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "detach", VALUEFUNC(_wrap_FXGLVisual_detach), -1);
+  rb_define_method(SwigClassFXGLVisual.klass, "destroy", VALUEFUNC(_wrap_FXGLVisual_destroy), -1);
+  SwigClassFXGLVisual.mark = (void (*)(void *)) FXRbGLVisual::markfunc;
+  SwigClassFXGLVisual.destroy = (void (*)(void *)) FXRbGLVisual::freefunc;
+  SwigClassFXGLVisual.trackObjects = 0;
+  rb_define_module_function(mFox, "glUseFXFont", VALUEFUNC(_wrap_glUseFXFont), -1);
+  
+  SwigClassFXGLContext.klass = rb_define_class_under(mFox, "FXGLContext", ((swig_class *) SWIGTYPE_p_FXId->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXGLContext, (void *) &SwigClassFXGLContext);
+  rb_define_alloc_func(SwigClassFXGLContext.klass, _wrap_FXGLContext_allocate);
+  rb_define_method(SwigClassFXGLContext.klass, "initialize", VALUEFUNC(_wrap_new_FXGLContext), -1);
+  rb_define_method(SwigClassFXGLContext.klass, "isShared", VALUEFUNC(_wrap_FXGLContext_isShared), -1);
+  rb_define_method(SwigClassFXGLContext.klass, "getVisual", VALUEFUNC(_wrap_FXGLContext_getVisual), -1);
+  rb_define_method(SwigClassFXGLContext.klass, "begin", VALUEFUNC(_wrap_FXGLContext_begin), -1);
+  rb_define_method(SwigClassFXGLContext.klass, "end", VALUEFUNC(_wrap_FXGLContext_end), -1);
+  rb_define_method(SwigClassFXGLContext.klass, "swapBuffers", VALUEFUNC(_wrap_FXGLContext_swapBuffers), -1);
+  rb_define_method(SwigClassFXGLContext.klass, "swapSubBuffers", VALUEFUNC(_wrap_FXGLContext_swapSubBuffers), -1);
+  rb_define_method(SwigClassFXGLContext.klass, "save", VALUEFUNC(_wrap_FXGLContext_save), -1);
+  rb_define_method(SwigClassFXGLContext.klass, "load", VALUEFUNC(_wrap_FXGLContext_load), -1);
+  rb_define_method(SwigClassFXGLContext.klass, "create", VALUEFUNC(_wrap_FXGLContext_create), -1);
+  rb_define_method(SwigClassFXGLContext.klass, "detach", VALUEFUNC(_wrap_FXGLContext_detach), -1);
+  rb_define_method(SwigClassFXGLContext.klass, "destroy", VALUEFUNC(_wrap_FXGLContext_destroy), -1);
+  SwigClassFXGLContext.mark = (void (*)(void *)) FXRbGLContext::markfunc;
+  SwigClassFXGLContext.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXGLContext.trackObjects = 0;
+  
+  SwigClassFXGLCanvas.klass = rb_define_class_under(mFox, "FXGLCanvas", ((swig_class *) SWIGTYPE_p_FXCanvas->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXGLCanvas, (void *) &SwigClassFXGLCanvas);
+  rb_define_alloc_func(SwigClassFXGLCanvas.klass, _wrap_FXGLCanvas_allocate);
+  rb_define_method(SwigClassFXGLCanvas.klass, "initialize", VALUEFUNC(_wrap_new_FXGLCanvas), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "shared?", VALUEFUNC(_wrap_FXGLCanvas_sharedq___), -1);
+  rb_define_singleton_method(SwigClassFXGLCanvas.klass, "getCurrentContext", VALUEFUNC(_wrap_FXGLCanvas_getCurrentContext), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "getContext", VALUEFUNC(_wrap_FXGLCanvas_getContext), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "save", VALUEFUNC(_wrap_FXGLCanvas_save), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "load", VALUEFUNC(_wrap_FXGLCanvas_load), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "create", VALUEFUNC(_wrap_FXGLCanvas_create), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "detach", VALUEFUNC(_wrap_FXGLCanvas_detach), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "destroy", VALUEFUNC(_wrap_FXGLCanvas_destroy), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "resize", VALUEFUNC(_wrap_FXGLCanvas_resize), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXGLCanvas_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXGLCanvas_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXGLCanvas_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXGLCanvas_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "canFocus", VALUEFUNC(_wrap_FXGLCanvas_canFocus), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "setFocus", VALUEFUNC(_wrap_FXGLCanvas_setFocus), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "killFocus", VALUEFUNC(_wrap_FXGLCanvas_killFocus), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "changeFocus", VALUEFUNC(_wrap_FXGLCanvas_changeFocus), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "setDefault", VALUEFUNC(_wrap_FXGLCanvas_setDefault), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "enable", VALUEFUNC(_wrap_FXGLCanvas_enable), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "disable", VALUEFUNC(_wrap_FXGLCanvas_disable), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "raiseWindow", VALUEFUNC(_wrap_FXGLCanvas_raiseWindow), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "lower", VALUEFUNC(_wrap_FXGLCanvas_lower), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "move", VALUEFUNC(_wrap_FXGLCanvas_move), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "position", VALUEFUNC(_wrap_FXGLCanvas_position), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "layout", VALUEFUNC(_wrap_FXGLCanvas_layout), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "recalc", VALUEFUNC(_wrap_FXGLCanvas_recalc), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "reparent", VALUEFUNC(_wrap_FXGLCanvas_reparent), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "show", VALUEFUNC(_wrap_FXGLCanvas_show), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "hide", VALUEFUNC(_wrap_FXGLCanvas_hide), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "isComposite", VALUEFUNC(_wrap_FXGLCanvas_isComposite), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "contains", VALUEFUNC(_wrap_FXGLCanvas_contains), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXGLCanvas_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "setBackColor", VALUEFUNC(_wrap_FXGLCanvas_setBackColor), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "tr", VALUEFUNC(_wrap_FXGLCanvas_tr), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "dropEnable", VALUEFUNC(_wrap_FXGLCanvas_dropEnable), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "dropDisable", VALUEFUNC(_wrap_FXGLCanvas_dropDisable), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "setShape", VALUEFUNC(_wrap_FXGLCanvas_setShape), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "clearShape", VALUEFUNC(_wrap_FXGLCanvas_clearShape), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "makeCurrent", VALUEFUNC(_wrap_FXGLCanvas_makeCurrent), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "makeNonCurrent", VALUEFUNC(_wrap_FXGLCanvas_makeNonCurrent), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "isCurrent", VALUEFUNC(_wrap_FXGLCanvas_isCurrent), -1);
+  rb_define_method(SwigClassFXGLCanvas.klass, "swapBuffers", VALUEFUNC(_wrap_FXGLCanvas_swapBuffers), -1);
+  SwigClassFXGLCanvas.mark = (void (*)(void *)) FXRbGLCanvas::markfunc;
+  SwigClassFXGLCanvas.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXGLCanvas.trackObjects = 0;
+  
+  SWIGTYPE_p_FXGLCanvas->dcast = (swig_dycast_func) FXGLCanvas_dynamic_cast;
+  
+  rb_define_const(mFox, "VIEWER_LIGHTING", SWIG_From_int(static_cast< int >(VIEWER_LIGHTING)));
+  rb_define_const(mFox, "VIEWER_FOG", SWIG_From_int(static_cast< int >(VIEWER_FOG)));
+  rb_define_const(mFox, "VIEWER_DITHER", SWIG_From_int(static_cast< int >(VIEWER_DITHER)));
+  
+  SwigClassFXViewport.klass = rb_define_class_under(mFox, "FXViewport", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXViewport, (void *) &SwigClassFXViewport);
+  rb_define_alloc_func(SwigClassFXViewport.klass, _wrap_FXViewport_allocate);
+  rb_define_method(SwigClassFXViewport.klass, "initialize", VALUEFUNC(_wrap_new_FXViewport), -1);
+  rb_define_method(SwigClassFXViewport.klass, "w=", VALUEFUNC(_wrap_FXViewport_w_set), -1);
+  rb_define_method(SwigClassFXViewport.klass, "w", VALUEFUNC(_wrap_FXViewport_w_get), -1);
+  rb_define_method(SwigClassFXViewport.klass, "h=", VALUEFUNC(_wrap_FXViewport_h_set), -1);
+  rb_define_method(SwigClassFXViewport.klass, "h", VALUEFUNC(_wrap_FXViewport_h_get), -1);
+  rb_define_method(SwigClassFXViewport.klass, "left=", VALUEFUNC(_wrap_FXViewport_left_set), -1);
+  rb_define_method(SwigClassFXViewport.klass, "left", VALUEFUNC(_wrap_FXViewport_left_get), -1);
+  rb_define_method(SwigClassFXViewport.klass, "right=", VALUEFUNC(_wrap_FXViewport_right_set), -1);
+  rb_define_method(SwigClassFXViewport.klass, "right", VALUEFUNC(_wrap_FXViewport_right_get), -1);
+  rb_define_method(SwigClassFXViewport.klass, "bottom=", VALUEFUNC(_wrap_FXViewport_bottom_set), -1);
+  rb_define_method(SwigClassFXViewport.klass, "bottom", VALUEFUNC(_wrap_FXViewport_bottom_get), -1);
+  rb_define_method(SwigClassFXViewport.klass, "top=", VALUEFUNC(_wrap_FXViewport_top_set), -1);
+  rb_define_method(SwigClassFXViewport.klass, "top", VALUEFUNC(_wrap_FXViewport_top_get), -1);
+  rb_define_method(SwigClassFXViewport.klass, "hither=", VALUEFUNC(_wrap_FXViewport_hither_set), -1);
+  rb_define_method(SwigClassFXViewport.klass, "hither", VALUEFUNC(_wrap_FXViewport_hither_get), -1);
+  rb_define_method(SwigClassFXViewport.klass, "yon=", VALUEFUNC(_wrap_FXViewport_yon_set), -1);
+  rb_define_method(SwigClassFXViewport.klass, "yon", VALUEFUNC(_wrap_FXViewport_yon_get), -1);
+  SwigClassFXViewport.mark = 0;
+  SwigClassFXViewport.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXViewport.trackObjects = 0;
+  
+  SwigClassFXLight.klass = rb_define_class_under(mFox, "FXLight", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXLight, (void *) &SwigClassFXLight);
+  rb_define_alloc_func(SwigClassFXLight.klass, _wrap_FXLight_allocate);
+  rb_define_method(SwigClassFXLight.klass, "initialize", VALUEFUNC(_wrap_new_FXLight), -1);
+  rb_define_method(SwigClassFXLight.klass, "ambient=", VALUEFUNC(_wrap_FXLight_ambient_set), -1);
+  rb_define_method(SwigClassFXLight.klass, "ambient", VALUEFUNC(_wrap_FXLight_ambient_get), -1);
+  rb_define_method(SwigClassFXLight.klass, "diffuse=", VALUEFUNC(_wrap_FXLight_diffuse_set), -1);
+  rb_define_method(SwigClassFXLight.klass, "diffuse", VALUEFUNC(_wrap_FXLight_diffuse_get), -1);
+  rb_define_method(SwigClassFXLight.klass, "specular=", VALUEFUNC(_wrap_FXLight_specular_set), -1);
+  rb_define_method(SwigClassFXLight.klass, "specular", VALUEFUNC(_wrap_FXLight_specular_get), -1);
+  rb_define_method(SwigClassFXLight.klass, "position=", VALUEFUNC(_wrap_FXLight_position_set), -1);
+  rb_define_method(SwigClassFXLight.klass, "position", VALUEFUNC(_wrap_FXLight_position_get), -1);
+  rb_define_method(SwigClassFXLight.klass, "direction=", VALUEFUNC(_wrap_FXLight_direction_set), -1);
+  rb_define_method(SwigClassFXLight.klass, "direction", VALUEFUNC(_wrap_FXLight_direction_get), -1);
+  rb_define_method(SwigClassFXLight.klass, "exponent=", VALUEFUNC(_wrap_FXLight_exponent_set), -1);
+  rb_define_method(SwigClassFXLight.klass, "exponent", VALUEFUNC(_wrap_FXLight_exponent_get), -1);
+  rb_define_method(SwigClassFXLight.klass, "cutoff=", VALUEFUNC(_wrap_FXLight_cutoff_set), -1);
+  rb_define_method(SwigClassFXLight.klass, "cutoff", VALUEFUNC(_wrap_FXLight_cutoff_get), -1);
+  rb_define_method(SwigClassFXLight.klass, "c_attn=", VALUEFUNC(_wrap_FXLight_c_attn_set), -1);
+  rb_define_method(SwigClassFXLight.klass, "c_attn", VALUEFUNC(_wrap_FXLight_c_attn_get), -1);
+  rb_define_method(SwigClassFXLight.klass, "l_attn=", VALUEFUNC(_wrap_FXLight_l_attn_set), -1);
+  rb_define_method(SwigClassFXLight.klass, "l_attn", VALUEFUNC(_wrap_FXLight_l_attn_get), -1);
+  rb_define_method(SwigClassFXLight.klass, "q_attn=", VALUEFUNC(_wrap_FXLight_q_attn_set), -1);
+  rb_define_method(SwigClassFXLight.klass, "q_attn", VALUEFUNC(_wrap_FXLight_q_attn_get), -1);
+  SwigClassFXLight.mark = 0;
+  SwigClassFXLight.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXLight.trackObjects = 0;
+  
+  SwigClassFXMaterial.klass = rb_define_class_under(mFox, "FXMaterial", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMaterial, (void *) &SwigClassFXMaterial);
+  rb_define_alloc_func(SwigClassFXMaterial.klass, _wrap_FXMaterial_allocate);
+  rb_define_method(SwigClassFXMaterial.klass, "initialize", VALUEFUNC(_wrap_new_FXMaterial), -1);
+  rb_define_method(SwigClassFXMaterial.klass, "ambient=", VALUEFUNC(_wrap_FXMaterial_ambient_set), -1);
+  rb_define_method(SwigClassFXMaterial.klass, "ambient", VALUEFUNC(_wrap_FXMaterial_ambient_get), -1);
+  rb_define_method(SwigClassFXMaterial.klass, "diffuse=", VALUEFUNC(_wrap_FXMaterial_diffuse_set), -1);
+  rb_define_method(SwigClassFXMaterial.klass, "diffuse", VALUEFUNC(_wrap_FXMaterial_diffuse_get), -1);
+  rb_define_method(SwigClassFXMaterial.klass, "specular=", VALUEFUNC(_wrap_FXMaterial_specular_set), -1);
+  rb_define_method(SwigClassFXMaterial.klass, "specular", VALUEFUNC(_wrap_FXMaterial_specular_get), -1);
+  rb_define_method(SwigClassFXMaterial.klass, "emission=", VALUEFUNC(_wrap_FXMaterial_emission_set), -1);
+  rb_define_method(SwigClassFXMaterial.klass, "emission", VALUEFUNC(_wrap_FXMaterial_emission_get), -1);
+  rb_define_method(SwigClassFXMaterial.klass, "shininess=", VALUEFUNC(_wrap_FXMaterial_shininess_set), -1);
+  rb_define_method(SwigClassFXMaterial.klass, "shininess", VALUEFUNC(_wrap_FXMaterial_shininess_get), -1);
+  SwigClassFXMaterial.mark = 0;
+  SwigClassFXMaterial.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXMaterial.trackObjects = 0;
+  
+  SwigClassFXGLViewer.klass = rb_define_class_under(mFox, "FXGLViewer", ((swig_class *) SWIGTYPE_p_FXGLCanvas->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXGLViewer, (void *) &SwigClassFXGLViewer);
+  rb_define_alloc_func(SwigClassFXGLViewer.klass, _wrap_FXGLViewer_allocate);
+  rb_define_method(SwigClassFXGLViewer.klass, "initialize", VALUEFUNC(_wrap_new_FXGLViewer), -1);
+  rb_define_singleton_method(SwigClassFXGLViewer.klass, "objectType", VALUEFUNC(_wrap_FXGLViewer_objectType_get), 0);
+  rb_define_singleton_method(SwigClassFXGLViewer.klass, "objectType=", VALUEFUNC(_wrap_FXGLViewer_objectType_set), 1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onPaint", VALUEFUNC(_wrap_FXGLViewer_onPaint), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onEnter", VALUEFUNC(_wrap_FXGLViewer_onEnter), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onLeave", VALUEFUNC(_wrap_FXGLViewer_onLeave), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onMotion", VALUEFUNC(_wrap_FXGLViewer_onMotion), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onMouseWheel", VALUEFUNC(_wrap_FXGLViewer_onMouseWheel), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onChanged", VALUEFUNC(_wrap_FXGLViewer_onChanged), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onPick", VALUEFUNC(_wrap_FXGLViewer_onPick), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onClicked", VALUEFUNC(_wrap_FXGLViewer_onClicked), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onDoubleClicked", VALUEFUNC(_wrap_FXGLViewer_onDoubleClicked), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onTripleClicked", VALUEFUNC(_wrap_FXGLViewer_onTripleClicked), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onLassoed", VALUEFUNC(_wrap_FXGLViewer_onLassoed), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onSelected", VALUEFUNC(_wrap_FXGLViewer_onSelected), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onDeselected", VALUEFUNC(_wrap_FXGLViewer_onDeselected), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onInserted", VALUEFUNC(_wrap_FXGLViewer_onInserted), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onDeleted", VALUEFUNC(_wrap_FXGLViewer_onDeleted), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXGLViewer_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXGLViewer_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onMiddleBtnPress", VALUEFUNC(_wrap_FXGLViewer_onMiddleBtnPress), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onMiddleBtnRelease", VALUEFUNC(_wrap_FXGLViewer_onMiddleBtnRelease), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onRightBtnPress", VALUEFUNC(_wrap_FXGLViewer_onRightBtnPress), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onRightBtnRelease", VALUEFUNC(_wrap_FXGLViewer_onRightBtnRelease), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUngrabbed", VALUEFUNC(_wrap_FXGLViewer_onUngrabbed), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onKeyPress", VALUEFUNC(_wrap_FXGLViewer_onKeyPress), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onKeyRelease", VALUEFUNC(_wrap_FXGLViewer_onKeyRelease), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onFocusIn", VALUEFUNC(_wrap_FXGLViewer_onFocusIn), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onFocusOut", VALUEFUNC(_wrap_FXGLViewer_onFocusOut), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onClipboardLost", VALUEFUNC(_wrap_FXGLViewer_onClipboardLost), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onClipboardGained", VALUEFUNC(_wrap_FXGLViewer_onClipboardGained), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onClipboardRequest", VALUEFUNC(_wrap_FXGLViewer_onClipboardRequest), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdPerspective", VALUEFUNC(_wrap_FXGLViewer_onCmdPerspective), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdPerspective", VALUEFUNC(_wrap_FXGLViewer_onUpdPerspective), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdParallel", VALUEFUNC(_wrap_FXGLViewer_onCmdParallel), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdParallel", VALUEFUNC(_wrap_FXGLViewer_onUpdParallel), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdFront", VALUEFUNC(_wrap_FXGLViewer_onCmdFront), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdFront", VALUEFUNC(_wrap_FXGLViewer_onUpdFront), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdBack", VALUEFUNC(_wrap_FXGLViewer_onCmdBack), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdBack", VALUEFUNC(_wrap_FXGLViewer_onUpdBack), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdLeft", VALUEFUNC(_wrap_FXGLViewer_onCmdLeft), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdLeft", VALUEFUNC(_wrap_FXGLViewer_onUpdLeft), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdRight", VALUEFUNC(_wrap_FXGLViewer_onCmdRight), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdRight", VALUEFUNC(_wrap_FXGLViewer_onUpdRight), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdTop", VALUEFUNC(_wrap_FXGLViewer_onCmdTop), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdTop", VALUEFUNC(_wrap_FXGLViewer_onUpdTop), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdBottom", VALUEFUNC(_wrap_FXGLViewer_onCmdBottom), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdBottom", VALUEFUNC(_wrap_FXGLViewer_onUpdBottom), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdResetView", VALUEFUNC(_wrap_FXGLViewer_onCmdResetView), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdFitView", VALUEFUNC(_wrap_FXGLViewer_onCmdFitView), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onDNDEnter", VALUEFUNC(_wrap_FXGLViewer_onDNDEnter), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onDNDLeave", VALUEFUNC(_wrap_FXGLViewer_onDNDLeave), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onDNDMotion", VALUEFUNC(_wrap_FXGLViewer_onDNDMotion), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onDNDDrop", VALUEFUNC(_wrap_FXGLViewer_onDNDDrop), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onTipTimer", VALUEFUNC(_wrap_FXGLViewer_onTipTimer), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdXYZDial", VALUEFUNC(_wrap_FXGLViewer_onCmdXYZDial), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdXYZDial", VALUEFUNC(_wrap_FXGLViewer_onUpdXYZDial), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdRollPitchYaw", VALUEFUNC(_wrap_FXGLViewer_onCmdRollPitchYaw), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdRollPitchYaw", VALUEFUNC(_wrap_FXGLViewer_onUpdRollPitchYaw), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdXYZScale", VALUEFUNC(_wrap_FXGLViewer_onCmdXYZScale), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdXYZScale", VALUEFUNC(_wrap_FXGLViewer_onUpdXYZScale), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdCurrent", VALUEFUNC(_wrap_FXGLViewer_onUpdCurrent), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdCutSel", VALUEFUNC(_wrap_FXGLViewer_onCmdCutSel), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdCopySel", VALUEFUNC(_wrap_FXGLViewer_onCmdCopySel), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdPasteSel", VALUEFUNC(_wrap_FXGLViewer_onCmdPasteSel), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdDeleteSel", VALUEFUNC(_wrap_FXGLViewer_onCmdDeleteSel), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdDeleteSel", VALUEFUNC(_wrap_FXGLViewer_onUpdDeleteSel), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdBackColor", VALUEFUNC(_wrap_FXGLViewer_onCmdBackColor), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdBackColor", VALUEFUNC(_wrap_FXGLViewer_onUpdBackColor), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdGradientBackColor", VALUEFUNC(_wrap_FXGLViewer_onCmdGradientBackColor), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdGradientBackColor", VALUEFUNC(_wrap_FXGLViewer_onUpdGradientBackColor), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdAmbientColor", VALUEFUNC(_wrap_FXGLViewer_onCmdAmbientColor), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdAmbientColor", VALUEFUNC(_wrap_FXGLViewer_onUpdAmbientColor), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdLighting", VALUEFUNC(_wrap_FXGLViewer_onCmdLighting), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdLighting", VALUEFUNC(_wrap_FXGLViewer_onUpdLighting), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdFog", VALUEFUNC(_wrap_FXGLViewer_onCmdFog), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdFog", VALUEFUNC(_wrap_FXGLViewer_onUpdFog), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdDither", VALUEFUNC(_wrap_FXGLViewer_onCmdDither), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdDither", VALUEFUNC(_wrap_FXGLViewer_onUpdDither), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdFov", VALUEFUNC(_wrap_FXGLViewer_onCmdFov), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdFov", VALUEFUNC(_wrap_FXGLViewer_onUpdFov), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdZoom", VALUEFUNC(_wrap_FXGLViewer_onCmdZoom), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdZoom", VALUEFUNC(_wrap_FXGLViewer_onUpdZoom), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdLightAmbient", VALUEFUNC(_wrap_FXGLViewer_onCmdLightAmbient), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdLightAmbient", VALUEFUNC(_wrap_FXGLViewer_onUpdLightAmbient), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdLightDiffuse", VALUEFUNC(_wrap_FXGLViewer_onCmdLightDiffuse), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdLightDiffuse", VALUEFUNC(_wrap_FXGLViewer_onUpdLightDiffuse), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdLightSpecular", VALUEFUNC(_wrap_FXGLViewer_onCmdLightSpecular), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdLightSpecular", VALUEFUNC(_wrap_FXGLViewer_onUpdLightSpecular), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdTurbo", VALUEFUNC(_wrap_FXGLViewer_onCmdTurbo), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onUpdTurbo", VALUEFUNC(_wrap_FXGLViewer_onUpdTurbo), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdPrintImage", VALUEFUNC(_wrap_FXGLViewer_onCmdPrintImage), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdPrintVector", VALUEFUNC(_wrap_FXGLViewer_onCmdPrintVector), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdLassoZoom", VALUEFUNC(_wrap_FXGLViewer_onCmdLassoZoom), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onCmdLassoSelect", VALUEFUNC(_wrap_FXGLViewer_onCmdLassoSelect), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onQueryHelp", VALUEFUNC(_wrap_FXGLViewer_onQueryHelp), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "onQueryTip", VALUEFUNC(_wrap_FXGLViewer_onQueryTip), -1);
+  rb_define_const(SwigClassFXGLViewer.klass, "PARALLEL", SWIG_From_int(static_cast< int >(FXGLViewer::PARALLEL)));
+  rb_define_const(SwigClassFXGLViewer.klass, "PERSPECTIVE", SWIG_From_int(static_cast< int >(FXGLViewer::PERSPECTIVE)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_PERSPECTIVE", SWIG_From_int(static_cast< int >(FXGLViewer::ID_PERSPECTIVE)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_PARALLEL", SWIG_From_int(static_cast< int >(FXGLViewer::ID_PARALLEL)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_FRONT", SWIG_From_int(static_cast< int >(FXGLViewer::ID_FRONT)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_BACK", SWIG_From_int(static_cast< int >(FXGLViewer::ID_BACK)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_LEFT", SWIG_From_int(static_cast< int >(FXGLViewer::ID_LEFT)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_RIGHT", SWIG_From_int(static_cast< int >(FXGLViewer::ID_RIGHT)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_TOP", SWIG_From_int(static_cast< int >(FXGLViewer::ID_TOP)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_BOTTOM", SWIG_From_int(static_cast< int >(FXGLViewer::ID_BOTTOM)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_RESETVIEW", SWIG_From_int(static_cast< int >(FXGLViewer::ID_RESETVIEW)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_FITVIEW", SWIG_From_int(static_cast< int >(FXGLViewer::ID_FITVIEW)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_TOP_COLOR", SWIG_From_int(static_cast< int >(FXGLViewer::ID_TOP_COLOR)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_BOTTOM_COLOR", SWIG_From_int(static_cast< int >(FXGLViewer::ID_BOTTOM_COLOR)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_BACK_COLOR", SWIG_From_int(static_cast< int >(FXGLViewer::ID_BACK_COLOR)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_AMBIENT_COLOR", SWIG_From_int(static_cast< int >(FXGLViewer::ID_AMBIENT_COLOR)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_LIGHT_AMBIENT", SWIG_From_int(static_cast< int >(FXGLViewer::ID_LIGHT_AMBIENT)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_LIGHT_DIFFUSE", SWIG_From_int(static_cast< int >(FXGLViewer::ID_LIGHT_DIFFUSE)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_LIGHT_SPECULAR", SWIG_From_int(static_cast< int >(FXGLViewer::ID_LIGHT_SPECULAR)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_LIGHTING", SWIG_From_int(static_cast< int >(FXGLViewer::ID_LIGHTING)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_TURBO", SWIG_From_int(static_cast< int >(FXGLViewer::ID_TURBO)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_FOG", SWIG_From_int(static_cast< int >(FXGLViewer::ID_FOG)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_DITHER", SWIG_From_int(static_cast< int >(FXGLViewer::ID_DITHER)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_SCALE_X", SWIG_From_int(static_cast< int >(FXGLViewer::ID_SCALE_X)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_SCALE_Y", SWIG_From_int(static_cast< int >(FXGLViewer::ID_SCALE_Y)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_SCALE_Z", SWIG_From_int(static_cast< int >(FXGLViewer::ID_SCALE_Z)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_DIAL_X", SWIG_From_int(static_cast< int >(FXGLViewer::ID_DIAL_X)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_DIAL_Y", SWIG_From_int(static_cast< int >(FXGLViewer::ID_DIAL_Y)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_DIAL_Z", SWIG_From_int(static_cast< int >(FXGLViewer::ID_DIAL_Z)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_ROLL", SWIG_From_int(static_cast< int >(FXGLViewer::ID_ROLL)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_PITCH", SWIG_From_int(static_cast< int >(FXGLViewer::ID_PITCH)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_YAW", SWIG_From_int(static_cast< int >(FXGLViewer::ID_YAW)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_FOV", SWIG_From_int(static_cast< int >(FXGLViewer::ID_FOV)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_ZOOM", SWIG_From_int(static_cast< int >(FXGLViewer::ID_ZOOM)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_CUT_SEL", SWIG_From_int(static_cast< int >(FXGLViewer::ID_CUT_SEL)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_COPY_SEL", SWIG_From_int(static_cast< int >(FXGLViewer::ID_COPY_SEL)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_PASTE_SEL", SWIG_From_int(static_cast< int >(FXGLViewer::ID_PASTE_SEL)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_DELETE_SEL", SWIG_From_int(static_cast< int >(FXGLViewer::ID_DELETE_SEL)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_PRINT_IMAGE", SWIG_From_int(static_cast< int >(FXGLViewer::ID_PRINT_IMAGE)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_PRINT_VECTOR", SWIG_From_int(static_cast< int >(FXGLViewer::ID_PRINT_VECTOR)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_LASSO_ZOOM", SWIG_From_int(static_cast< int >(FXGLViewer::ID_LASSO_ZOOM)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_LASSO_SELECT", SWIG_From_int(static_cast< int >(FXGLViewer::ID_LASSO_SELECT)));
+  rb_define_const(SwigClassFXGLViewer.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXGLViewer::ID_LAST)));
+  rb_define_singleton_method(SwigClassFXGLViewer.klass, "objectTypeName", VALUEFUNC(_wrap_FXGLViewer_objectTypeName), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "worldPix", VALUEFUNC(_wrap_FXGLViewer_worldPix), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "modelPix", VALUEFUNC(_wrap_FXGLViewer_modelPix), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "lasso", VALUEFUNC(_wrap_FXGLViewer_lasso), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "fitToBounds", VALUEFUNC(_wrap_FXGLViewer_fitToBounds), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getViewport", VALUEFUNC(_wrap_FXGLViewer_getViewport), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "eyeToScreen", VALUEFUNC(_wrap_FXGLViewer_eyeToScreen), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "screenToEye", VALUEFUNC(_wrap_FXGLViewer_screenToEye), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "screenToTarget", VALUEFUNC(_wrap_FXGLViewer_screenToTarget), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "worldToEye", VALUEFUNC(_wrap_FXGLViewer_worldToEye), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "worldToEyeZ", VALUEFUNC(_wrap_FXGLViewer_worldToEyeZ), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "eyeToWorld", VALUEFUNC(_wrap_FXGLViewer_eyeToWorld), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "worldVector", VALUEFUNC(_wrap_FXGLViewer_worldVector), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "setMaterial", VALUEFUNC(_wrap_FXGLViewer_setMaterial), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getMaterial", VALUEFUNC(_wrap_FXGLViewer_getMaterial), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "setFieldOfView", VALUEFUNC(_wrap_FXGLViewer_setFieldOfView), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getFieldOfView", VALUEFUNC(_wrap_FXGLViewer_getFieldOfView), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "setZoom", VALUEFUNC(_wrap_FXGLViewer_setZoom), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getZoom", VALUEFUNC(_wrap_FXGLViewer_getZoom), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "setDistance", VALUEFUNC(_wrap_FXGLViewer_setDistance), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getDistance", VALUEFUNC(_wrap_FXGLViewer_getDistance), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "setScale", VALUEFUNC(_wrap_FXGLViewer_setScale), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getScale", VALUEFUNC(_wrap_FXGLViewer_getScale), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "setOrientation", VALUEFUNC(_wrap_FXGLViewer_setOrientation), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getOrientation", VALUEFUNC(_wrap_FXGLViewer_getOrientation), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "setCenter", VALUEFUNC(_wrap_FXGLViewer_setCenter), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getCenter", VALUEFUNC(_wrap_FXGLViewer_getCenter), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "translate", VALUEFUNC(_wrap_FXGLViewer_translate), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getBoreVector", VALUEFUNC(_wrap_FXGLViewer_getBoreVector), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getEyeVector", VALUEFUNC(_wrap_FXGLViewer_getEyeVector), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getEyePosition", VALUEFUNC(_wrap_FXGLViewer_getEyePosition), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "setHelpText", VALUEFUNC(_wrap_FXGLViewer_setHelpText), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getHelpText", VALUEFUNC(_wrap_FXGLViewer_getHelpText), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "setTipText", VALUEFUNC(_wrap_FXGLViewer_setTipText), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getTipText", VALUEFUNC(_wrap_FXGLViewer_getTipText), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getTransform", VALUEFUNC(_wrap_FXGLViewer_getTransform), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getInvTransform", VALUEFUNC(_wrap_FXGLViewer_getInvTransform), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "setScene", VALUEFUNC(_wrap_FXGLViewer_setScene), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getScene", VALUEFUNC(_wrap_FXGLViewer_getScene), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "setSelection", VALUEFUNC(_wrap_FXGLViewer_setSelection), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getSelection", VALUEFUNC(_wrap_FXGLViewer_getSelection), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "setProjection", VALUEFUNC(_wrap_FXGLViewer_setProjection), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getProjection", VALUEFUNC(_wrap_FXGLViewer_getProjection), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "setBackgroundColor", VALUEFUNC(_wrap_FXGLViewer_setBackgroundColor), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getBackgroundColor", VALUEFUNC(_wrap_FXGLViewer_getBackgroundColor), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "setAmbientColor", VALUEFUNC(_wrap_FXGLViewer_setAmbientColor), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getAmbientColor", VALUEFUNC(_wrap_FXGLViewer_getAmbientColor), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "readPixels", VALUEFUNC(_wrap_FXGLViewer_readPixels), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "readFeedback", VALUEFUNC(_wrap_FXGLViewer_readFeedback), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "setZSortFunc", VALUEFUNC(_wrap_FXGLViewer_setZSortFunc), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getZSortFunc", VALUEFUNC(_wrap_FXGLViewer_getZSortFunc), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "setMaxHits", VALUEFUNC(_wrap_FXGLViewer_setMaxHits), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getMaxHits", VALUEFUNC(_wrap_FXGLViewer_getMaxHits), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "doesTurbo", VALUEFUNC(_wrap_FXGLViewer_doesTurbo), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getTurboMode", VALUEFUNC(_wrap_FXGLViewer_getTurboMode), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "setTurboMode", VALUEFUNC(_wrap_FXGLViewer_setTurboMode), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getLight", VALUEFUNC(_wrap_FXGLViewer_getLight), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "setLight", VALUEFUNC(_wrap_FXGLViewer_setLight), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "save", VALUEFUNC(_wrap_FXGLViewer_save), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "load", VALUEFUNC(_wrap_FXGLViewer_load), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "create", VALUEFUNC(_wrap_FXGLViewer_create), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "detach", VALUEFUNC(_wrap_FXGLViewer_detach), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "destroy", VALUEFUNC(_wrap_FXGLViewer_destroy), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "resize", VALUEFUNC(_wrap_FXGLViewer_resize), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXGLViewer_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXGLViewer_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXGLViewer_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXGLViewer_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "canFocus", VALUEFUNC(_wrap_FXGLViewer_canFocus), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "setFocus", VALUEFUNC(_wrap_FXGLViewer_setFocus), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "killFocus", VALUEFUNC(_wrap_FXGLViewer_killFocus), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "changeFocus", VALUEFUNC(_wrap_FXGLViewer_changeFocus), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "setDefault", VALUEFUNC(_wrap_FXGLViewer_setDefault), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "enable", VALUEFUNC(_wrap_FXGLViewer_enable), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "disable", VALUEFUNC(_wrap_FXGLViewer_disable), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "raiseWindow", VALUEFUNC(_wrap_FXGLViewer_raiseWindow), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "lower", VALUEFUNC(_wrap_FXGLViewer_lower), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "move", VALUEFUNC(_wrap_FXGLViewer_move), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "position", VALUEFUNC(_wrap_FXGLViewer_position), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "layout", VALUEFUNC(_wrap_FXGLViewer_layout), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "recalc", VALUEFUNC(_wrap_FXGLViewer_recalc), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "reparent", VALUEFUNC(_wrap_FXGLViewer_reparent), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "show", VALUEFUNC(_wrap_FXGLViewer_show), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "hide", VALUEFUNC(_wrap_FXGLViewer_hide), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "isComposite", VALUEFUNC(_wrap_FXGLViewer_isComposite), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "contains", VALUEFUNC(_wrap_FXGLViewer_contains), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXGLViewer_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "setBackColor", VALUEFUNC(_wrap_FXGLViewer_setBackColor), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "tr", VALUEFUNC(_wrap_FXGLViewer_tr), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "dropEnable", VALUEFUNC(_wrap_FXGLViewer_dropEnable), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "dropDisable", VALUEFUNC(_wrap_FXGLViewer_dropDisable), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "setShape", VALUEFUNC(_wrap_FXGLViewer_setShape), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "clearShape", VALUEFUNC(_wrap_FXGLViewer_clearShape), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "makeCurrent", VALUEFUNC(_wrap_FXGLViewer_makeCurrent), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "makeNonCurrent", VALUEFUNC(_wrap_FXGLViewer_makeNonCurrent), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "isCurrent", VALUEFUNC(_wrap_FXGLViewer_isCurrent), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "swapBuffers", VALUEFUNC(_wrap_FXGLViewer_swapBuffers), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "select", VALUEFUNC(_wrap_FXGLViewer_select), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "pick", VALUEFUNC(_wrap_FXGLViewer_pick), -1);
+  rb_define_method(SwigClassFXGLViewer.klass, "setBounds", VALUEFUNC(_wrap_FXGLViewer_setBounds), -1);
+  SwigClassFXGLViewer.mark = (void (*)(void *)) FXRbGLViewer::markfunc;
+  SwigClassFXGLViewer.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXGLViewer.trackObjects = 0;
+  
+  SwigClassFXGLObject.klass = rb_define_class_under(mFox, "FXGLObject", ((swig_class *) SWIGTYPE_p_FXObject->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXGLObject, (void *) &SwigClassFXGLObject);
+  rb_define_alloc_func(SwigClassFXGLObject.klass, _wrap_FXGLObject_allocate);
+  rb_define_method(SwigClassFXGLObject.klass, "initialize", VALUEFUNC(_wrap_new_FXGLObject), -1);
+  rb_define_const(SwigClassFXGLObject.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXGLObject::ID_LAST)));
+  rb_define_method(SwigClassFXGLObject.klass, "identify", VALUEFUNC(_wrap_FXGLObject_identify), -1);
+  rb_define_method(SwigClassFXGLObject.klass, "save", VALUEFUNC(_wrap_FXGLObject_save), -1);
+  rb_define_method(SwigClassFXGLObject.klass, "load", VALUEFUNC(_wrap_FXGLObject_load), -1);
+  rb_define_method(SwigClassFXGLObject.klass, "copy", VALUEFUNC(_wrap_FXGLObject_copy), -1);
+  rb_define_method(SwigClassFXGLObject.klass, "bounds", VALUEFUNC(_wrap_FXGLObject_bounds), -1);
+  rb_define_method(SwigClassFXGLObject.klass, "draw", VALUEFUNC(_wrap_FXGLObject_draw), -1);
+  rb_define_method(SwigClassFXGLObject.klass, "hit", VALUEFUNC(_wrap_FXGLObject_hit), -1);
+  rb_define_method(SwigClassFXGLObject.klass, "canDrag", VALUEFUNC(_wrap_FXGLObject_canDrag), -1);
+  rb_define_method(SwigClassFXGLObject.klass, "canDelete", VALUEFUNC(_wrap_FXGLObject_canDelete), -1);
+  rb_define_method(SwigClassFXGLObject.klass, "drag", VALUEFUNC(_wrap_FXGLObject_drag), -1);
+  SwigClassFXGLObject.mark = (void (*)(void *)) FXRbGLObject::markfunc;
+  SwigClassFXGLObject.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXGLObject.trackObjects = 0;
+  
+  SWIGTYPE_p_FXGLObject->dcast = (swig_dycast_func) FXGLObject_dynamic_cast;
+  
+  rb_define_const(mFox, "SURFACE_SINGLESIDED", SWIG_From_int(static_cast< int >(SURFACE_SINGLESIDED)));
+  rb_define_const(mFox, "SURFACE_DUALSIDED", SWIG_From_int(static_cast< int >(SURFACE_DUALSIDED)));
+  rb_define_const(mFox, "SHADING_NONE", SWIG_From_int(static_cast< int >(SHADING_NONE)));
+  rb_define_const(mFox, "SHADING_SMOOTH", SWIG_From_int(static_cast< int >(SHADING_SMOOTH)));
+  rb_define_const(mFox, "SHADING_FLAT", SWIG_From_int(static_cast< int >(SHADING_FLAT)));
+  rb_define_const(mFox, "FACECULLING_OFF", SWIG_From_int(static_cast< int >(FACECULLING_OFF)));
+  rb_define_const(mFox, "FACECULLING_ON", SWIG_From_int(static_cast< int >(FACECULLING_ON)));
+  rb_define_const(mFox, "STYLE_SURFACE", SWIG_From_int(static_cast< int >(STYLE_SURFACE)));
+  rb_define_const(mFox, "STYLE_WIREFRAME", SWIG_From_int(static_cast< int >(STYLE_WIREFRAME)));
+  rb_define_const(mFox, "STYLE_POINTS", SWIG_From_int(static_cast< int >(STYLE_POINTS)));
+  rb_define_const(mFox, "STYLE_BOUNDBOX", SWIG_From_int(static_cast< int >(STYLE_BOUNDBOX)));
+  
+  SwigClassFXGLShape.klass = rb_define_class_under(mFox, "FXGLShape", ((swig_class *) SWIGTYPE_p_FXGLObject->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXGLShape, (void *) &SwigClassFXGLShape);
+  rb_define_alloc_func(SwigClassFXGLShape.klass, _wrap_FXGLShape_allocate);
+  rb_define_method(SwigClassFXGLShape.klass, "initialize", VALUEFUNC(_wrap_new_FXGLShape), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "onDNDDrop", VALUEFUNC(_wrap_FXGLShape_onDNDDrop), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "onDNDMotion", VALUEFUNC(_wrap_FXGLShape_onDNDMotion), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "onQueryTip", VALUEFUNC(_wrap_FXGLShape_onQueryTip), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "onCmdShadeOff", VALUEFUNC(_wrap_FXGLShape_onCmdShadeOff), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "onUpdShadeOff", VALUEFUNC(_wrap_FXGLShape_onUpdShadeOff), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "onCmdShadeOn", VALUEFUNC(_wrap_FXGLShape_onCmdShadeOn), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "onUpdShadeOn", VALUEFUNC(_wrap_FXGLShape_onUpdShadeOn), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "onCmdShadeSmooth", VALUEFUNC(_wrap_FXGLShape_onCmdShadeSmooth), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "onUpdShadeSmooth", VALUEFUNC(_wrap_FXGLShape_onUpdShadeSmooth), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "onCmdFrontMaterial", VALUEFUNC(_wrap_FXGLShape_onCmdFrontMaterial), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "onUpdFrontMaterial", VALUEFUNC(_wrap_FXGLShape_onUpdFrontMaterial), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "onCmdBackMaterial", VALUEFUNC(_wrap_FXGLShape_onCmdBackMaterial), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "onUpdBackMaterial", VALUEFUNC(_wrap_FXGLShape_onUpdBackMaterial), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "onCmdDrawingStyle", VALUEFUNC(_wrap_FXGLShape_onCmdDrawingStyle), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "onUpdDrawingStyle", VALUEFUNC(_wrap_FXGLShape_onUpdDrawingStyle), -1);
+  rb_define_const(SwigClassFXGLShape.klass, "ID_SHADEOFF", SWIG_From_int(static_cast< int >(FXGLShape::ID_SHADEOFF)));
+  rb_define_const(SwigClassFXGLShape.klass, "ID_SHADEON", SWIG_From_int(static_cast< int >(FXGLShape::ID_SHADEON)));
+  rb_define_const(SwigClassFXGLShape.klass, "ID_SHADESMOOTH", SWIG_From_int(static_cast< int >(FXGLShape::ID_SHADESMOOTH)));
+  rb_define_const(SwigClassFXGLShape.klass, "ID_TOGGLE_SIDED", SWIG_From_int(static_cast< int >(FXGLShape::ID_TOGGLE_SIDED)));
+  rb_define_const(SwigClassFXGLShape.klass, "ID_TOGGLE_CULLING", SWIG_From_int(static_cast< int >(FXGLShape::ID_TOGGLE_CULLING)));
+  rb_define_const(SwigClassFXGLShape.klass, "ID_STYLE_POINTS", SWIG_From_int(static_cast< int >(FXGLShape::ID_STYLE_POINTS)));
+  rb_define_const(SwigClassFXGLShape.klass, "ID_STYLE_WIREFRAME", SWIG_From_int(static_cast< int >(FXGLShape::ID_STYLE_WIREFRAME)));
+  rb_define_const(SwigClassFXGLShape.klass, "ID_STYLE_SURFACE", SWIG_From_int(static_cast< int >(FXGLShape::ID_STYLE_SURFACE)));
+  rb_define_const(SwigClassFXGLShape.klass, "ID_STYLE_BOUNDINGBOX", SWIG_From_int(static_cast< int >(FXGLShape::ID_STYLE_BOUNDINGBOX)));
+  rb_define_const(SwigClassFXGLShape.klass, "ID_FRONT_MATERIAL", SWIG_From_int(static_cast< int >(FXGLShape::ID_FRONT_MATERIAL)));
+  rb_define_const(SwigClassFXGLShape.klass, "ID_BACK_MATERIAL", SWIG_From_int(static_cast< int >(FXGLShape::ID_BACK_MATERIAL)));
+  rb_define_const(SwigClassFXGLShape.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXGLShape::ID_LAST)));
+  rb_define_method(SwigClassFXGLShape.klass, "identify", VALUEFUNC(_wrap_FXGLShape_identify), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "setTipText", VALUEFUNC(_wrap_FXGLShape_setTipText), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "getTipText", VALUEFUNC(_wrap_FXGLShape_getTipText), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "setMaterial", VALUEFUNC(_wrap_FXGLShape_setMaterial), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "getPosition", VALUEFUNC(_wrap_FXGLShape_getPosition), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "setPosition", VALUEFUNC(_wrap_FXGLShape_setPosition), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "getMaterial", VALUEFUNC(_wrap_FXGLShape_getMaterial), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "setRange", VALUEFUNC(_wrap_FXGLShape_setRange), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "save", VALUEFUNC(_wrap_FXGLShape_save), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "load", VALUEFUNC(_wrap_FXGLShape_load), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "copy", VALUEFUNC(_wrap_FXGLShape_copy), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "bounds", VALUEFUNC(_wrap_FXGLShape_bounds), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "draw", VALUEFUNC(_wrap_FXGLShape_draw), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "hit", VALUEFUNC(_wrap_FXGLShape_hit), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "canDrag", VALUEFUNC(_wrap_FXGLShape_canDrag), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "canDelete", VALUEFUNC(_wrap_FXGLShape_canDelete), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "drag", VALUEFUNC(_wrap_FXGLShape_drag), -1);
+  rb_define_method(SwigClassFXGLShape.klass, "drawshape", VALUEFUNC(_wrap_FXGLShape_drawshape), -1);
+  SwigClassFXGLShape.mark = (void (*)(void *)) FXRbGLShape::markfunc;
+  SwigClassFXGLShape.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXGLShape.trackObjects = 0;
+  
+  SwigClassFXExtentf.klass = rb_define_class_under(mFox, "FXExtentf", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXExtentf, (void *) &SwigClassFXExtentf);
+  rb_define_alloc_func(SwigClassFXExtentf.klass, _wrap_FXExtentf_allocate);
+  rb_define_method(SwigClassFXExtentf.klass, "initialize", VALUEFUNC(_wrap_new_FXExtentf), -1);
+  rb_define_method(SwigClassFXExtentf.klass, "lower=", VALUEFUNC(_wrap_FXExtentf_lower_set), -1);
+  rb_define_method(SwigClassFXExtentf.klass, "lower", VALUEFUNC(_wrap_FXExtentf_lower_get), -1);
+  rb_define_method(SwigClassFXExtentf.klass, "upper=", VALUEFUNC(_wrap_FXExtentf_upper_set), -1);
+  rb_define_method(SwigClassFXExtentf.klass, "upper", VALUEFUNC(_wrap_FXExtentf_upper_get), -1);
+  rb_define_method(SwigClassFXExtentf.klass, "[]=", VALUEFUNC(_wrap_FXExtentf___setitem__), -1);
+  rb_define_method(SwigClassFXExtentf.klass, "[]", VALUEFUNC(_wrap_FXExtentf___getitem__), -1);
+  rb_define_method(SwigClassFXExtentf.klass, "width", VALUEFUNC(_wrap_FXExtentf_width), -1);
+  rb_define_method(SwigClassFXExtentf.klass, "height", VALUEFUNC(_wrap_FXExtentf_height), -1);
+  rb_define_method(SwigClassFXExtentf.klass, "longest", VALUEFUNC(_wrap_FXExtentf_longest), -1);
+  rb_define_method(SwigClassFXExtentf.klass, "shortest", VALUEFUNC(_wrap_FXExtentf_shortest), -1);
+  rb_define_method(SwigClassFXExtentf.klass, "diameter", VALUEFUNC(_wrap_FXExtentf_diameter), -1);
+  rb_define_method(SwigClassFXExtentf.klass, "radius", VALUEFUNC(_wrap_FXExtentf_radius), -1);
+  rb_define_method(SwigClassFXExtentf.klass, "diagonal", VALUEFUNC(_wrap_FXExtentf_diagonal), -1);
+  rb_define_method(SwigClassFXExtentf.klass, "center", VALUEFUNC(_wrap_FXExtentf_center), -1);
+  rb_define_method(SwigClassFXExtentf.klass, "empty?", VALUEFUNC(_wrap_FXExtentf_emptyq___), -1);
+  rb_define_method(SwigClassFXExtentf.klass, "contains", VALUEFUNC(_wrap_FXExtentf_contains), -1);
+  rb_define_method(SwigClassFXExtentf.klass, "contains?", VALUEFUNC(_wrap_FXExtentf_containsq___), -1);
+  rb_define_method(SwigClassFXExtentf.klass, "include", VALUEFUNC(_wrap_FXExtentf_include), -1);
+  rb_define_method(SwigClassFXExtentf.klass, "include!", VALUEFUNC(_wrap_FXExtentf_includeN___), -1);
+  rb_define_method(SwigClassFXExtentf.klass, "corner", VALUEFUNC(_wrap_FXExtentf_corner), -1);
+  rb_define_method(SwigClassFXExtentf.klass, "overlap?", VALUEFUNC(_wrap_FXExtentf_overlapq___), -1);
+  rb_define_method(SwigClassFXExtentf.klass, "unite_with", VALUEFUNC(_wrap_FXExtentf_unite_with), -1);
+  rb_define_method(SwigClassFXExtentf.klass, "intersect_with", VALUEFUNC(_wrap_FXExtentf_intersect_with), -1);
+  SwigClassFXExtentf.mark = 0;
+  SwigClassFXExtentf.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXExtentf.trackObjects = 0;
+  
+  SwigClassFXExtentd.klass = rb_define_class_under(mFox, "FXExtentd", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXExtentd, (void *) &SwigClassFXExtentd);
+  rb_define_alloc_func(SwigClassFXExtentd.klass, _wrap_FXExtentd_allocate);
+  rb_define_method(SwigClassFXExtentd.klass, "initialize", VALUEFUNC(_wrap_new_FXExtentd), -1);
+  rb_define_method(SwigClassFXExtentd.klass, "lower=", VALUEFUNC(_wrap_FXExtentd_lower_set), -1);
+  rb_define_method(SwigClassFXExtentd.klass, "lower", VALUEFUNC(_wrap_FXExtentd_lower_get), -1);
+  rb_define_method(SwigClassFXExtentd.klass, "upper=", VALUEFUNC(_wrap_FXExtentd_upper_set), -1);
+  rb_define_method(SwigClassFXExtentd.klass, "upper", VALUEFUNC(_wrap_FXExtentd_upper_get), -1);
+  rb_define_method(SwigClassFXExtentd.klass, "[]=", VALUEFUNC(_wrap_FXExtentd___setitem__), -1);
+  rb_define_method(SwigClassFXExtentd.klass, "[]", VALUEFUNC(_wrap_FXExtentd___getitem__), -1);
+  rb_define_method(SwigClassFXExtentd.klass, "width", VALUEFUNC(_wrap_FXExtentd_width), -1);
+  rb_define_method(SwigClassFXExtentd.klass, "height", VALUEFUNC(_wrap_FXExtentd_height), -1);
+  rb_define_method(SwigClassFXExtentd.klass, "longest", VALUEFUNC(_wrap_FXExtentd_longest), -1);
+  rb_define_method(SwigClassFXExtentd.klass, "shortest", VALUEFUNC(_wrap_FXExtentd_shortest), -1);
+  rb_define_method(SwigClassFXExtentd.klass, "diameter", VALUEFUNC(_wrap_FXExtentd_diameter), -1);
+  rb_define_method(SwigClassFXExtentd.klass, "radius", VALUEFUNC(_wrap_FXExtentd_radius), -1);
+  rb_define_method(SwigClassFXExtentd.klass, "diagonal", VALUEFUNC(_wrap_FXExtentd_diagonal), -1);
+  rb_define_method(SwigClassFXExtentd.klass, "center", VALUEFUNC(_wrap_FXExtentd_center), -1);
+  rb_define_method(SwigClassFXExtentd.klass, "empty?", VALUEFUNC(_wrap_FXExtentd_emptyq___), -1);
+  rb_define_method(SwigClassFXExtentd.klass, "contains", VALUEFUNC(_wrap_FXExtentd_contains), -1);
+  rb_define_method(SwigClassFXExtentd.klass, "contains?", VALUEFUNC(_wrap_FXExtentd_containsq___), -1);
+  rb_define_method(SwigClassFXExtentd.klass, "include", VALUEFUNC(_wrap_FXExtentd_include), -1);
+  rb_define_method(SwigClassFXExtentd.klass, "include!", VALUEFUNC(_wrap_FXExtentd_includeN___), -1);
+  rb_define_method(SwigClassFXExtentd.klass, "corner", VALUEFUNC(_wrap_FXExtentd_corner), -1);
+  rb_define_method(SwigClassFXExtentd.klass, "overlap?", VALUEFUNC(_wrap_FXExtentd_overlapq___), -1);
+  rb_define_method(SwigClassFXExtentd.klass, "unite_with", VALUEFUNC(_wrap_FXExtentd_unite_with), -1);
+  rb_define_method(SwigClassFXExtentd.klass, "intersect_with", VALUEFUNC(_wrap_FXExtentd_intersect_with), -1);
+  SwigClassFXExtentd.mark = 0;
+  SwigClassFXExtentd.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassFXExtentd.trackObjects = 0;
+}
+
diff --git a/ext/fox16_c/gvl_wrappers.cpp b/ext/fox16_c/gvl_wrappers.cpp
new file mode 100644
index 00000000..66229c71
--- /dev/null
+++ b/ext/fox16_c/gvl_wrappers.cpp
@@ -0,0 +1,14 @@
+/*
+ * gvl_wrappers.c - Wrapper functions for locking/unlocking the Ruby GVL
+ *
+ */
+
+#include "FXRbCommon.h"
+
+#ifdef HAVE___THREAD
+  __thread int g_fxrb_thread_has_gvl = 1;
+#endif
+
+FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_WRAPPER_STRUCT );
+FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_SKELETON );
+FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_STUB );
diff --git a/ext/fox16_c/iconlist_wrap.cpp b/ext/fox16_c/iconlist_wrap.cpp
new file mode 100644
index 00000000..70b5b705
--- /dev/null
+++ b/ext/fox16_c/iconlist_wrap.cpp
@@ -0,0 +1,15802 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 3.0.12
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+
+#ifndef SWIGRUBY
+#define SWIGRUBY
+#endif
+
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
+};
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic C API SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "4"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/*  Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN           0x1
+
+
+/*
+   Flags/methods for returning states.
+
+   The SWIG conversion methods, as ConvertPtr, return an integer
+   that tells if the conversion was successful or not. And if not,
+   an error code can be returned (see swigerrors.swg for the codes).
+
+   Use the following macros/flags to set or process the returning
+   states.
+
+   In old versions of SWIG, code such as the following was usually written:
+
+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+       // success code
+     } else {
+       //fail code
+     }
+
+   Now you can be more explicit:
+
+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+    } else {
+      // fail code
+    }
+
+   which is the same really, but now you can also do
+
+    Type *ptr;
+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+      if (SWIG_IsNewObj(res) {
+        ...
+	delete *ptr;
+      } else {
+        ...
+      }
+    } else {
+      // fail code
+    }
+
+   I.e., now SWIG_ConvertPtr can return new objects and you can
+   identify the case and take care of the deallocation. Of course that
+   also requires SWIG_ConvertPtr to return new result values, such as
+
+      int SWIG_ConvertPtr(obj, ptr,...) {
+        if (<obj is ok>) {
+          if (<need new object>) {
+            *ptr = <ptr to new allocated object>;
+            return SWIG_NEWOBJ;
+          } else {
+            *ptr = <ptr to old object>;
+            return SWIG_OLDOBJ;
+          }
+        } else {
+          return SWIG_BADOBJ;
+        }
+      }
+
+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+   SWIG errors code.
+
+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+   allows to return the 'cast rank', for example, if you have this
+
+       int food(double)
+       int fooi(int);
+
+   and you call
+
+      food(1)   // cast rank '1'  (1 -> 1.0)
+      fooi(1)   // cast rank '0'
+
+   just use the SWIG_AddCast()/SWIG_CheckState()
+*/
+
+#define SWIG_OK                    (0)
+#define SWIG_ERROR                 (-1)
+#define SWIG_IsOK(r)               (r >= 0)
+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT         (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ                (SWIG_ERROR)
+#define SWIG_OLDOBJ                (SWIG_OK)
+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+#  ifndef SWIG_TypeRank
+#    define SWIG_TypeRank             unsigned long
+#  endif
+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
+#    define SWIG_MAXCASTRANK          (2)
+#  endif
+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+#  define SWIG_AddCast(r) (r)
+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *, int *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store information on one type */
+typedef struct swig_type_info {
+  const char             *name;			/* mangled name of this type */
+  const char             *str;			/* human readable name of this type */
+  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
+  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
+  void                   *clientdata;		/* language specific type data */
+  int                    owndata;		/* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
+  swig_converter_func     converter;		/* function to cast the void pointers */
+  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
+  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
+  size_t                 size;		        /* Number of types in this module */
+  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
+  swig_type_info         **type_initial;	/* Array of initially generated type structures */
+  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
+  void                    *clientdata;		/* Language specific module data */
+} swig_module_info;
+
+/*
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+  }
+  return (int)((l1 - f1) - (l2 - f2));
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCmp(const char *nb, const char *tb) {
+  int equiv = 1;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (equiv != 0 && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
+}
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
+}
+
+/*
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+  swig_type_info *lastty = ty;
+  if (!ty || !ty->dcast) return ty;
+  while (ty && (ty->dcast)) {
+    ty = (*ty->dcast)(ptr);
+    if (ty) lastty = ty;
+  }
+  return lastty;
+}
+
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+  return ty->name;
+}
+
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (!type) return NULL;
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
+  }
+  else
+    return type->name;
+}
+
+/*
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+  swig_cast_info *cast = ti->cast;
+  /* if (ti->clientdata == clientdata) return; */
+  ti->clientdata = clientdata;
+
+  while (cast) {
+    if (!cast->converter) {
+      swig_type_info *tc = cast->type;
+      if (!tc->clientdata) {
+	SWIG_TypeClientData(tc, clientdata);
+      }
+    }
+    cast = cast->next;
+  }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientData(ti, clientdata);
+  ti->owndata = 1;
+}
+
+/*
+  Search for a swig_type_info structure only by mangled name
+  Search is a O(log #types)
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+                            swig_module_info *end,
+		            const char *name) {
+  swig_module_info *iter = start;
+  do {
+    if (iter->size) {
+      size_t l = 0;
+      size_t r = iter->size - 1;
+      do {
+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
+	size_t i = (l + r) >> 1;
+	const char *iname = iter->types[i]->name;
+	if (iname) {
+	  int compare = strcmp(name, iname);
+	  if (compare == 0) {
+	    return iter->types[i];
+	  } else if (compare < 0) {
+	    if (i) {
+	      r = i - 1;
+	    } else {
+	      break;
+	    }
+	  } else if (compare > 0) {
+	    l = i + 1;
+	  }
+	} else {
+	  break; /* should never happen */
+	}
+      } while (l <= r);
+    }
+    iter = iter->next;
+  } while (iter != end);
+  return 0;
+}
+
+/*
+  Search for a swig_type_info structure for either a mangled name or a human readable name.
+  It first searches the mangled names of the types, which is a O(log #types)
+  If a type is not found it then searches the human readable names, which is O(#types).
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+                     swig_module_info *end,
+		     const char *name) {
+  /* STEP 1: Search the name field using binary search */
+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+  if (ret) {
+    return ret;
+  } else {
+    /* STEP 2: If the type hasn't been found, do a complete search
+       of the str field (the human readable name) */
+    swig_module_info *iter = start;
+    do {
+      size_t i = 0;
+      for (; i < iter->size; ++i) {
+	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+	  return iter->types[i];
+      }
+      iter = iter->next;
+    } while (iter != end);
+  }
+
+  /* neither found a match */
+  return 0;
+}
+
+/*
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+
+/*
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = (unsigned char)((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = (unsigned char)((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (unsigned char)(d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (unsigned char)(d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/*
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/*  Errors in SWIG */
+#define  SWIG_UnknownError    	   -1
+#define  SWIG_IOError        	   -2
+#define  SWIG_RuntimeError   	   -3
+#define  SWIG_IndexError     	   -4
+#define  SWIG_TypeError      	   -5
+#define  SWIG_DivisionByZero 	   -6
+#define  SWIG_OverflowError  	   -7
+#define  SWIG_SyntaxError    	   -8
+#define  SWIG_ValueError     	   -9
+#define  SWIG_SystemError    	   -10
+#define  SWIG_AttributeError 	   -11
+#define  SWIG_MemoryError    	   -12
+#define  SWIG_NullReferenceError   -13
+
+
+
+      #include <ruby.h>
+
+      #if defined(RB_METHOD_DEFINITION_DECL)
+      # define RUBY_VALUE_METHOD_FUNC(func) (func)
+      # define RUBY_INT_METHOD_FUNC(func) (func)
+      # define RUBY_VOID_METHOD_FUNC(func) (func)
+      # define RUBY_VOIDP_METHOD_FUNC(func) (func)
+      #else
+      # define RUBY_VALUE_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
+      # define RUBY_INT_METHOD_FUNC(func) ((int (*)(ANYARGS))(func))
+      # define RUBY_VOID_METHOD_FUNC(func) ((void (*)(ANYARGS))(func))
+      # define RUBY_VOIDP_METHOD_FUNC(func) ((void *(*)(ANYARGS))(func))
+      #endif
+
+
+/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
+ * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
+ * issue for now by disabling this.
+ * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
+ */
+#ifdef rb_intern
+# undef rb_intern
+#endif
+
+/* Remove global macros defined in Ruby's win32.h */
+#ifdef write
+# undef write
+#endif
+#ifdef read
+# undef read
+#endif
+#ifdef bind
+# undef bind
+#endif
+#ifdef close
+# undef close
+#endif
+#ifdef connect
+# undef connect
+#endif
+
+
+/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
+#ifndef NUM2LL
+#define NUM2LL(x) NUM2LONG((x))
+#endif
+#ifndef LL2NUM
+#define LL2NUM(x) INT2NUM((long) (x))
+#endif
+#ifndef ULL2NUM
+#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
+#endif
+
+/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
+#ifndef NUM2ULL
+#ifdef HAVE_LONG_LONG
+#define NUM2ULL(x) rb_num2ull((x))
+#else
+#define NUM2ULL(x) NUM2ULONG(x)
+#endif
+#endif
+
+/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
+/* Define these for older versions so we can just write code the new way */
+#ifndef RSTRING_LEN
+# define RSTRING_LEN(x) RSTRING(x)->len
+#endif
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(x) RSTRING(x)->ptr
+#endif
+#ifndef RSTRING_END
+# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
+#endif
+#ifndef RARRAY_LEN
+# define RARRAY_LEN(x) RARRAY(x)->len
+#endif
+#ifndef RARRAY_PTR
+# define RARRAY_PTR(x) RARRAY(x)->ptr
+#endif
+#ifndef RFLOAT_VALUE
+# define RFLOAT_VALUE(x) RFLOAT(x)->value
+#endif
+#ifndef DOUBLE2NUM
+# define DOUBLE2NUM(x) rb_float_new(x)
+#endif
+#ifndef RHASH_TBL
+# define RHASH_TBL(x) (RHASH(x)->tbl)
+#endif
+#ifndef RHASH_ITER_LEV
+# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
+#endif
+#ifndef RHASH_IFNONE
+# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
+#endif
+#ifndef RHASH_SIZE
+# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
+#endif
+#ifndef RHASH_EMPTY_P
+# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
+#endif
+#ifndef RSTRUCT_LEN
+# define RSTRUCT_LEN(x) RSTRUCT(x)->len
+#endif
+#ifndef RSTRUCT_PTR
+# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
+#endif
+
+
+
+/*
+ * Need to be very careful about how these macros are defined, especially
+ * when compiling C++ code or C code with an ANSI C compiler.
+ *
+ * VALUEFUNC(f) is a macro used to typecast a C function that implements
+ * a Ruby method so that it can be passed as an argument to API functions
+ * like rb_define_method() and rb_define_singleton_method().
+ *
+ * VOIDFUNC(f) is a macro used to typecast a C function that implements
+ * either the "mark" or "free" stuff for a Ruby Data object, so that it
+ * can be passed as an argument to API functions like Data_Wrap_Struct()
+ * and Data_Make_Struct().
+ */
+ 
+#ifdef __cplusplus
+#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
+#    define PROTECTFUNC(f) ((VALUE (*)()) f)
+#    define VALUEFUNC(f) ((VALUE (*)()) f)
+#    define VOIDFUNC(f)  ((void (*)()) f)
+#  else
+#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
+#      define PROTECTFUNC(f) ((VALUE (*)()) f)
+#      define VALUEFUNC(f) ((VALUE (*)()) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    else /* These definitions should work for Ruby 1.7+ */
+#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
+#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    endif
+#  endif
+#else
+#  define VALUEFUNC(f) (f)
+#  define VOIDFUNC(f) (f)
+#endif
+
+/* Don't use for expressions have side effect */
+#ifndef RB_STRING_VALUE
+#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
+#endif
+#ifndef StringValue
+#define StringValue(s) RB_STRING_VALUE(s)
+#endif
+#ifndef StringValuePtr
+#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
+#endif
+#ifndef StringValueLen
+#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
+#endif
+#ifndef SafeStringValue
+#define SafeStringValue(v) do {\
+    StringValue(v);\
+    rb_check_safe_str(v);\
+} while (0)
+#endif
+
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
+#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
+#endif
+
+static VALUE _mSWIG = Qnil;
+
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+
+/* Define some additional error types */
+#define SWIG_ObjectPreviouslyDeletedError  -100
+
+
+/* Define custom exceptions for errors that do not map to existing Ruby
+   exceptions.  Note this only works for C++ since a global cannot be
+   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/
+
+SWIGINTERN VALUE 
+getNullReferenceError(void) {
+  static int init = 0;
+  static VALUE rb_eNullReferenceError ;
+  if (!init) {
+    init = 1;
+    rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
+  }
+  return rb_eNullReferenceError;
+} 
+
+SWIGINTERN VALUE 
+getObjectPreviouslyDeletedError(void) {
+  static int init = 0;
+  static VALUE rb_eObjectPreviouslyDeleted ;
+  if (!init) {
+    init = 1;
+    rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
+  }
+  return rb_eObjectPreviouslyDeleted;
+} 
+
+
+SWIGINTERN VALUE
+SWIG_Ruby_ErrorType(int SWIG_code) {
+  VALUE type;
+  switch (SWIG_code) {
+  case SWIG_MemoryError:
+    type = rb_eNoMemError;
+    break;
+  case SWIG_IOError:
+    type = rb_eIOError;
+    break;
+  case SWIG_RuntimeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_IndexError:
+    type = rb_eIndexError;
+    break;
+  case SWIG_TypeError:
+    type = rb_eTypeError;
+    break;
+  case SWIG_DivisionByZero:
+    type = rb_eZeroDivError;
+    break;
+  case SWIG_OverflowError:
+    type = rb_eRangeError;
+    break;
+  case SWIG_SyntaxError:
+    type = rb_eSyntaxError;
+    break;
+  case SWIG_ValueError:
+    type = rb_eArgError;
+    break;
+  case SWIG_SystemError:
+    type = rb_eFatal;
+    break;
+  case SWIG_AttributeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_NullReferenceError:
+    type = getNullReferenceError();
+    break;
+  case SWIG_ObjectPreviouslyDeletedError:
+    type = getObjectPreviouslyDeletedError();
+    break;
+  case SWIG_UnknownError:
+    type = rb_eRuntimeError;
+    break;
+  default:
+    type = rb_eRuntimeError;
+  }
+  return type;
+}
+
+
+/* This function is called when a user inputs a wrong argument to
+   a method.
+ */
+SWIGINTERN 
+const char* Ruby_Format_TypeError( const char* msg,
+				   const char* type, 
+				   const char* name, 
+				   const int argn,
+				   VALUE input )
+{
+  char buf[128];
+  VALUE str;
+  VALUE asStr;
+  if ( msg && *msg )
+    {
+      str = rb_str_new2(msg);
+    }
+  else
+    {
+      str = rb_str_new(NULL, 0);
+    }
+
+  str = rb_str_cat2( str, "Expected argument " );
+  sprintf( buf, "%d of type ", argn-1 );
+  str = rb_str_cat2( str, buf );
+  str = rb_str_cat2( str, type );
+  str = rb_str_cat2( str, ", but got " );
+  str = rb_str_cat2( str, rb_obj_classname(input) );
+  str = rb_str_cat2( str, " " );
+  asStr = rb_inspect(input);
+  if ( RSTRING_LEN(asStr) > 30 )
+    {
+      str = rb_str_cat( str, StringValuePtr(asStr), 30 );
+      str = rb_str_cat2( str, "..." );
+    }
+  else
+    {
+      str = rb_str_append( str, asStr );
+    }
+
+  if ( name )
+    {
+      str = rb_str_cat2( str, "\n\tin SWIG method '" );
+      str = rb_str_cat2( str, name );
+      str = rb_str_cat2( str, "'" );
+    }
+
+  return StringValuePtr( str );
+}
+
+/* This function is called when an overloaded method fails */
+SWIGINTERN 
+void Ruby_Format_OverloadedError(
+				 const int argc,
+				 const int maxargs,
+				 const char* method, 
+				 const char* prototypes 
+				 )
+{
+  const char* msg = "Wrong # of arguments";
+  if ( argc <= maxargs ) msg = "Wrong arguments";
+  rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
+	   "Possible C/C++ prototypes are:\n%s",
+	   msg, method, prototypes);
+}
+
+/* -----------------------------------------------------------------------------
+ * rubytracking.swg
+ *
+ * This file contains support for tracking mappings from 
+ * Ruby objects to C++ objects.  This functionality is needed
+ * to implement mark functions for Ruby's mark and sweep
+ * garbage collector.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(ST_DATA_T_DEFINED)
+/* Needs to be explicitly included for Ruby 1.8 and earlier */
+#include <st.h>
+#endif
+
+/* Ruby 1.8 actually assumes the first case. */
+#if SIZEOF_VOIDP == SIZEOF_LONG
+#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
+#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
+#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
+#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
+#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
+#else
+#  error sizeof(void*) is not the same as long or long long
+#endif
+
+/* Global hash table to store Trackings from C/C++
+   structs to Ruby Objects. 
+*/
+static st_table* swig_ruby_trackings = NULL;
+
+static VALUE swig_ruby_trackings_count(ID id, VALUE *var) {
+  return SWIG2NUM(swig_ruby_trackings->num_entries);
+}
+
+
+/* Setup a hash table to store Trackings */
+SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
+  /* Create a hash table to store Trackings from C++
+     objects to Ruby objects. */
+
+  /* Try to see if some other .so has already created a 
+     tracking hash table, which we keep hidden in an instance var
+     in the SWIG module.
+     This is done to allow multiple DSOs to share the same
+     tracking table.
+  */
+  VALUE trackings_value = Qnil;
+  /* change the variable name so that we can mix modules
+     compiled with older SWIG's - this used to be called "@__trackings__" */
+  ID trackings_id = rb_intern( "@__safetrackings__" );
+  VALUE verbose = rb_gv_get("VERBOSE");
+  rb_gv_set("VERBOSE", Qfalse);
+  trackings_value = rb_ivar_get( _mSWIG, trackings_id );
+  rb_gv_set("VERBOSE", verbose);
+
+  /* The trick here is that we have to store the hash table
+  pointer in a Ruby variable. We do not want Ruby's GC to
+  treat this pointer as a Ruby object, so we convert it to
+  a Ruby numeric value. */
+  if (trackings_value == Qnil) {
+    /* No, it hasn't.  Create one ourselves */
+    swig_ruby_trackings = st_init_numtable();
+    rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
+  } else {
+    swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
+  }
+
+        rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", RUBY_VALUE_METHOD_FUNC(swig_ruby_trackings_count), RUBY_VOID_METHOD_FUNC((rb_gvar_setter_t*)NULL))
+;
+}
+
+/* Add a Tracking from a C/C++ struct to a Ruby object */
+SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
+  /* Store the mapping to the global hash table. */
+  st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
+}
+
+/* Get the Ruby object that owns the specified C/C++ struct */
+SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
+  /* Now lookup the value stored in the global hash table */
+  VALUE value;
+
+  if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
+    return value;
+  } else {
+    return Qnil;
+  }
+}
+
+/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
+   is very important to remove objects once they are destroyed
+   since the same memory address may be reused later to create
+   a new object. */
+SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
+  /* Delete the object from the hash table */
+  st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
+}
+
+/* This is a helper method that unlinks a Ruby object from its
+   underlying C++ object.  This is needed if the lifetime of the
+   Ruby object is longer than the C++ object */
+SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
+  VALUE object = SWIG_RubyInstanceFor(ptr);
+
+  if (object != Qnil) {
+    if (TYPE(object) != T_DATA)
+      abort();
+    DATA_PTR(object) = 0;
+  }
+}
+
+/* This is a helper method that iterates over all the trackings
+   passing the C++ object pointer and its related Ruby object
+   to the passed callback function. */
+
+/* Proxy method to abstract the internal trackings datatype */
+      static int swig_ruby_internal_iterate_callback(st_data_t ptr, st_data_t obj, st_data_t meth) {
+        ((void(*)(void*, VALUE))meth)((void*)ptr, (VALUE)obj);
+
+  return ST_CONTINUE;
+}
+
+SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
+  st_foreach(swig_ruby_trackings, RUBY_INT_METHOD_FUNC(swig_ruby_internal_iterate_callback), (st_data_t)meth);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Ruby API portion that goes into the runtime
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGINTERN VALUE
+SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
+  if (NIL_P(target)) {
+    target = o;
+  } else {
+    if (TYPE(target) != T_ARRAY) {
+      VALUE o2 = target;
+      target = rb_ary_new();
+      rb_ary_push(target, o2);
+    }
+    rb_ary_push(target, o);
+  }
+  return target;
+}
+
+/* For ruby1.8.4 and earlier. */
+#ifndef RUBY_INIT_STACK
+   RUBY_EXTERN void Init_stack(VALUE* addr);
+#  define RUBY_INIT_STACK \
+   VALUE variable_in_this_stack_frame; \
+   Init_stack(&variable_in_this_stack_frame);
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* -----------------------------------------------------------------------------
+ * rubyrun.swg
+ *
+ * This file contains the runtime support for Ruby modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
+#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
+#define swig_owntype                                    swig_ruby_owntype
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) 		SWIG_Ruby_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
+#define SWIG_Error(code, msg)            		rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
+#define SWIG_fail                        		goto fail				 
+
+
+/* Ruby-specific SWIG API */
+
+#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
+#define SWIG_define_class(ty)                        	SWIG_Ruby_define_class(ty)
+#define SWIG_NewClassInstance(value, ty)             	SWIG_Ruby_NewClassInstance(value, ty)
+#define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
+#define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  
+
+#include "assert.h"
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  VALUE klass;
+  VALUE mImpl;
+  void  (*mark)(void *);
+  void  (*destroy)(void *);
+  int trackObjects;
+} swig_class;
+
+
+/* Global pointer used to keep some internal SWIG stuff */
+static VALUE _cSWIG_Pointer = Qnil;
+static VALUE swig_runtime_data_type_pointer = Qnil;
+
+/* Global IDs used to keep some internal SWIG stuff */
+static ID swig_arity_id = 0;
+static ID swig_call_id  = 0;
+
+/*
+  If your swig extension is to be run within an embedded ruby and has
+  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
+  This will reset ruby's stack frame on each entry point from the main 
+  program the first time a virtual director function is invoked (in a 
+  non-recursive way).
+  If this is not done, you run the risk of Ruby trashing the stack.
+*/
+
+#ifdef RUBY_EMBEDDED
+
+#  define SWIG_INIT_STACK                            \
+      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
+      ++swig_virtual_calls;
+#  define SWIG_RELEASE_STACK --swig_virtual_calls;
+#  define Ruby_DirectorTypeMismatchException(x) \
+          rb_raise( rb_eTypeError, "%s", x ); return c_result;
+
+      static unsigned int swig_virtual_calls = 0;
+
+#else  /* normal non-embedded extension */
+
+#  define SWIG_INIT_STACK
+#  define SWIG_RELEASE_STACK
+#  define Ruby_DirectorTypeMismatchException(x) \
+          throw Swig::DirectorTypeMismatchException( x );
+
+#endif  /* RUBY_EMBEDDED */
+
+
+SWIGRUNTIME VALUE 
+getExceptionClass(void) {
+  static int init = 0;
+  static VALUE rubyExceptionClass ;
+  if (!init) {
+    init = 1;
+    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
+  }
+  return rubyExceptionClass;
+} 
+
+/* This code checks to see if the Ruby object being raised as part
+   of an exception inherits from the Ruby class Exception.  If so,
+   the object is simply returned.  If not, then a new Ruby exception
+   object is created and that will be returned to Ruby.*/
+SWIGRUNTIME VALUE
+SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
+  VALUE exceptionClass = getExceptionClass();
+  if (rb_obj_is_kind_of(obj, exceptionClass)) {
+    return obj;
+  }  else {
+    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
+  }
+}
+
+/* Initialize Ruby runtime support */
+SWIGRUNTIME void
+SWIG_Ruby_InitRuntime(void)
+{
+  if (_mSWIG == Qnil) {
+    _mSWIG = rb_define_module("SWIG");
+    swig_call_id  = rb_intern("call");
+    swig_arity_id = rb_intern("arity");
+  }
+}
+
+/* Define Ruby class for C type */
+SWIGRUNTIME void
+SWIG_Ruby_define_class(swig_type_info *type)
+{
+  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+  sprintf(klass_name, "TYPE%s", type->name);
+  if (NIL_P(_cSWIG_Pointer)) {
+    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
+    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
+  }
+  rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
+  free((void *) klass_name);
+}
+
+/* Create a new pointer object */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
+{
+  int own =  flags & SWIG_POINTER_OWN; 
+  int track;
+  char *klass_name;
+  swig_class *sklass;
+  VALUE klass;
+  VALUE obj;
+  
+  if (!ptr)
+    return Qnil;
+  
+  if (type->clientdata) {
+    sklass = (swig_class *) type->clientdata;
+		
+    /* Are we tracking this class and have we already returned this Ruby object? */
+    track = sklass->trackObjects;
+    if (track) {
+      obj = SWIG_RubyInstanceFor(ptr);
+      
+      /* Check the object's type and make sure it has the correct type.
+        It might not in cases where methods do things like 
+        downcast methods. */
+      if (obj != Qnil) {
+        VALUE value = rb_iv_get(obj, "@__swigtype__");
+        const char* type_name = RSTRING_PTR(value);
+				
+        if (strcmp(type->name, type_name) == 0) {
+          return obj;
+        }
+      }
+    }
+
+    /* Create a new Ruby object */
+    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
+			   ( own ? VOIDFUNC(sklass->destroy) : 
+			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
+			     ), ptr);
+
+    /* If tracking is on for this class then track this object. */
+    if (track) {
+      SWIG_RubyAddTracking(ptr, obj);
+    }
+  } else {
+    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+    sprintf(klass_name, "TYPE%s", type->name);
+    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
+    free((void *) klass_name);
+    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
+  }
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  
+  return obj;
+}
+
+/* Create a new class instance (always owned) */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
+{
+  VALUE obj;
+  swig_class *sklass = (swig_class *) type->clientdata;
+  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  return obj;
+}
+
+/* Get type mangle from class name */
+SWIGRUNTIMEINLINE char *
+SWIG_Ruby_MangleStr(VALUE obj)
+{
+  VALUE stype = rb_iv_get(obj, "@__swigtype__");
+  return StringValuePtr(stype);
+}
+
+/* Acquire a pointer value */
+typedef struct {
+  void (*datafree)(void *);
+  int own;
+} swig_ruby_owntype;
+
+SWIGRUNTIME swig_ruby_owntype
+SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
+  swig_ruby_owntype oldown = {0, 0};
+  if (obj) {
+    oldown.datafree = RDATA(obj)->dfree;
+    RDATA(obj)->dfree = own.datafree;
+  }
+  return oldown;
+}
+
+/* Convert a pointer value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
+{
+  char *c;
+  swig_cast_info *tc;
+  void *vptr = 0;
+
+  /* Grab the pointer */
+  if (NIL_P(obj)) {
+    if (ptr)
+      *ptr = 0;
+    return SWIG_OK;
+  } else {
+    if (TYPE(obj) != T_DATA) {
+      return SWIG_ERROR;
+    }
+    Data_Get_Struct(obj, void, vptr);
+  }
+  
+  if (own) {
+    own->datafree = RDATA(obj)->dfree;
+    own->own = 0;
+  }
+    
+  /* Check to see if the input object is giving up ownership
+     of the underlying C struct or C++ object.  If so then we
+     need to reset the destructor since the Ruby object no 
+     longer owns the underlying C++ object.*/ 
+  if (flags & SWIG_POINTER_DISOWN) {
+    /* Is tracking on for this class? */
+    int track = 0;
+    if (ty && ty->clientdata) {
+      swig_class *sklass = (swig_class *) ty->clientdata;
+      track = sklass->trackObjects;
+    }
+		
+    if (track) {
+      /* We are tracking objects for this class.  Thus we change the destructor
+       * to SWIG_RubyRemoveTracking.  This allows us to
+       * remove the mapping from the C++ to Ruby object
+       * when the Ruby object is garbage collected.  If we don't
+       * do this, then it is possible we will return a reference 
+       * to a Ruby object that no longer exists thereby crashing Ruby. */
+      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
+    } else {    
+      RDATA(obj)->dfree = 0;
+    }
+  }
+
+  /* Do type-checking if type info was provided */
+  if (ty) {
+    if (ty->clientdata) {
+      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
+        if (vptr == 0) {
+          /* The object has already been deleted */
+          return SWIG_ObjectPreviouslyDeletedError;
+        }
+      }
+    }
+    if ((c = SWIG_MangleStr(obj)) == NULL) {
+      return SWIG_ERROR;
+    }
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) {
+      return SWIG_ERROR;
+    } else {
+      if (ptr) {
+        if (tc->type == ty) {
+          *ptr = vptr;
+        } else {
+          int newmemory = 0;
+          *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
+          if (newmemory == SWIG_CAST_NEW_MEMORY) {
+            assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+            if (own)
+              own->own = own->own | SWIG_CAST_NEW_MEMORY;
+          }
+        }
+      }
+    }
+  } else {
+    if (ptr)
+      *ptr = vptr;
+  }
+  
+  return SWIG_OK;
+}
+
+/* Check convert */
+SWIGRUNTIMEINLINE int
+SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
+{
+  char *c = SWIG_MangleStr(obj);
+  if (!c) return 0;
+  return SWIG_TypeCheck(c,ty) != 0;
+}
+
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r, ptr, sz);
+  strcpy(r, type->name);
+  return rb_str_new2(result);
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c;
+
+  if (TYPE(obj) != T_STRING) goto type_error;
+  c = StringValuePtr(obj);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') goto type_error;
+  c++;
+  c = SWIG_UnpackData(c, ptr, sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) goto type_error;
+  }
+  return SWIG_OK;
+
+ type_error:
+  return SWIG_ERROR;
+}
+
+SWIGRUNTIME swig_module_info *
+SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
+{
+  VALUE pointer;
+  swig_module_info *ret = 0;
+  VALUE verbose = rb_gv_get("VERBOSE");
+
+ /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
+  rb_gv_set("VERBOSE", Qfalse);
+  
+  /* first check if pointer already created */
+  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  if (pointer != Qnil) {
+    Data_Get_Struct(pointer, swig_module_info, ret);
+  }
+
+  /* reinstate warnings */
+  rb_gv_set("VERBOSE", verbose);
+  return ret;
+}
+
+SWIGRUNTIME void 
+SWIG_Ruby_SetModule(swig_module_info *pointer)
+{
+  /* register a new class */
+  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
+  /* create and store the structure pointer to a global variable */
+  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
+  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
+}
+
+/* This function can be used to check whether a proc or method or similarly
+   callable function has been passed.  Usually used in a %typecheck, like:
+
+   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
+        $result = SWIG_Ruby_isCallable( $input );
+   }
+ */
+SWIGINTERN
+int SWIG_Ruby_isCallable( VALUE proc )
+{
+  if ( rb_respond_to( proc, swig_call_id ) )
+    return 1;
+  return 0;
+}
+
+/* This function can be used to check the arity (number of arguments)
+   a proc or method can take.  Usually used in a %typecheck.
+   Valid arities will be that equal to minimal or those < 0
+   which indicate a variable number of parameters at the end.
+ */
+SWIGINTERN
+int SWIG_Ruby_arity( VALUE proc, int minimal )
+{
+  if ( rb_respond_to( proc, swig_arity_id ) )
+    {
+      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
+      int arity = NUM2INT(num);
+      if ( arity < 0 && (arity+1) < -minimal ) return 1;
+      if ( arity == minimal ) return 1;
+      return 1;
+    }
+  return 0;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
+
+
+
+  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) 
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_p_FX4Splitter swig_types[0]
+#define SWIGTYPE_p_FXAccelTable swig_types[1]
+#define SWIGTYPE_p_FXApp swig_types[2]
+#define SWIGTYPE_p_FXBitmap swig_types[3]
+#define SWIGTYPE_p_FXCURCursor swig_types[4]
+#define SWIGTYPE_p_FXComposite swig_types[5]
+#define SWIGTYPE_p_FXCursor swig_types[6]
+#define SWIGTYPE_p_FXDC swig_types[7]
+#define SWIGTYPE_p_FXDataTarget swig_types[8]
+#define SWIGTYPE_p_FXDebugTarget swig_types[9]
+#define SWIGTYPE_p_FXDelegator swig_types[10]
+#define SWIGTYPE_p_FXDict swig_types[11]
+#define SWIGTYPE_p_FXDockSite swig_types[12]
+#define SWIGTYPE_p_FXDocument swig_types[13]
+#define SWIGTYPE_p_FXDrawable swig_types[14]
+#define SWIGTYPE_p_FXFileDict swig_types[15]
+#define SWIGTYPE_p_FXFileItem swig_types[16]
+#define SWIGTYPE_p_FXFileList swig_types[17]
+#define SWIGTYPE_p_FXFileStream swig_types[18]
+#define SWIGTYPE_p_FXFont swig_types[19]
+#define SWIGTYPE_p_FXFrame swig_types[20]
+#define SWIGTYPE_p_FXGIFCursor swig_types[21]
+#define SWIGTYPE_p_FXGroupBox swig_types[22]
+#define SWIGTYPE_p_FXHeader swig_types[23]
+#define SWIGTYPE_p_FXHorizontalFrame swig_types[24]
+#define SWIGTYPE_p_FXIcon swig_types[25]
+#define SWIGTYPE_p_FXIconDict swig_types[26]
+#define SWIGTYPE_p_FXIconItem swig_types[27]
+#define SWIGTYPE_p_FXIconList swig_types[28]
+#define SWIGTYPE_p_FXId swig_types[29]
+#define SWIGTYPE_p_FXMainWindow swig_types[30]
+#define SWIGTYPE_p_FXMatrix swig_types[31]
+#define SWIGTYPE_p_FXMemoryStream swig_types[32]
+#define SWIGTYPE_p_FXObject swig_types[33]
+#define SWIGTYPE_p_FXPacker swig_types[34]
+#define SWIGTYPE_p_FXPopup swig_types[35]
+#define SWIGTYPE_p_FXRecentFiles swig_types[36]
+#define SWIGTYPE_p_FXRegion swig_types[37]
+#define SWIGTYPE_p_FXRegistry swig_types[38]
+#define SWIGTYPE_p_FXRootWindow swig_types[39]
+#define SWIGTYPE_p_FXScrollArea swig_types[40]
+#define SWIGTYPE_p_FXScrollWindow swig_types[41]
+#define SWIGTYPE_p_FXSettings swig_types[42]
+#define SWIGTYPE_p_FXShell swig_types[43]
+#define SWIGTYPE_p_FXShutter swig_types[44]
+#define SWIGTYPE_p_FXShutterItem swig_types[45]
+#define SWIGTYPE_p_FXSplashWindow swig_types[46]
+#define SWIGTYPE_p_FXSplitter swig_types[47]
+#define SWIGTYPE_p_FXSpring swig_types[48]
+#define SWIGTYPE_p_FXStatusBar swig_types[49]
+#define SWIGTYPE_p_FXStream swig_types[50]
+#define SWIGTYPE_p_FXStringDict swig_types[51]
+#define SWIGTYPE_p_FXSwitcher swig_types[52]
+#define SWIGTYPE_p_FXTopWindow swig_types[53]
+#define SWIGTYPE_p_FXTranslator swig_types[54]
+#define SWIGTYPE_p_FXVerticalFrame swig_types[55]
+#define SWIGTYPE_p_FXVisual swig_types[56]
+#define SWIGTYPE_p_FXWindow swig_types[57]
+#define SWIGTYPE_p_char swig_types[58]
+#define SWIGTYPE_p_double swig_types[59]
+#define SWIGTYPE_p_float swig_types[60]
+#define SWIGTYPE_p_int swig_types[61]
+#define SWIGTYPE_p_long swig_types[62]
+#define SWIGTYPE_p_short swig_types[63]
+#define SWIGTYPE_p_unsigned_char swig_types[64]
+#define SWIGTYPE_p_unsigned_int swig_types[65]
+#define SWIGTYPE_p_unsigned_long swig_types[66]
+#define SWIGTYPE_p_unsigned_short swig_types[67]
+static swig_type_info *swig_types[69];
+static swig_module_info swig_module = {swig_types, 68, 0, 0, 0, 0};
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
+
+/* -------- TYPES TABLE (END) -------- */
+
+#define SWIG_init    Init_iconlist
+#define SWIG_name    "Iconlist"
+
+
+
+#define SWIG_RUBY_THREAD_BEGIN_BLOCK
+#define SWIG_RUBY_THREAD_END_BLOCK
+
+
+#define SWIGVERSION 0x030012 
+#define SWIG_VERSION SWIGVERSION
+
+
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
+
+
+#include <stdexcept>
+
+
+#include "FXRbCommon.h"
+
+
+inline FXColor to_FXColor(VALUE obj){
+  if(TYPE(obj)==T_STRING){
+    return fxcolorfromname(StringValuePtr(obj));
+    }
+  else if(TYPE(obj)==T_SYMBOL){
+    return fxcolorfromname(rb_id2name(SYM2ID(obj)));
+    }
+  else{
+    return NUM2ULONG(obj);
+    }
+  }
+
+
+inline FXString to_FXString(VALUE obj){
+  if(!NIL_P(obj)){
+    Check_Type(obj,T_STRING);
+    return FXString(StringValuePtr(obj));
+    }
+  else{
+    return FXString::null;
+    }
+  }
+
+
+inline FXbool to_FXbool(VALUE obj){
+  if (obj == Qtrue || obj == Qfalse){
+    return (obj == Qtrue) ? TRUE : FALSE;
+    }
+  else{
+    return static_cast<FXbool>(NUM2UINT(obj));
+    }
+  }
+
+
+static swig_type_info* FXEventTypeInfo=0;
+
+inline void* to_FXEvent(VALUE obj){
+  void* ptr;
+  if(!FXEventTypeInfo){
+    FXEventTypeInfo=SWIG_TypeQuery("FXEvent *");
+    FXASSERT(FXEventTypeInfo!=0);
+    }
+  SWIG_ConvertPtr(obj,&ptr,FXEventTypeInfo,1);
+  return ptr;
+  }
+
+
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
+
+
+  #define SWIG_From_long   LONG2NUM 
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_int  (int value)
+{    
+  return SWIG_From_long  (value);
+}
+
+SWIGINTERN FXIconItem *new_FXIconItem(FXString const &text,FXIcon *bi=0,FXIcon *mi=0,void *ITEMDATA=0){
+      return new FXRbIconItem(text,bi,mi,ITEMDATA);
+      }
+SWIGINTERN void FXIconItem_setData(FXIconItem *self,VALUE ptr){
+      self->setData((void*) ptr);
+      }
+SWIGINTERN VALUE FXIconItem_getData(FXIconItem const *self){
+      return self->getData() ? (VALUE) self->getData() : Qnil;
+      }
+
+static swig_type_info *FXIconItem_dynamic_cast(void **ptr) {
+    FXIconItem **ppIconItem = reinterpret_cast<FXIconItem **>(ptr);
+    FXFileItem *pFileItem=dynamic_cast<FXFileItem*>(*ppIconItem);
+    if(pFileItem){
+      *ptr=reinterpret_cast<void*>(pFileItem);
+      return SWIG_TypeQuery("FXFileItem *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXIconList *new_FXIconList(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=ICONLIST_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbIconList(p,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN FXint FXIconList_setItem__SWIG_0(FXIconList *self,FXint index,FXIconItem *item,FXbool notify=0){
+      // Save pointer to the soon-to-be-destroyed item
+      FXIconItem* oldItem=self->getItem(index);
+
+      // Do the deed
+      if(item->isMemberOf(FXMETACLASS(FXRbIconItem)))
+        dynamic_cast<FXRbIconItem*>(item)->owned=1;
+      FXint result=self->setItem(index,item,notify);
+
+      // Now zero-out pointers held by still-alive Ruby objects
+      FXRbUnregisterRubyObj(oldItem);
+
+      // Done
+      return result;
+      }
+SWIGINTERN FXint FXIconList_setItem__SWIG_1(FXIconList *self,FXint index,FXString const &text,FXIcon *big=0,FXIcon *mini=0,void *ITEMDATA=0,FXbool notify=0){
+      // Save pointer to the soon-to-be-destroyed item
+      FXIconItem* oldItem=self->getItem(index);
+
+      // Do the deed
+      FXint result=self->setItem(index,text,big,mini,ITEMDATA,notify);
+
+      // Now zero-out pointers held by still-alive Ruby objects
+      FXRbUnregisterRubyObj(oldItem);
+
+      // Done
+      return result;
+      }
+SWIGINTERN FXint FXIconList_insertItem__SWIG_0(FXIconList *self,FXint index,FXIconItem *item,FXbool notify=0){
+      if(item->isMemberOf(FXMETACLASS(FXRbIconItem)))
+        dynamic_cast<FXRbIconItem*>(item)->owned=1;
+      return self->insertItem(index,item,notify);
+      }
+SWIGINTERN FXint FXIconList_appendItem__SWIG_0(FXIconList *self,FXIconItem *item,FXbool notify=0){
+      if(item->isMemberOf(FXMETACLASS(FXRbIconItem)))
+        dynamic_cast<FXRbIconItem*>(item)->owned=1;
+      return self->appendItem(item,notify);
+      }
+SWIGINTERN FXint FXIconList_prependItem__SWIG_0(FXIconList *self,FXIconItem *item,FXbool notify=0){
+      if(item->isMemberOf(FXMETACLASS(FXRbIconItem)))
+        dynamic_cast<FXRbIconItem*>(item)->owned=1;
+      return self->prependItem(item,notify);
+      }
+SWIGINTERN void FXIconList_removeItem(FXIconList *self,FXint index,FXbool notify=0){
+      // Save pointer to the soon-to-be-destroyed item
+      FXIconItem* item=self->getItem(index);
+
+      // Do the deed
+      self->removeItem(index,notify);
+
+      // Now zero-out pointers held by still-alive Ruby objects
+      FXRbUnregisterRubyObj(item);
+      }
+SWIGINTERN void FXIconList_clearItems(FXIconList *self,FXbool notify=0){
+      // Save pointers to the soon-to-be-destroyed items
+      FXObjectListOf<FXIconItem> items;
+      FXint numItems = self->getNumItems();
+      for (FXint i = 0; i< numItems; i++) items.append(self->getItem(i));
+
+      // Do the deed
+      self->clearItems(notify);
+
+      // Now zero-out pointers held by still-alive Ruby objects
+      for (FXint j = 0; j < items.no(); j++) FXRbUnregisterRubyObj(items[j]);
+      }
+SWIGINTERN void FXIconList_makeItemVisible__SWIG_0(FXIconList *self,FXIconItem *item){
+      FXint numItems=self->getNumItems();
+      for(FXint i=0; i<numItems; i++){
+        if(self->getItem(i)==item){
+          self->makeItemVisible(i);
+	  break;
+	  }
+	}
+      }
+SWIGINTERN void FXIconList_setItemData(FXIconList *self,FXint index,VALUE ptr){
+      self->setItemData(index, (void*) ptr);
+      }
+SWIGINTERN VALUE FXIconList_getItemData(FXIconList const *self,FXint index){
+      return self->getItemData(index) ? (VALUE) self->getItemData(index) : Qnil;
+      }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_long  (unsigned long value)
+{
+  return ULONG2NUM(value); 
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_int  (unsigned int value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_bool  (bool value)
+{
+  return value ? Qtrue : Qfalse;
+}
+
+
+SWIGINTERN swig_type_info*
+SWIG_pchar_descriptor(void)
+{
+  static int init = 0;
+  static swig_type_info* info = 0;
+  if (!init) {
+    info = SWIG_TypeQuery("_p_char");
+    init = 1;
+  }
+  return info;
+}
+
+
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
+{
+  if (TYPE(obj) == T_STRING) {
+    char *cstr = StringValuePtr(obj); 
+    size_t size = RSTRING_LEN(obj) + 1;
+    if (cptr)  {
+      if (alloc) {
+	if (*alloc == SWIG_NEWOBJ) {
+	  *cptr = reinterpret_cast< char* >(memcpy(new char[size], cstr, sizeof(char)*(size)));
+	} else {
+	  *cptr = cstr;
+	  *alloc = SWIG_OLDOBJ;
+	}
+      }
+    }
+    if (psize) *psize = size;
+    return SWIG_OK;
+  } else {
+    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+    if (pchar_descriptor) {
+      void* vptr = 0;
+      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
+	if (cptr) *cptr = (char *)vptr;
+	if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
+	if (alloc) *alloc = SWIG_OLDOBJ;
+	return SWIG_OK;
+      }
+    }
+  }  
+  return SWIG_TypeError;
+}
+
+
+
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+  if (carray) {
+    if (size > LONG_MAX) {
+      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+      return pchar_descriptor ? 
+	SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : Qnil;
+    } else {
+      return rb_str_new(carray, static_cast< long >(size));
+    }
+  } else {
+    return Qnil;
+  }
+}
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtr(const char *cptr)
+{ 
+  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
+}
+
+SWIGINTERN VALUE FXIconList_position__SWIG_1(FXIconList const *self){
+    FXint x, y;
+    self->getPosition(x, y);
+    VALUE pos = rb_ary_new();
+    rb_ary_push(pos, INT2NUM(x));
+    rb_ary_push(pos, INT2NUM(y));
+    return pos;
+  }
+
+static swig_type_info *FXIconList_dynamic_cast(void **ptr) {
+    FXIconList **ppIconList = reinterpret_cast<FXIconList **>(ptr);
+    FXFileList *pFileList=dynamic_cast<FXFileList*>(*ppIconList);
+    if(pFileList){
+      *ptr=reinterpret_cast<void*>(pFileList);
+      return SWIG_TypeQuery("FXFileList *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXFileItem *new_FXFileItem(FXString const &text,FXIcon *bi=0,FXIcon *mi=0,void *ITEMDATA=0){
+      return new FXRbFileItem(text,bi,mi,ITEMDATA);
+      }
+SWIGINTERN FXFileList *new_FXFileList(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbFileList(p,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN VALUE FXFileList_position__SWIG_1(FXFileList const *self){
+    FXint x, y;
+    self->getPosition(x, y);
+    VALUE pos = rb_ary_new();
+    rb_ary_push(pos, INT2NUM(x));
+    rb_ary_push(pos, INT2NUM(y));
+    return pos;
+  }
+static swig_class SwigClassFXIconItem;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXIconItem_allocate(VALUE self)
+#else
+_wrap_FXIconItem_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXIconItem);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXIconItem(int argc, VALUE *argv, VALUE self) {
+  FXString *arg1 = 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  void *arg4 = (void *) 0 ;
+  SwigValueWrapper< FXString > p1 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXIconItem *result = 0 ;
+  
+  if ((argc < 1) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  p1 = to_FXString(argv[0]); arg1 = &p1;
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","FXIconItem", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXIcon * >(argp2);
+  }
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","FXIconItem", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = (argv[3] == Qnil) ? NULL : (void *) argv[3];
+  }
+  {
+    result = (FXIconItem *)new_FXIconItem((FXString const &)*arg1,arg2,arg3,arg4);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_getText(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","getText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  result = (FXString *) &((FXIconItem const *)arg1)->getText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_getBigIcon(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","getBigIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  result = (FXIcon *)((FXIconItem const *)arg1)->getBigIcon();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_getMiniIcon(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","getMiniIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  result = (FXIcon *)((FXIconItem const *)arg1)->getMiniIcon();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_setData(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem *","setData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  arg2 = argv[0];
+  FXIconItem_setData(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_getData(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","getData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  result = (VALUE)FXIconItem_getData((FXIconItem const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_hasFocus(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","hasFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  result = (FXbool)((FXIconItem const *)arg1)->hasFocus();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_isSelected(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","isSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  result = (FXbool)((FXIconItem const *)arg1)->isSelected();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_isEnabled(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","isEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  result = (FXbool)((FXIconItem const *)arg1)->isEnabled();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_isDraggable(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","isDraggable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  result = (FXbool)((FXIconItem const *)arg1)->isDraggable();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_save(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXIconItem_save((FXIconItem const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_load(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXIconItem_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_draw(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconList *arg2 = (FXIconList *) 0 ;
+  FXDC *arg3 = 0 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","draw", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconList const *","draw", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIconList * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXDC,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXDC &","draw", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDC &","draw", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXDC * >(argp3);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXIconItem_draw((FXIconItem const *)arg1,(FXIconList const *)arg2,*arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_hitItem(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconList *arg2 = (FXIconList *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 = (FXint) 1 ;
+  FXint arg6 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","hitItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconList const *","hitItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIconList * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  if (argc > 3) {
+    arg5 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg6 = NUM2INT(argv[4]);
+  }
+  result = (FXint)FXIconItem_hitItem((FXIconItem const *)arg1,(FXIconList const *)arg2,arg3,arg4,arg5,arg6);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_drawBigIcon(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconList *arg2 = (FXIconList *) 0 ;
+  FXDC *arg3 = 0 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","drawBigIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconList const *","drawBigIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIconList * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXDC,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXDC &","drawBigIcon", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDC &","drawBigIcon", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXDC * >(argp3);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXIconItem_drawBigIcon((FXIconItem const *)arg1,(FXIconList const *)arg2,*arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_drawMiniIcon(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconList *arg2 = (FXIconList *) 0 ;
+  FXDC *arg3 = 0 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","drawMiniIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconList const *","drawMiniIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIconList * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXDC,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXDC &","drawMiniIcon", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDC &","drawMiniIcon", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXDC * >(argp3);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXIconItem_drawMiniIcon((FXIconItem const *)arg1,(FXIconList const *)arg2,*arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_drawDetails(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconList *arg2 = (FXIconList *) 0 ;
+  FXDC *arg3 = 0 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","drawDetails", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconList const *","drawDetails", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIconList * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXDC,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXDC &","drawDetails", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDC &","drawDetails", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXDC * >(argp3);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXIconItem_drawDetails((FXIconItem const *)arg1,(FXIconList const *)arg2,*arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_setText(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem *","setText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  FXIconItem_setText(arg1,(FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_setBigIcon(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem *","setBigIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setBigIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXIconItem_setBigIcon(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_setMiniIcon(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem *","setMiniIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setMiniIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXIconItem_setMiniIcon(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXIconItem_setFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_setSelected(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem *","setSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXIconItem_setSelected(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_setEnabled(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem *","setEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXIconItem_setEnabled(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_setDraggable(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem *","setDraggable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXIconItem_setDraggable(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_getWidth(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconList *arg2 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","getWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconList const *","getWidth", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIconList * >(argp2);
+  result = (FXint)FXIconItem_getWidth((FXIconItem const *)arg1,(FXIconList const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_getHeight(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconList *arg2 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","getHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconList const *","getHeight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIconList * >(argp2);
+  result = (FXint)FXIconItem_getHeight((FXIconItem const *)arg1,(FXIconList const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_create(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  FXIconItem_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_detach(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  FXIconItem_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconItem_destroy(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  FXIconItem_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXIconList;
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onEnter(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onLeave(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onRightBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onRightBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onRightBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onRightBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onRightBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onRightBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onTipTimer(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onTipTimer", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTipTimer", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onTipTimer(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onCmdSelectAll(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onCmdSelectAll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSelectAll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSelectAll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onCmdDeselectAll(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onCmdDeselectAll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDeselectAll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDeselectAll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onCmdSelectInverse(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onCmdSelectInverse", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSelectInverse", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSelectInverse(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onCmdArrangeByRows(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onCmdArrangeByRows", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdArrangeByRows", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdArrangeByRows(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onUpdArrangeByRows(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onUpdArrangeByRows", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdArrangeByRows", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdArrangeByRows(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onCmdArrangeByColumns(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onCmdArrangeByColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdArrangeByColumns", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdArrangeByColumns(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onUpdArrangeByColumns(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onUpdArrangeByColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdArrangeByColumns", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdArrangeByColumns(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onCmdShowDetails(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onCmdShowDetails", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdShowDetails", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdShowDetails(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onUpdShowDetails(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onUpdShowDetails", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdShowDetails", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdShowDetails(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onCmdShowBigIcons(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onCmdShowBigIcons", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdShowBigIcons", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdShowBigIcons(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onUpdShowBigIcons(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onUpdShowBigIcons", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdShowBigIcons", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdShowBigIcons(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onCmdShowMiniIcons(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onCmdShowMiniIcons", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdShowMiniIcons", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdShowMiniIcons(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onUpdShowMiniIcons(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onUpdShowMiniIcons", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdShowMiniIcons", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdShowMiniIcons(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onHeaderChanged(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onHeaderChanged", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHeaderChanged", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onHeaderChanged(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onHeaderResize(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onHeaderResize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHeaderResize", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onHeaderResize(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onFocusIn(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onFocusIn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusIn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusIn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onFocusOut(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onFocusOut", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusOut", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusOut(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onClicked(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onDoubleClicked(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onDoubleClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDoubleClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onDoubleClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onTripleClicked(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onTripleClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTripleClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onTripleClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onCommand(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onCommand", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCommand", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCommand(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onAutoScroll(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onAutoScroll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onAutoScroll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onAutoScroll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onLookupTimer(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onLookupTimer", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLookupTimer", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onLookupTimer(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXint) NUM2INT(argv[2]);
+    arg4 = static_cast<void*>(&value4);
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_ascending(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconItem *arg2 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","FXIconList::ascending", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconItem const *","FXIconList::ascending", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXIconItem * >(argp2);
+  result = (FXint)FXIconList::ascending((FXIconItem const *)arg1,(FXIconItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_descending(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconItem *arg2 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","FXIconList::descending", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconItem const *","FXIconList::descending", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXIconItem * >(argp2);
+  result = (FXint)FXIconList::descending((FXIconItem const *)arg1,(FXIconItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_ascendingCase(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconItem *arg2 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","FXIconList::ascendingCase", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconItem const *","FXIconList::ascendingCase", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXIconItem * >(argp2);
+  result = (FXint)FXIconList::ascendingCase((FXIconItem const *)arg1,(FXIconItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_descendingCase(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconItem *arg2 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","FXIconList::descendingCase", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconItem const *","FXIconList::descendingCase", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXIconItem * >(argp2);
+  result = (FXint)FXIconList::descendingCase((FXIconItem const *)arg1,(FXIconItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXIconList_allocate(VALUE self)
+#else
+_wrap_FXIconList_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXIconList);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXIconList(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) ICONLIST_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXIconList *result = 0 ;
+  
+  if ((argc < 1) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXIconList", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXIconList", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXIconList *)new_FXIconList(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getNumItems(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getNumItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (FXint)((FXIconList const *)arg1)->getNumItems();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getNumRows(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getNumRows", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (FXint)((FXIconList const *)arg1)->getNumRows();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getNumCols(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getNumCols", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (FXint)((FXIconList const *)arg1)->getNumCols();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getHeader(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXHeader *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getHeader", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (FXHeader *)((FXIconList const *)arg1)->getHeader();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXHeader, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setHeaders(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXchar **arg2 = (FXchar **) 0 ;
+  FXint arg3 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setHeaders", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  {
+    arg2 = NULL;
+    if(!NIL_P(argv[0])){
+      Check_Type(argv[0], T_ARRAY);
+      if (FXMALLOC(&arg2, FXchar *, RARRAY_LEN(argv[0])+1)) {
+        for (long i = 0; i < RARRAY_LEN(argv[0]); i++) {
+          VALUE e = rb_ary_entry(argv[0], i);
+          arg2[i] = (FXchar *) StringValuePtr(e);
+        }
+        arg2[RARRAY_LEN(argv[0])] = 0;
+      }
+    }
+  }
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  (arg1)->setHeaders((FXchar const **)arg2,arg3);
+  FXFREE(&arg2);
+  return Qnil;
+fail:
+  FXFREE(&arg2);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_appendHeader(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXint arg4 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","appendHeader", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","appendHeader", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  (arg1)->appendHeader((FXString const &)*arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_removeHeader(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","removeHeader", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumHeaders()) {
+      rb_raise(rb_eIndexError, "icon list header index out of bounds");
+    }
+  }
+  (arg1)->removeHeader(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setHeaderText(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setHeaderText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumHeaders()) {
+      rb_raise(rb_eIndexError, "icon list header index out of bounds");
+    }
+  }
+  (arg1)->setHeaderText(arg2,(FXString const &)*arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getHeaderText(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getHeaderText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumHeaders()) {
+      rb_raise(rb_eIndexError, "icon list header index out of bounds");
+    }
+  }
+  result = ((FXIconList const *)arg1)->getHeaderText(arg2);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setHeaderIcon(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setHeaderIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","setHeaderIcon", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXIcon * >(argp3);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumHeaders()) {
+      rb_raise(rb_eIndexError, "icon list header index out of bounds");
+    }
+  }
+  (arg1)->setHeaderIcon(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getHeaderIcon(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getHeaderIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumHeaders()) {
+      rb_raise(rb_eIndexError, "icon list header index out of bounds");
+    }
+  }
+  result = (FXIcon *)((FXIconList const *)arg1)->getHeaderIcon(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setHeaderSize(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setHeaderSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumHeaders()) {
+      rb_raise(rb_eIndexError, "icon list header index out of bounds");
+    }
+  }
+  (arg1)->setHeaderSize(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getHeaderSize(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getHeaderSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumHeaders()) {
+      rb_raise(rb_eIndexError, "icon list header index out of bounds");
+    }
+  }
+  result = (FXint)((FXIconList const *)arg1)->getHeaderSize(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getNumHeaders(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getNumHeaders", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (FXint)((FXIconList const *)arg1)->getNumHeaders();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getItem(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIconItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  result = (FXIconItem *)((FXIconList const *)arg1)->getItem(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIconItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setItem__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXIconItem *arg3 = (FXIconItem *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIconItem *","setItem", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXIconItem * >(argp3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  result = (FXint)FXIconList_setItem__SWIG_0(arg1,arg2,arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setItem__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  void *arg6 = (void *) 0 ;
+  FXbool arg7 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  if (argc > 2) {
+    res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","setItem", 4, argv[2] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 3) {
+    res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","setItem", 5, argv[3] )); 
+    }
+    arg5 = reinterpret_cast< FXIcon * >(argp5);
+  }
+  if (argc > 4) {
+    arg6 = (argv[4] == Qnil) ? NULL : (void *) argv[4];
+  }
+  if (argc > 5) {
+    arg7 = to_FXbool(argv[5]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  result = (FXint)FXIconList_setItem__SWIG_1(arg1,arg2,(FXString const &)*arg3,arg4,arg5,arg6,arg7);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXIconList_setItem(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[8];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 8) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 3) && (argc <= 4)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXIconList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXIconItem, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXIconList_setItem__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (argv[3] == Qtrue || argv[3] == Qfalse) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_FXIconList_setItem__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 3) && (argc <= 7)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXIconList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXIconList_setItem__SWIG_1(nargs, args, self);
+          }
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXIconList_setItem__SWIG_1(nargs, args, self);
+            }
+            void *vptr = 0;
+            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_FXIcon, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_FXIconList_setItem__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = 1;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_FXIconList_setItem__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (argv[6] == Qtrue || argv[6] == Qfalse) ? 1 : 0;
+                }
+                if (_v) {
+                  return _wrap_FXIconList_setItem__SWIG_1(nargs, args, self);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 8, "setItem", 
+    "    FXint setItem(FXint index, FXIconItem *item, FXbool notify)\n"
+    "    FXint setItem(FXint index, FXString const &text, FXIcon *big, FXIcon *mini, void *ITEMDATA, FXbool notify)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_fillItems(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXchar **arg2 = (FXchar **) 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  void *arg5 = (void *) 0 ;
+  FXbool arg6 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","fillItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  {
+    arg2 = NULL;
+    if(!NIL_P(argv[0])){
+      Check_Type(argv[0], T_ARRAY);
+      if (FXMALLOC(&arg2, FXchar *, RARRAY_LEN(argv[0])+1)) {
+        for (long i = 0; i < RARRAY_LEN(argv[0]); i++) {
+          VALUE e = rb_ary_entry(argv[0], i);
+          arg2[i] = (FXchar *) StringValuePtr(e);
+        }
+        arg2[RARRAY_LEN(argv[0])] = 0;
+      }
+    }
+  }
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","fillItems", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 2) {
+    res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","fillItems", 4, argv[2] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 3) {
+    arg5 = (argv[3] == Qnil) ? NULL : (void *) argv[3];
+  }
+  if (argc > 4) {
+    arg6 = to_FXbool(argv[4]);
+  }
+  result = (FXint)(arg1)->fillItems((FXchar const **)arg2,arg3,arg4,arg5,arg6);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  FXFREE(&arg2);
+  return vresult;
+fail:
+  FXFREE(&arg2);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_insertItem__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXIconItem *arg3 = (FXIconItem *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","insertItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIconItem *","insertItem", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXIconItem * >(argp3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  result = (FXint)FXIconList_insertItem__SWIG_0(arg1,arg2,arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_insertItem__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  void *arg6 = (void *) 0 ;
+  FXbool arg7 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","insertItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  if (argc > 2) {
+    res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","insertItem", 4, argv[2] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 3) {
+    res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","insertItem", 5, argv[3] )); 
+    }
+    arg5 = reinterpret_cast< FXIcon * >(argp5);
+  }
+  if (argc > 4) {
+    arg6 = (argv[4] == Qnil) ? NULL : (void *) argv[4];
+  }
+  if (argc > 5) {
+    arg7 = to_FXbool(argv[5]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  result = (FXint)(arg1)->insertItem(arg2,(FXString const &)*arg3,arg4,arg5,arg6,arg7);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXIconList_insertItem(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[8];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 8) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 3) && (argc <= 4)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXIconList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXIconItem, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXIconList_insertItem__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (argv[3] == Qtrue || argv[3] == Qfalse) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_FXIconList_insertItem__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 3) && (argc <= 7)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXIconList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXIconList_insertItem__SWIG_1(nargs, args, self);
+          }
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXIconList_insertItem__SWIG_1(nargs, args, self);
+            }
+            void *vptr = 0;
+            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_FXIcon, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_FXIconList_insertItem__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = 1;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_FXIconList_insertItem__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (argv[6] == Qtrue || argv[6] == Qfalse) ? 1 : 0;
+                }
+                if (_v) {
+                  return _wrap_FXIconList_insertItem__SWIG_1(nargs, args, self);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 8, "insertItem", 
+    "    FXint insertItem(FXint index, FXIconItem *item, FXbool notify)\n"
+    "    FXint insertItem(FXint index, FXString const &text, FXIcon *big, FXIcon *mini, void *ITEMDATA, FXbool notify)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_appendItem__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXIconItem *arg2 = (FXIconItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","appendItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconItem *","appendItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIconItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXint)FXIconList_appendItem__SWIG_0(arg1,arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_appendItem__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  void *arg5 = (void *) 0 ;
+  FXbool arg6 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","appendItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","appendItem", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 2) {
+    res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","appendItem", 4, argv[2] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 3) {
+    arg5 = (argv[3] == Qnil) ? NULL : (void *) argv[3];
+  }
+  if (argc > 4) {
+    arg6 = to_FXbool(argv[4]);
+  }
+  result = (FXint)(arg1)->appendItem((FXString const &)*arg2,arg3,arg4,arg5,arg6);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXIconList_appendItem(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[7];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 7) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 2) && (argc <= 3)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXIconList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIconItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_FXIconList_appendItem__SWIG_0(nargs, args, self);
+        }
+        {
+          _v = (argv[2] == Qtrue || argv[2] == Qfalse) ? 1 : 0;
+        }
+        if (_v) {
+          return _wrap_FXIconList_appendItem__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  if ((argc >= 2) && (argc <= 6)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXIconList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_FXIconList_appendItem__SWIG_1(nargs, args, self);
+        }
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXIcon, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXIconList_appendItem__SWIG_1(nargs, args, self);
+          }
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXIconList_appendItem__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = 1;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_FXIconList_appendItem__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = (argv[5] == Qtrue || argv[5] == Qfalse) ? 1 : 0;
+              }
+              if (_v) {
+                return _wrap_FXIconList_appendItem__SWIG_1(nargs, args, self);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 7, "appendItem", 
+    "    FXint appendItem(FXIconItem *item, FXbool notify)\n"
+    "    FXint appendItem(FXString const &text, FXIcon *big, FXIcon *mini, void *ITEMDATA, FXbool notify)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_prependItem__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXIconItem *arg2 = (FXIconItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","prependItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconItem *","prependItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIconItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXint)FXIconList_prependItem__SWIG_0(arg1,arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_prependItem__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  void *arg5 = (void *) 0 ;
+  FXbool arg6 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","prependItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","prependItem", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 2) {
+    res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","prependItem", 4, argv[2] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 3) {
+    arg5 = (argv[3] == Qnil) ? NULL : (void *) argv[3];
+  }
+  if (argc > 4) {
+    arg6 = to_FXbool(argv[4]);
+  }
+  result = (FXint)(arg1)->prependItem((FXString const &)*arg2,arg3,arg4,arg5,arg6);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXIconList_prependItem(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[7];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 7) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 2) && (argc <= 3)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXIconList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIconItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_FXIconList_prependItem__SWIG_0(nargs, args, self);
+        }
+        {
+          _v = (argv[2] == Qtrue || argv[2] == Qfalse) ? 1 : 0;
+        }
+        if (_v) {
+          return _wrap_FXIconList_prependItem__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  if ((argc >= 2) && (argc <= 6)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXIconList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_FXIconList_prependItem__SWIG_1(nargs, args, self);
+        }
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXIcon, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXIconList_prependItem__SWIG_1(nargs, args, self);
+          }
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXIconList_prependItem__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = 1;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_FXIconList_prependItem__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = (argv[5] == Qtrue || argv[5] == Qfalse) ? 1 : 0;
+              }
+              if (_v) {
+                return _wrap_FXIconList_prependItem__SWIG_1(nargs, args, self);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 7, "prependItem", 
+    "    FXint prependItem(FXIconItem *item, FXbool notify)\n"
+    "    FXint prependItem(FXString const &text, FXIcon *big, FXIcon *mini, void *ITEMDATA, FXbool notify)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_moveItem(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","moveItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  result = (FXint)(arg1)->moveItem(arg2,arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_extractItem(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIconItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","extractItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  result = (FXIconItem *)(arg1)->extractItem(arg2,arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIconItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_removeItem(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","removeItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  FXIconList_removeItem(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_clearItems(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","clearItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXIconList_clearItems(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getItemWidth(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getItemWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (FXint)((FXIconList const *)arg1)->getItemWidth();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getItemHeight(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getItemHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (FXint)((FXIconList const *)arg1)->getItemHeight();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_findItem(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXString *arg2 = 0 ;
+  FXint arg3 = (FXint) -1 ;
+  FXuint arg4 = (FXuint) SEARCH_FORWARD|SEARCH_WRAP ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","findItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2UINT(argv[2]);
+  }
+  result = (FXint)((FXIconList const *)arg1)->findItem((FXString const &)*arg2,arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_findItemByData(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXint arg3 = (FXint) -1 ;
+  FXuint arg4 = (FXuint) SEARCH_FORWARD|SEARCH_WRAP ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","findItemByData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = (argv[0] == Qnil) ? NULL : (void *) argv[0];
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2UINT(argv[2]);
+  }
+  result = (FXint)((FXIconList const *)arg1)->findItemByData((void const *)arg2,arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_makeItemVisible__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXIconItem *arg2 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","makeItemVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconItem *","makeItemVisible", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIconItem * >(argp2);
+  FXIconList_makeItemVisible__SWIG_0(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setItemText(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setItemText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  (arg1)->setItemText(arg2,(FXString const &)*arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getItemText(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getItemText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  result = ((FXIconList const *)arg1)->getItemText(arg2);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setItemBigIcon(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setItemBigIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","setItemBigIcon", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXIcon * >(argp3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  (arg1)->setItemBigIcon(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getItemBigIcon(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getItemBigIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  result = (FXIcon *)((FXIconList const *)arg1)->getItemBigIcon(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setItemMiniIcon(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setItemMiniIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","setItemMiniIcon", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXIcon * >(argp3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  (arg1)->setItemMiniIcon(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getItemMiniIcon(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getItemMiniIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  result = (FXIcon *)((FXIconList const *)arg1)->getItemMiniIcon(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setItemData(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  VALUE arg3 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setItemData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = argv[1];
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  FXIconList_setItemData(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getItemData(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getItemData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  result = (VALUE)FXIconList_getItemData((FXIconList const *)arg1,arg2);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_isItemSelected(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","isItemSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  result = (FXbool)((FXIconList const *)arg1)->isItemSelected(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_isItemCurrent(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","isItemCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  result = (FXbool)((FXIconList const *)arg1)->isItemCurrent(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_isItemVisible(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","isItemVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  result = (FXbool)((FXIconList const *)arg1)->isItemVisible(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_isItemEnabled(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","isItemEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  result = (FXbool)((FXIconList const *)arg1)->isItemEnabled(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_hitItem(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 = (FXint) 1 ;
+  FXint arg6 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","hitItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  if (argc > 3) {
+    arg5 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg6 = NUM2INT(argv[4]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  result = (FXint)((FXIconList const *)arg1)->hitItem(arg2,arg3,arg4,arg5,arg6);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_updateItem(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","updateItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  ((FXIconList const *)arg1)->updateItem(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getCurrentItem(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getCurrentItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (FXint)((FXIconList const *)arg1)->getCurrentItem();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setAnchorItem(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setAnchorItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  (arg1)->setAnchorItem(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getAnchorItem(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getAnchorItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (FXint)((FXIconList const *)arg1)->getAnchorItem();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getCursorItem(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getCursorItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (FXint)((FXIconList const *)arg1)->getCursorItem();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_sortItems(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","sortItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  (arg1)->sortItems();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setFont(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  (arg1)->setFont(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getFont(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (FXFont *)((FXIconList const *)arg1)->getFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getTextColor(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (FXColor)((FXIconList const *)arg1)->getTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setTextColor(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (FXColor)((FXIconList const *)arg1)->getSelBackColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelBackColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (FXColor)((FXIconList const *)arg1)->getSelTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setItemSpace(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setItemSpace", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setItemSpace(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getItemSpace(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getItemSpace", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (FXint)((FXIconList const *)arg1)->getItemSpace();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getListStyle(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getListStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (FXuint)((FXIconList const *)arg1)->getListStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setListStyle(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setListStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setListStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (FXString *) &((FXIconList const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_save(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXIconList_save((FXIconList const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_load(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXIconList_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_create(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  FXIconList_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_detach(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  FXIconList_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_destroy(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  FXIconList_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_resize(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXIconList_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (FXint)FXIconList_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (FXint)FXIconList_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXIconList_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXIconList_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (bool)FXIconList_canFocus((FXIconList const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  FXIconList_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  FXIconList_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXIconList_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXIconList_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_enable(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  FXIconList_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_disable(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  FXIconList_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  FXIconList_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_lower(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  FXIconList_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_move(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXIconList_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXIconList_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_layout(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  FXIconList_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_recalc(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  FXIconList_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_reparent(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXIconList_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_show(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  FXIconList_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_hide(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  FXIconList_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (bool)FXIconList_isComposite((FXIconList const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_contains(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXIconList_contains((FXIconList const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (bool)FXIconList_doesSaveUnder((FXIconList const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXIconList_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_tr(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXIconList_tr((FXIconList const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  FXIconList_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  FXIconList_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXIconList_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXIconList_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXIconList_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXIconList_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXIconList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXIconList_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXIconList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXIconList_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXIconList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXIconList_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  FXIconList_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getViewportHeight(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","getViewportHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (FXint)FXIconList_getViewportHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getViewportWidth(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","getViewportWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (FXint)FXIconList_getViewportWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getContentHeight(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","getContentHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (FXint)FXIconList_getContentHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getContentWidth(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","getContentWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (FXint)FXIconList_getContentWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  result = (VALUE)FXIconList_position__SWIG_1((FXIconList const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXIconList_position(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXIconList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXIconList_position__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXIconList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXIconList_position__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "position", 
+    "    void position(FXint x, FXint y, FXint w, FXint h)\n"
+    "    VALUE position()\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_selectItem(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","selectItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  result = (FXbool)FXIconList_selectItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_deselectItem(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","deselectItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  result = (FXbool)FXIconList_deselectItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_toggleItem(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","toggleItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  result = (FXbool)FXIconList_toggleItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_selectInRectangle(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXbool arg6 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","selectInRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXbool(argv[4]);
+  }
+  result = (FXbool)FXIconList_selectInRectangle(arg1,arg2,arg3,arg4,arg5,arg6);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_extendSelection(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","extendSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  result = (FXbool)FXIconList_extendSelection(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_killSelection(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","killSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXIconList_killSelection(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_setCurrentItem(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","setCurrentItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  FXIconList_setCurrentItem(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_getItemAt(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList const *","getItemAt", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXint)FXIconList_getItemAt((FXIconList const *)arg1,arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_makeItemVisible__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","makeItemVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  FXIconList_makeItemVisible(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXIconList_makeItemVisible(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXIconList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIconItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXIconList_makeItemVisible__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXIconList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXIconList_makeItemVisible__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "makeItemVisible", 
+    "    void makeItemVisible(FXIconItem *item)\n"
+    "    void makeItemVisible(FXint index)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_enableItem(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","enableItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  result = (FXbool)FXIconList_enableItem(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconList_disableItem(int argc, VALUE *argv, VALUE self) {
+  FXIconList *arg1 = (FXIconList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconList *","disableItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "icon list item index out of bounds");
+    }
+  }
+  result = (FXbool)FXIconList_disableItem(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXFileItem;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXFileItem_allocate(VALUE self)
+#else
+_wrap_FXFileItem_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXFileItem);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXFileItem(int argc, VALUE *argv, VALUE self) {
+  FXString *arg1 = 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  void *arg4 = (void *) 0 ;
+  SwigValueWrapper< FXString > p1 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXFileItem *result = 0 ;
+  
+  if ((argc < 1) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  p1 = to_FXString(argv[0]); arg1 = &p1;
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","FXFileItem", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXIcon * >(argp2);
+  }
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","FXFileItem", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = (argv[3] == Qnil) ? NULL : (void *) argv[3];
+  }
+  {
+    result = (FXFileItem *)new_FXFileItem((FXString const &)*arg1,arg2,arg3,arg4);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_isFile(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem const *","isFile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  result = (FXbool)((FXFileItem const *)arg1)->isFile();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_isDirectory(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem const *","isDirectory", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  result = (FXbool)((FXFileItem const *)arg1)->isDirectory();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_isShare(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem const *","isShare", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  result = (FXbool)((FXFileItem const *)arg1)->isShare();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_isExecutable(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem const *","isExecutable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  result = (FXbool)((FXFileItem const *)arg1)->isExecutable();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_isSymlink(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem const *","isSymlink", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  result = (FXbool)((FXFileItem const *)arg1)->isSymlink();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_isChardev(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem const *","isChardev", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  result = (FXbool)((FXFileItem const *)arg1)->isChardev();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_isBlockdev(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem const *","isBlockdev", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  result = (FXbool)((FXFileItem const *)arg1)->isBlockdev();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_isFifo(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem const *","isFifo", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  result = (FXbool)((FXFileItem const *)arg1)->isFifo();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_isSocket(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem const *","isSocket", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  result = (FXbool)((FXFileItem const *)arg1)->isSocket();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_getAssoc(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFileAssoc *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem const *","getAssoc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  result = (FXFileAssoc *)((FXFileItem const *)arg1)->getAssoc();
+  vresult = FXRbGetRubyObj(result, "FXFileAssoc *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_getSize(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXlong result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem const *","getSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  result = ((FXFileItem const *)arg1)->getSize();
+  vresult = LONG2NUM(result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_getDate(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTime result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem const *","getDate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  result = (FXTime)((FXFileItem const *)arg1)->getDate();
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_save(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXFileItem_save((FXFileItem const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_load(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXFileItem_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_draw(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  FXIconList *arg2 = (FXIconList *) 0 ;
+  FXDC *arg3 = 0 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem const *","draw", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconList const *","draw", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIconList * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXDC,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXDC &","draw", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDC &","draw", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXDC * >(argp3);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXFileItem_draw((FXFileItem const *)arg1,(FXIconList const *)arg2,*arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_hitItem(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  FXIconList *arg2 = (FXIconList *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 = (FXint) 1 ;
+  FXint arg6 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem const *","hitItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconList const *","hitItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIconList * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  if (argc > 3) {
+    arg5 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg6 = NUM2INT(argv[4]);
+  }
+  result = (FXint)FXFileItem_hitItem((FXFileItem const *)arg1,(FXIconList const *)arg2,arg3,arg4,arg5,arg6);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_drawBigIcon(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  FXIconList *arg2 = (FXIconList *) 0 ;
+  FXDC *arg3 = 0 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem const *","drawBigIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconList const *","drawBigIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIconList * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXDC,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXDC &","drawBigIcon", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDC &","drawBigIcon", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXDC * >(argp3);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXFileItem_drawBigIcon((FXFileItem const *)arg1,(FXIconList const *)arg2,*arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_drawMiniIcon(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  FXIconList *arg2 = (FXIconList *) 0 ;
+  FXDC *arg3 = 0 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem const *","drawMiniIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconList const *","drawMiniIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIconList * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXDC,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXDC &","drawMiniIcon", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDC &","drawMiniIcon", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXDC * >(argp3);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXFileItem_drawMiniIcon((FXFileItem const *)arg1,(FXIconList const *)arg2,*arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_drawDetails(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  FXIconList *arg2 = (FXIconList *) 0 ;
+  FXDC *arg3 = 0 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem const *","drawDetails", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconList const *","drawDetails", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIconList * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXDC,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXDC &","drawDetails", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDC &","drawDetails", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXDC * >(argp3);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXFileItem_drawDetails((FXFileItem const *)arg1,(FXIconList const *)arg2,*arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_setText(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem *","setText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  FXFileItem_setText(arg1,(FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_setBigIcon(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem *","setBigIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setBigIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXFileItem_setBigIcon(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_setMiniIcon(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem *","setMiniIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setMiniIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXFileItem_setMiniIcon(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXFileItem_setFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_setSelected(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem *","setSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXFileItem_setSelected(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_setEnabled(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem *","setEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXFileItem_setEnabled(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_setDraggable(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem *","setDraggable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXFileItem_setDraggable(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_getWidth(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  FXIconList *arg2 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem const *","getWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconList const *","getWidth", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIconList * >(argp2);
+  result = (FXint)FXFileItem_getWidth((FXFileItem const *)arg1,(FXIconList const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_getHeight(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  FXIconList *arg2 = (FXIconList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem const *","getHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIconList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconList const *","getHeight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIconList * >(argp2);
+  result = (FXint)FXFileItem_getHeight((FXFileItem const *)arg1,(FXIconList const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_create(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  FXFileItem_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_detach(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  FXFileItem_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileItem_destroy(int argc, VALUE *argv, VALUE self) {
+  FXFileItem *arg1 = (FXFileItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileItem *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileItem * >(argp1);
+  FXFileItem_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXFileList;
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onOpenTimer(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onOpenTimer", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onOpenTimer", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onOpenTimer(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onRefreshTimer(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onRefreshTimer", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRefreshTimer", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onRefreshTimer(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onDNDEnter(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onDNDEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onDNDLeave(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onDNDLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onDNDMotion(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onDNDMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onDNDDrop(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onDNDDrop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDDrop", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDDrop(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onDNDRequest(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onDNDRequest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDRequest", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDRequest(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onBeginDrag(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onBeginDrag", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onBeginDrag", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onBeginDrag(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onEndDrag(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onEndDrag", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEndDrag", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEndDrag(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onDragged(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onDragged", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDragged", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDragged(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = static_cast<void*>(StringValuePtr(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onCmdGetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onCmdGetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdGetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onCmdSetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onCmdSetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onCmdDirectoryUp(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onCmdDirectoryUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDirectoryUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDirectoryUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onUpdDirectoryUp(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onUpdDirectoryUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdDirectoryUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdDirectoryUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onCmdSortByName(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onCmdSortByName", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSortByName", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSortByName(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onUpdSortByName(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onUpdSortByName", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSortByName", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdSortByName(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onCmdSortByType(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onCmdSortByType", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSortByType", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSortByType(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onUpdSortByType(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onUpdSortByType", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSortByType", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdSortByType(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onCmdSortBySize(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onCmdSortBySize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSortBySize", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSortBySize(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onUpdSortBySize(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onUpdSortBySize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSortBySize", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdSortBySize(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onCmdSortByTime(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onCmdSortByTime", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSortByTime", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSortByTime(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onUpdSortByTime(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onUpdSortByTime", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSortByTime", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdSortByTime(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onCmdSortByUser(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onCmdSortByUser", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSortByUser", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSortByUser(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onUpdSortByUser(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onUpdSortByUser", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSortByUser", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdSortByUser(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onCmdSortByGroup(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onCmdSortByGroup", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSortByGroup", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSortByGroup(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onUpdSortByGroup(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onUpdSortByGroup", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSortByGroup", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdSortByGroup(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onCmdSortReverse(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onCmdSortReverse", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSortReverse", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSortReverse(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onUpdSortReverse(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onUpdSortReverse", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSortReverse", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdSortReverse(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onCmdSortCase(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onCmdSortCase", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSortCase", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSortCase(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onUpdSortCase(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onUpdSortCase", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSortCase", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdSortCase(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onCmdSetPattern(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onCmdSetPattern", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetPattern", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = static_cast<void*>(StringValuePtr(argv[2]));
+  result = (long)(arg1)->onCmdSetPattern(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onUpdSetPattern(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onUpdSetPattern", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSetPattern", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdSetPattern(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onCmdSetDirectory(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onCmdSetDirectory", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetDirectory", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = static_cast<void*>(StringValuePtr(argv[2]));
+  result = (long)(arg1)->onCmdSetDirectory(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onUpdSetDirectory(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onUpdSetDirectory", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSetDirectory", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdSetDirectory(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onCmdToggleHidden(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onCmdToggleHidden", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdToggleHidden", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdToggleHidden(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onUpdToggleHidden(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onUpdToggleHidden", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdToggleHidden", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdToggleHidden(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onCmdShowHidden(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onCmdShowHidden", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdShowHidden", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdShowHidden(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onUpdShowHidden(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onUpdShowHidden", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdShowHidden", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdShowHidden(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onCmdHideHidden(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onCmdHideHidden", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdHideHidden", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdHideHidden(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onUpdHideHidden(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onUpdHideHidden", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdHideHidden", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdHideHidden(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onCmdToggleImages(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onCmdToggleImages", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdToggleImages", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdToggleImages(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onUpdToggleImages(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onUpdToggleImages", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdToggleImages", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdToggleImages(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onCmdHeader(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onCmdHeader", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdHeader", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2UINT(argv[2]));
+  result = (long)(arg1)->onCmdHeader(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onUpdHeader(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onUpdHeader", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdHeader", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdHeader(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_onCmdRefresh(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","onCmdRefresh", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdRefresh", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdRefresh(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_ascending(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconItem *arg2 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::ascending", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::ascending", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXIconItem * >(argp2);
+  result = (FXint)FXFileList::ascending((FXIconItem const *)arg1,(FXIconItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_descending(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconItem *arg2 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::descending", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::descending", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXIconItem * >(argp2);
+  result = (FXint)FXFileList::descending((FXIconItem const *)arg1,(FXIconItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_ascendingCase(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconItem *arg2 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::ascendingCase", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::ascendingCase", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXIconItem * >(argp2);
+  result = (FXint)FXFileList::ascendingCase((FXIconItem const *)arg1,(FXIconItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_descendingCase(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconItem *arg2 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::descendingCase", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::descendingCase", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXIconItem * >(argp2);
+  result = (FXint)FXFileList::descendingCase((FXIconItem const *)arg1,(FXIconItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_ascendingType(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconItem *arg2 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::ascendingType", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::ascendingType", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXIconItem * >(argp2);
+  result = (FXint)FXFileList::ascendingType((FXIconItem const *)arg1,(FXIconItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_descendingType(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconItem *arg2 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::descendingType", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::descendingType", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXIconItem * >(argp2);
+  result = (FXint)FXFileList::descendingType((FXIconItem const *)arg1,(FXIconItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_ascendingSize(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconItem *arg2 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::ascendingSize", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::ascendingSize", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXIconItem * >(argp2);
+  result = (FXint)FXFileList::ascendingSize((FXIconItem const *)arg1,(FXIconItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_descendingSize(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconItem *arg2 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::descendingSize", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::descendingSize", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXIconItem * >(argp2);
+  result = (FXint)FXFileList::descendingSize((FXIconItem const *)arg1,(FXIconItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_ascendingTime(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconItem *arg2 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::ascendingTime", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::ascendingTime", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXIconItem * >(argp2);
+  result = (FXint)FXFileList::ascendingTime((FXIconItem const *)arg1,(FXIconItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_descendingTime(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconItem *arg2 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::descendingTime", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::descendingTime", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXIconItem * >(argp2);
+  result = (FXint)FXFileList::descendingTime((FXIconItem const *)arg1,(FXIconItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_ascendingUser(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconItem *arg2 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::ascendingUser", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::ascendingUser", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXIconItem * >(argp2);
+  result = (FXint)FXFileList::ascendingUser((FXIconItem const *)arg1,(FXIconItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_descendingUser(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconItem *arg2 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::descendingUser", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::descendingUser", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXIconItem * >(argp2);
+  result = (FXint)FXFileList::descendingUser((FXIconItem const *)arg1,(FXIconItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_ascendingGroup(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconItem *arg2 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::ascendingGroup", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::ascendingGroup", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXIconItem * >(argp2);
+  result = (FXint)FXFileList::ascendingGroup((FXIconItem const *)arg1,(FXIconItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_descendingGroup(int argc, VALUE *argv, VALUE self) {
+  FXIconItem *arg1 = (FXIconItem *) 0 ;
+  FXIconItem *arg2 = (FXIconItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::descendingGroup", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXIconItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIconItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIconItem const *","FXFileList::descendingGroup", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXIconItem * >(argp2);
+  result = (FXint)FXFileList::descendingGroup((FXIconItem const *)arg1,(FXIconItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXFileList_allocate(VALUE self)
+#else
+_wrap_FXFileList_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXFileList);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXFileList(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXFileList *result = 0 ;
+  
+  if ((argc < 1) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXFileList", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXFileList", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXFileList *)new_FXFileList(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_scan(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","scan", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->scan(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_setCurrentFile(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXString *arg2 = 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","setCurrentFile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setCurrentFile((FXString const &)*arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_getCurrentFile(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","getCurrentFile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  result = ((FXFileList const *)arg1)->getCurrentFile();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_setDirectory(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","setDirectory", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setDirectory((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_getDirectory(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","getDirectory", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  result = ((FXFileList const *)arg1)->getDirectory();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_setPattern(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","setPattern", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setPattern((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_getPattern(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","getPattern", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  result = ((FXFileList const *)arg1)->getPattern();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_isItemDirectory(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","isItemDirectory", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "file list item index out of bounds");
+    }
+  }
+  result = (FXbool)((FXFileList const *)arg1)->isItemDirectory(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_isItemShare(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","isItemShare", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "file list item index out of bounds");
+    }
+  }
+  result = (FXbool)((FXFileList const *)arg1)->isItemShare(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_isItemFile(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","isItemFile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "file list item index out of bounds");
+    }
+  }
+  result = (FXbool)((FXFileList const *)arg1)->isItemFile(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_isItemExecutable(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","isItemExecutable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "file list item index out of bounds");
+    }
+  }
+  result = (FXbool)((FXFileList const *)arg1)->isItemExecutable(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_getItemFilename(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","getItemFilename", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "file list item index out of bounds");
+    }
+  }
+  result = ((FXFileList const *)arg1)->getItemFilename(arg2);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_getItemPathname(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","getItemPathname", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "file list item index out of bounds");
+    }
+  }
+  result = ((FXFileList const *)arg1)->getItemPathname(arg2);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_getItemAssoc(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFileAssoc *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","getItemAssoc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "file list item index out of bounds");
+    }
+  }
+  result = (FXFileAssoc *)((FXFileList const *)arg1)->getItemAssoc(arg2);
+  vresult = FXRbGetRubyObj(result, "FXFileAssoc *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_getMatchMode(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","getMatchMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  result = (FXuint)((FXFileList const *)arg1)->getMatchMode();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_setMatchMode(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","setMatchMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setMatchMode(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_getHiddenFilesShown(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","showHiddenFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  result = (FXbool)((FXFileList const *)arg1)->showHiddenFiles();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_setHiddenFilesShown(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","showHiddenFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->showHiddenFiles(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_getOnlyDirectoriesShown(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","showOnlyDirectories", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  result = (FXbool)((FXFileList const *)arg1)->showOnlyDirectories();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_setOnlyDirectoriesShown(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","showOnlyDirectories", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->showOnlyDirectories(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_showOnlyFiles__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","showOnlyFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  result = (FXbool)((FXFileList const *)arg1)->showOnlyFiles();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_showOnlyFiles__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","showOnlyFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->showOnlyFiles(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXFileList_showOnlyFiles(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFileList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXFileList_showOnlyFiles__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFileList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (argv[1] == Qtrue || argv[1] == Qfalse) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXFileList_showOnlyFiles__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "FXFileList.showOnlyFiles", 
+    "    FXbool FXFileList.showOnlyFiles()\n"
+    "    void FXFileList.showOnlyFiles(FXbool shown)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_getShowImages(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","showImages", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  result = (FXbool)((FXFileList const *)arg1)->showImages();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_setShowImages(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","showImages", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->showImages(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_getImageSize(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","getImageSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  result = (FXint)((FXFileList const *)arg1)->getImageSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_setImageSize(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","setImageSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setImageSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_parentDirsShownq___(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","showParents", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  result = (FXbool)((FXFileList const *)arg1)->showParents();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_parentDirsShowne___(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","showParents", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->showParents(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_setAssociations(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXFileDict *arg2 = (FXFileDict *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","setAssociations", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFileDict, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFileDict *","setAssociations", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFileDict * >(argp2);
+  (arg1)->setAssociations(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_getAssociations(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFileDict *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","getAssociations", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  result = (FXFileDict *)((FXFileList const *)arg1)->getAssociations();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFileDict, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_save(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXFileList_save((FXFileList const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_load(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXFileList_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_create(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  FXFileList_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_detach(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  FXFileList_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_destroy(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  FXFileList_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_resize(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXFileList_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  result = (FXint)FXFileList_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  result = (FXint)FXFileList_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXFileList_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXFileList_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  result = (bool)FXFileList_canFocus((FXFileList const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  FXFileList_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  FXFileList_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXFileList_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXFileList_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_enable(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  FXFileList_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_disable(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  FXFileList_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  FXFileList_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_lower(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  FXFileList_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_move(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXFileList_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXFileList_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_layout(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  FXFileList_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_recalc(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  FXFileList_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_reparent(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXFileList_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_show(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  FXFileList_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_hide(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  FXFileList_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  result = (bool)FXFileList_isComposite((FXFileList const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_contains(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXFileList_contains((FXFileList const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  result = (bool)FXFileList_doesSaveUnder((FXFileList const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXFileList_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_tr(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXFileList_tr((FXFileList const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  FXFileList_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  FXFileList_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXFileList_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXFileList_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXFileList_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXFileList_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFileList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXFileList_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFileList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXFileList_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFileList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXFileList_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  FXFileList_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_getViewportHeight(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","getViewportHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  result = (FXint)FXFileList_getViewportHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_getViewportWidth(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","getViewportWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  result = (FXint)FXFileList_getViewportWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_getContentHeight(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","getContentHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  result = (FXint)FXFileList_getContentHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_getContentWidth(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","getContentWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  result = (FXint)FXFileList_getContentWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  result = (VALUE)FXFileList_position__SWIG_1((FXFileList const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXFileList_position(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFileList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXFileList_position__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFileList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXFileList_position__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "position", 
+    "    void position(FXint x, FXint y, FXint w, FXint h)\n"
+    "    VALUE position()\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_selectItem(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","selectItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "file list item index out of bounds");
+    }
+  }
+  result = (FXbool)FXFileList_selectItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_deselectItem(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","deselectItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "file list item index out of bounds");
+    }
+  }
+  result = (FXbool)FXFileList_deselectItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_toggleItem(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","toggleItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "file list item index out of bounds");
+    }
+  }
+  result = (FXbool)FXFileList_toggleItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_selectInRectangle(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXbool arg6 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","selectInRectangle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXbool(argv[4]);
+  }
+  result = (FXbool)FXFileList_selectInRectangle(arg1,arg2,arg3,arg4,arg5,arg6);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_extendSelection(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","extendSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "file list item index out of bounds");
+    }
+  }
+  result = (FXbool)FXFileList_extendSelection(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_killSelection(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","killSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXFileList_killSelection(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_setCurrentItem(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","setCurrentItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "file list item index out of bounds");
+    }
+  }
+  FXFileList_setCurrentItem(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_getItemAt(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList const *","getItemAt", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXint)FXFileList_getItemAt((FXFileList const *)arg1,arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_makeItemVisible(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","makeItemVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "file list item index out of bounds");
+    }
+  }
+  FXFileList_makeItemVisible(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_enableItem(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","enableItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "file list item index out of bounds");
+    }
+  }
+  result = (FXbool)FXFileList_enableItem(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileList_disableItem(int argc, VALUE *argv, VALUE self) {
+  FXFileList *arg1 = (FXFileList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileList *","disableItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "file list item index out of bounds");
+    }
+  }
+  result = (FXbool)FXFileList_disableItem(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_FXFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FXDockSiteTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXPopupTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXShutterItemTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXStatusBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXMainWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXCompositeTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXCursor *) x));
+}
+static void *_p_FXDrawableTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXDrawable *) x));
+}
+static void *_p_FXSplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXIconListTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXIconList *) x));
+}
+static void *_p_FXFontTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXFont *) x));
+}
+static void *_p_FXPackerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXShutterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXFileListTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *)(FXIconList *) ((FXFileList *) x));
+}
+static void *_p_FXVisualTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXVisual *) x));
+}
+static void *_p_FXMatrixTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXSpringTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXSwitcherTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXIconListTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXIconList *) x));
+}
+static void *_p_FXSettingsTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXSettings *) x));
+}
+static void *_p_FXAccelTableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXAccelTable *) x));
+}
+static void *_p_FXCompositeTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXRegistryTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *)(FXSettings *) ((FXRegistry *) x));
+}
+static void *_p_FXIconDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXIconDict *) x));
+}
+static void *_p_FXShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXPopupTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXStatusBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXRecentFilesTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXRecentFiles *) x));
+}
+static void *_p_FXDocumentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDocument *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXIconItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXIconItem *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXSplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXFileListTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *)(FXIconList *) ((FXFileList *) x));
+}
+static void *_p_FXStringDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXStringDict *) x));
+}
+static void *_p_FXPackerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXFontTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXFont *) x));
+}
+static void *_p_FXFileDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXFileDict *) x));
+}
+static void *_p_FXDataTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDataTarget *) x));
+}
+static void *_p_FXDebugTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDebugTarget *) x));
+}
+static void *_p_FXSwitcherTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXShutterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXDelegatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDelegator *) x));
+}
+static void *_p_FXDrawableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXDrawable *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXCursor *) x));
+}
+static void *_p_FXFileItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXIconItem *) ((FXFileItem *) x));
+}
+static void *_p_FXTranslatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXTranslator *) x));
+}
+static void *_p_FXDockSiteTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDict *) x));
+}
+static void *_p_FXMatrixTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXShutterItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXIdTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXId *) x));
+}
+static void *_p_FXFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FXSpringTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXVisualTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXVisual *) x));
+}
+static void *_p_FXAppTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXApp *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXScrollWindow *) x));
+}
+static void *_p_FXIconListTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXIconList *) x));
+}
+static void *_p_FXFileListTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *) (FXIconList *) ((FXFileList *) x));
+}
+static void *_p_FXDockSiteTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXFrame *) x));
+}
+static void *_p_FXPopupTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXShutterItemTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXStatusBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXCompositeTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXComposite *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXSplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXIconListTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXIconList *) x));
+}
+static void *_p_FXPackerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXShutterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXFileListTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *)(FXIconList *) ((FXFileList *) x));
+}
+static void *_p_FXMatrixTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXSpringTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXSwitcherTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXDockSiteTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXPopupTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXShutterItemTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXScrollArea *) x));
+}
+static void *_p_FXStatusBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXRootWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXShell *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXSplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FX4Splitter *) x));
+}
+static void *_p_FXIconListTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXIconList *) x));
+}
+static void *_p_FXPackerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXPacker *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXShutterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXFileListTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *)(FXIconList *) ((FXFileList *) x));
+}
+static void *_p_FXMatrixTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXSpringTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXSwitcherTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXDockSiteTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FXPopupTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXShutterItemTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXStatusBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *)  ((FXWindow *) x));
+}
+static void *_p_FXCompositeTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXSplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXIconListTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXIconList *) x));
+}
+static void *_p_FXPackerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXShutterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXFileListTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *)(FXIconList *) ((FXFileList *) x));
+}
+static void *_p_FXMatrixTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXSpringTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXSwitcherTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXFileListTo_p_FXIconList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXIconList *)  ((FXFileList *) x));
+}
+static void *_p_FXFileStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXFileStream *) x));
+}
+static void *_p_FXMemoryStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXMemoryStream *) x));
+}
+static void *_p_FXFileItemTo_p_FXIconItem(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXIconItem *)  ((FXFileItem *) x));
+}
+static swig_type_info _swigt__p_FXBitmap = {"_p_FXBitmap", "FXBitmap *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXComposite = {"_p_FXComposite", "FXComposite *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDockSite = {"_p_FXDockSite", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPopup = {"_p_FXPopup", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutterItem = {"_p_FXShutterItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusBar = {"_p_FXStatusBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplashWindow = {"_p_FXSplashWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMainWindow = {"_p_FXMainWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTopWindow = {"_p_FXTopWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRootWindow = {"_p_FXRootWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollWindow = {"_p_FXScrollWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShell = {"_p_FXShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGroupBox = {"_p_FXGroupBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplitter = {"_p_FXSplitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FX4Splitter = {"_p_FX4Splitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPacker = {"_p_FXPacker", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalFrame = {"_p_FXVerticalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalFrame = {"_p_FXHorizontalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutter = {"_p_FXShutter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMatrix = {"_p_FXMatrix", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSpring = {"_p_FXSpring", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSwitcher = {"_p_FXSwitcher", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDC = {"_p_FXDC", "FXDC *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDrawable = {"_p_FXDrawable", "FXDrawable *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFrame = {"_p_FXFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileDict = {"_p_FXFileDict", "FXFileDict *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFileItem = {"_p_FXFileItem", "FXFileItem *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFileList = {"_p_FXFileList", "FXFileList *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFont = {"_p_FXFont", "FXFont *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXHeader = {"_p_FXHeader", "FXHeader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXIcon = {"_p_FXIcon", "FXIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXIconItem = {"_p_FXIconItem", "FXIconItem *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXIconList = {"_p_FXIconList", "FXIconList *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXId = {"_p_FXId", "FXId *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGIFCursor = {"_p_FXGIFCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCURCursor = {"_p_FXCURCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCursor = {"_p_FXCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVisual = {"_p_FXVisual", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXObject = {"_p_FXObject", "FXObject *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDict = {"_p_FXDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSettings = {"_p_FXSettings", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXAccelTable = {"_p_FXAccelTable", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRegistry = {"_p_FXRegistry", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXIconDict = {"_p_FXIconDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRecentFiles = {"_p_FXRecentFiles", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDocument = {"_p_FXDocument", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStringDict = {"_p_FXStringDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDebugTarget = {"_p_FXDebugTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDataTarget = {"_p_FXDataTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDelegator = {"_p_FXDelegator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTranslator = {"_p_FXTranslator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXApp = {"_p_FXApp", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRegion = {"_p_FXRegion", "FXRegion *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXScrollArea = {"_p_FXScrollArea", "FXScrollArea *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXStream = {"_p_FXStream", "FXStream *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFileStream = {"_p_FXFileStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMemoryStream = {"_p_FXMemoryStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXWindow = {"_p_FXWindow", "FXWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_char = {"_p_char", "char *|FXchar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "double *|FXdouble *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_float = {"_p_float", "float *|FXfloat *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "FXint *|int *|FXInputHandle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_long = {"_p_long", "long *|FXTime *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_short = {"_p_short", "short *|FXshort *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "FXuchar *|unsigned char *|FXbool *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "FXwchar *|FXDragType *|unsigned int *|FXuint *|FXColor *|FXSelector *|FXHotKey *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|FXuval *|FXPixel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|FXushort *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_FX4Splitter,
+  &_swigt__p_FXAccelTable,
+  &_swigt__p_FXApp,
+  &_swigt__p_FXBitmap,
+  &_swigt__p_FXCURCursor,
+  &_swigt__p_FXComposite,
+  &_swigt__p_FXCursor,
+  &_swigt__p_FXDC,
+  &_swigt__p_FXDataTarget,
+  &_swigt__p_FXDebugTarget,
+  &_swigt__p_FXDelegator,
+  &_swigt__p_FXDict,
+  &_swigt__p_FXDockSite,
+  &_swigt__p_FXDocument,
+  &_swigt__p_FXDrawable,
+  &_swigt__p_FXFileDict,
+  &_swigt__p_FXFileItem,
+  &_swigt__p_FXFileList,
+  &_swigt__p_FXFileStream,
+  &_swigt__p_FXFont,
+  &_swigt__p_FXFrame,
+  &_swigt__p_FXGIFCursor,
+  &_swigt__p_FXGroupBox,
+  &_swigt__p_FXHeader,
+  &_swigt__p_FXHorizontalFrame,
+  &_swigt__p_FXIcon,
+  &_swigt__p_FXIconDict,
+  &_swigt__p_FXIconItem,
+  &_swigt__p_FXIconList,
+  &_swigt__p_FXId,
+  &_swigt__p_FXMainWindow,
+  &_swigt__p_FXMatrix,
+  &_swigt__p_FXMemoryStream,
+  &_swigt__p_FXObject,
+  &_swigt__p_FXPacker,
+  &_swigt__p_FXPopup,
+  &_swigt__p_FXRecentFiles,
+  &_swigt__p_FXRegion,
+  &_swigt__p_FXRegistry,
+  &_swigt__p_FXRootWindow,
+  &_swigt__p_FXScrollArea,
+  &_swigt__p_FXScrollWindow,
+  &_swigt__p_FXSettings,
+  &_swigt__p_FXShell,
+  &_swigt__p_FXShutter,
+  &_swigt__p_FXShutterItem,
+  &_swigt__p_FXSplashWindow,
+  &_swigt__p_FXSplitter,
+  &_swigt__p_FXSpring,
+  &_swigt__p_FXStatusBar,
+  &_swigt__p_FXStream,
+  &_swigt__p_FXStringDict,
+  &_swigt__p_FXSwitcher,
+  &_swigt__p_FXTopWindow,
+  &_swigt__p_FXTranslator,
+  &_swigt__p_FXVerticalFrame,
+  &_swigt__p_FXVisual,
+  &_swigt__p_FXWindow,
+  &_swigt__p_char,
+  &_swigt__p_double,
+  &_swigt__p_float,
+  &_swigt__p_int,
+  &_swigt__p_long,
+  &_swigt__p_short,
+  &_swigt__p_unsigned_char,
+  &_swigt__p_unsigned_int,
+  &_swigt__p_unsigned_long,
+  &_swigt__p_unsigned_short,
+};
+
+static swig_cast_info _swigc__p_FXBitmap[] = {  {&_swigt__p_FXBitmap, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockSite[] = {{&_swigt__p_FXDockSite, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPopup[] = {{&_swigt__p_FXPopup, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutterItem[] = {{&_swigt__p_FXShutterItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusBar[] = {{&_swigt__p_FXStatusBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplashWindow[] = {{&_swigt__p_FXSplashWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMainWindow[] = {{&_swigt__p_FXMainWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTopWindow[] = {{&_swigt__p_FXTopWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRootWindow[] = {{&_swigt__p_FXRootWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollWindow[] = {{&_swigt__p_FXScrollWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShell[] = {{&_swigt__p_FXShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGroupBox[] = {{&_swigt__p_FXGroupBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplitter[] = {{&_swigt__p_FXSplitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FX4Splitter[] = {{&_swigt__p_FX4Splitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPacker[] = {{&_swigt__p_FXPacker, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalFrame[] = {{&_swigt__p_FXVerticalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalFrame[] = {{&_swigt__p_FXHorizontalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutter[] = {{&_swigt__p_FXShutter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMatrix[] = {{&_swigt__p_FXMatrix, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpring[] = {{&_swigt__p_FXSpring, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSwitcher[] = {{&_swigt__p_FXSwitcher, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComposite[] = {  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXComposite, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXComposite, 0, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXComposite, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXIconList, _p_FXIconListTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXFileList, _p_FXFileListTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXComposite, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDC[] = {  {&_swigt__p_FXDC, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFrame[] = {{&_swigt__p_FXFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDrawable[] = {  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDrawable, 0, 0, 0},  {&_swigt__p_FXIconList, _p_FXIconListTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFileList, _p_FXFileListTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXDrawable, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileDict[] = {  {&_swigt__p_FXFileDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileItem[] = {  {&_swigt__p_FXFileItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileList[] = {  {&_swigt__p_FXFileList, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFont[] = {  {&_swigt__p_FXFont, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeader[] = {  {&_swigt__p_FXHeader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIcon[] = {  {&_swigt__p_FXIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIconItem[] = {  {&_swigt__p_FXIconItem, 0, 0, 0},  {&_swigt__p_FXFileItem, _p_FXFileItemTo_p_FXIconItem, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIconList[] = {  {&_swigt__p_FXIconList, 0, 0, 0},  {&_swigt__p_FXFileList, _p_FXFileListTo_p_FXIconList, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGIFCursor[] = {{&_swigt__p_FXGIFCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCURCursor[] = {{&_swigt__p_FXCURCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCursor[] = {{&_swigt__p_FXCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVisual[] = {{&_swigt__p_FXVisual, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXId[] = {  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXId, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXId, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXId, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXId, 0, 0},  {&_swigt__p_FXId, 0, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXId, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXId, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXIconList, _p_FXIconListTo_p_FXId, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXId, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXId, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXId, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXId, 0, 0},  {&_swigt__p_FXFileList, _p_FXFileListTo_p_FXId, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXId, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXId, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXId, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXId, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDict[] = {{&_swigt__p_FXDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSettings[] = {{&_swigt__p_FXSettings, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXAccelTable[] = {{&_swigt__p_FXAccelTable, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegistry[] = {{&_swigt__p_FXRegistry, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIconDict[] = {{&_swigt__p_FXIconDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRecentFiles[] = {{&_swigt__p_FXRecentFiles, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDocument[] = {{&_swigt__p_FXDocument, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStringDict[] = {{&_swigt__p_FXStringDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDebugTarget[] = {{&_swigt__p_FXDebugTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDataTarget[] = {{&_swigt__p_FXDataTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDelegator[] = {{&_swigt__p_FXDelegator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTranslator[] = {{&_swigt__p_FXTranslator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXApp[] = {{&_swigt__p_FXApp, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXObject[] = {  {&_swigt__p_FXIconList, _p_FXIconListTo_p_FXObject, 0, 0},  {&_swigt__p_FXDict, _p_FXDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXSettings, _p_FXSettingsTo_p_FXObject, 0, 0},  {&_swigt__p_FXAccelTable, _p_FXAccelTableTo_p_FXObject, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXObject, 0, 0},  {&_swigt__p_FXRegistry, _p_FXRegistryTo_p_FXObject, 0, 0},  {&_swigt__p_FXId, _p_FXIdTo_p_FXObject, 0, 0},  {&_swigt__p_FXIconDict, _p_FXIconDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXObject, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXObject, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXRecentFiles, _p_FXRecentFilesTo_p_FXObject, 0, 0},  {&_swigt__p_FXDocument, _p_FXDocumentTo_p_FXObject, 0, 0},  {&_swigt__p_FXIconItem, _p_FXIconItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileList, _p_FXFileListTo_p_FXObject, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FXObject, 0, 0, 0},  {&_swigt__p_FXStringDict, _p_FXStringDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileDict, _p_FXFileDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXObject, 0, 0},  {&_swigt__p_FXDebugTarget, _p_FXDebugTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDataTarget, _p_FXDataTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXObject, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileItem, _p_FXFileItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXDelegator, _p_FXDelegatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXObject, 0, 0},  {&_swigt__p_FXTranslator, _p_FXTranslatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXApp, _p_FXAppTo_p_FXObject, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXObject, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXObject, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXObject, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegion[] = {  {&_swigt__p_FXRegion, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollArea[] = {  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXScrollArea, 0, 0},  {&_swigt__p_FXIconList, _p_FXIconListTo_p_FXScrollArea, 0, 0},  {&_swigt__p_FXFileList, _p_FXFileListTo_p_FXScrollArea, 0, 0},  {&_swigt__p_FXScrollArea, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileStream[] = {{&_swigt__p_FXFileStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMemoryStream[] = {{&_swigt__p_FXMemoryStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStream[] = {  {&_swigt__p_FXFileStream, _p_FXFileStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXMemoryStream, _p_FXMemoryStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXWindow[] = {  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXWindow, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXWindow, 0, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXIconList, _p_FXIconListTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFileList, _p_FXFileListTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXWindow, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
+
+static swig_cast_info *swig_cast_initial[] = {
+  _swigc__p_FX4Splitter,
+  _swigc__p_FXAccelTable,
+  _swigc__p_FXApp,
+  _swigc__p_FXBitmap,
+  _swigc__p_FXCURCursor,
+  _swigc__p_FXComposite,
+  _swigc__p_FXCursor,
+  _swigc__p_FXDC,
+  _swigc__p_FXDataTarget,
+  _swigc__p_FXDebugTarget,
+  _swigc__p_FXDelegator,
+  _swigc__p_FXDict,
+  _swigc__p_FXDockSite,
+  _swigc__p_FXDocument,
+  _swigc__p_FXDrawable,
+  _swigc__p_FXFileDict,
+  _swigc__p_FXFileItem,
+  _swigc__p_FXFileList,
+  _swigc__p_FXFileStream,
+  _swigc__p_FXFont,
+  _swigc__p_FXFrame,
+  _swigc__p_FXGIFCursor,
+  _swigc__p_FXGroupBox,
+  _swigc__p_FXHeader,
+  _swigc__p_FXHorizontalFrame,
+  _swigc__p_FXIcon,
+  _swigc__p_FXIconDict,
+  _swigc__p_FXIconItem,
+  _swigc__p_FXIconList,
+  _swigc__p_FXId,
+  _swigc__p_FXMainWindow,
+  _swigc__p_FXMatrix,
+  _swigc__p_FXMemoryStream,
+  _swigc__p_FXObject,
+  _swigc__p_FXPacker,
+  _swigc__p_FXPopup,
+  _swigc__p_FXRecentFiles,
+  _swigc__p_FXRegion,
+  _swigc__p_FXRegistry,
+  _swigc__p_FXRootWindow,
+  _swigc__p_FXScrollArea,
+  _swigc__p_FXScrollWindow,
+  _swigc__p_FXSettings,
+  _swigc__p_FXShell,
+  _swigc__p_FXShutter,
+  _swigc__p_FXShutterItem,
+  _swigc__p_FXSplashWindow,
+  _swigc__p_FXSplitter,
+  _swigc__p_FXSpring,
+  _swigc__p_FXStatusBar,
+  _swigc__p_FXStream,
+  _swigc__p_FXStringDict,
+  _swigc__p_FXSwitcher,
+  _swigc__p_FXTopWindow,
+  _swigc__p_FXTranslator,
+  _swigc__p_FXVerticalFrame,
+  _swigc__p_FXVisual,
+  _swigc__p_FXWindow,
+  _swigc__p_char,
+  _swigc__p_double,
+  _swigc__p_float,
+  _swigc__p_int,
+  _swigc__p_long,
+  _swigc__p_short,
+  _swigc__p_unsigned_char,
+  _swigc__p_unsigned_int,
+  _swigc__p_unsigned_long,
+  _swigc__p_unsigned_short,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned statically to an initial
+ * array. We just loop through that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded.
+ * There are three cases to handle:
+ *  1) If the cast->type has already been loaded AND the type we are adding
+ *     casting info to has not been loaded (it is in this module), THEN we
+ *     replace the cast->type pointer with the type pointer that has already
+ *     been loaded.
+ *  2) If BOTH types (the one we are adding casting info to, and the
+ *     cast->type) are loaded, THEN the cast info has already been loaded by
+ *     the previous module so we just ignore it.
+ *  3) Finally, if cast->type has not already been loaded, then we add that
+ *     swig_cast_info to the linked list (because the cast->type) pointer will
+ *     be correct.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* c-mode */
+#endif
+#endif
+
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+  size_t i;
+  swig_module_info *module_head, *iter;
+  int init;
+
+  /* check to see if the circular list has been setup, if not, set it up */
+  if (swig_module.next==0) {
+    /* Initialize the swig_module */
+    swig_module.type_initial = swig_type_initial;
+    swig_module.cast_initial = swig_cast_initial;
+    swig_module.next = &swig_module;
+    init = 1;
+  } else {
+    init = 0;
+  }
+
+  /* Try and load any already created modules */
+  module_head = SWIG_GetModule(clientdata);
+  if (!module_head) {
+    /* This is the first module loaded for this interpreter */
+    /* so set the swig module into the interpreter */
+    SWIG_SetModule(clientdata, &swig_module);
+  } else {
+    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+    iter=module_head;
+    do {
+      if (iter==&swig_module) {
+        /* Our module is already in the list, so there's nothing more to do. */
+        return;
+      }
+      iter=iter->next;
+    } while (iter!= module_head);
+
+    /* otherwise we must add our module into the list */
+    swig_module.next = module_head->next;
+    module_head->next = &swig_module;
+  }
+
+  /* When multiple interpreters are used, a module could have already been initialized in
+     a different interpreter, but not yet have a pointer in this interpreter.
+     In this case, we do not want to continue adding types... everything should be
+     set up already */
+  if (init == 0) return;
+
+  /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+  for (i = 0; i < swig_module.size; ++i) {
+    swig_type_info *type = 0;
+    swig_type_info *ret;
+    swig_cast_info *cast;
+
+#ifdef SWIGRUNTIME_DEBUG
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+
+    /* if there is another module already loaded */
+    if (swig_module.next != &swig_module) {
+      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
+    }
+    if (type) {
+      /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+      if (swig_module.type_initial[i]->clientdata) {
+	type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+      }
+    } else {
+      type = swig_module.type_initial[i];
+    }
+
+    /* Insert casting types */
+    cast = swig_module.cast_initial[i];
+    while (cast->type) {
+
+      /* Don't need to add information already in the list */
+      ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+      if (swig_module.next != &swig_module) {
+        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+      }
+      if (ret) {
+	if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+	  cast->type = ret;
+	  ret = 0;
+	} else {
+	  /* Check for casting already in the list */
+	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+	  if (!ocast) ret = 0;
+	}
+      }
+
+      if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+        if (type->cast) {
+          type->cast->prev = cast;
+          cast->next = type->cast;
+        }
+        type->cast = cast;
+      }
+      cast++;
+    }
+    /* Set entry in modules->types array equal to the type */
+    swig_module.types[i] = type;
+  }
+  swig_module.types[i] = 0;
+
+#ifdef SWIGRUNTIME_DEBUG
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+  for (i = 0; i < swig_module.size; ++i) {
+    int j = 0;
+    swig_cast_info *cast = swig_module.cast_initial[i];
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    while (cast->type) {
+      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+      cast++;
+      ++j;
+    }
+  printf("---- Total casts: %d\n",j);
+  }
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types.  It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+  size_t i;
+  swig_cast_info *equiv;
+  static int init_run = 0;
+
+  if (init_run) return;
+  init_run = 1;
+
+  for (i = 0; i < swig_module.size; i++) {
+    if (swig_module.types[i]->clientdata) {
+      equiv = swig_module.types[i]->cast;
+      while (equiv) {
+        if (!equiv->converter) {
+          if (equiv->type && !equiv->type->clientdata)
+            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+        }
+        equiv = equiv->next;
+      }
+    }
+  }
+}
+
+#ifdef __cplusplus
+#if 0
+{ /* c-mode */
+#endif
+}
+#endif
+
+/*
+
+*/
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void Init_iconlist(void) {
+  size_t i;
+  
+  SWIG_InitRuntime();
+  
+  
+  SWIG_InitializeModule(0);
+  for (i = 0; i < swig_module.size; i++) {
+    SWIG_define_class(swig_module.types[i]);
+  }
+  
+  SWIG_RubyInitializeTrackings();
+  
+  
+  rb_define_const(mFox, "ICONLIST_EXTENDEDSELECT", SWIG_From_int(static_cast< int >(ICONLIST_EXTENDEDSELECT)));
+  rb_define_const(mFox, "ICONLIST_SINGLESELECT", SWIG_From_int(static_cast< int >(ICONLIST_SINGLESELECT)));
+  rb_define_const(mFox, "ICONLIST_BROWSESELECT", SWIG_From_int(static_cast< int >(ICONLIST_BROWSESELECT)));
+  rb_define_const(mFox, "ICONLIST_MULTIPLESELECT", SWIG_From_int(static_cast< int >(ICONLIST_MULTIPLESELECT)));
+  rb_define_const(mFox, "ICONLIST_AUTOSIZE", SWIG_From_int(static_cast< int >(ICONLIST_AUTOSIZE)));
+  rb_define_const(mFox, "ICONLIST_DETAILED", SWIG_From_int(static_cast< int >(ICONLIST_DETAILED)));
+  rb_define_const(mFox, "ICONLIST_MINI_ICONS", SWIG_From_int(static_cast< int >(ICONLIST_MINI_ICONS)));
+  rb_define_const(mFox, "ICONLIST_BIG_ICONS", SWIG_From_int(static_cast< int >(ICONLIST_BIG_ICONS)));
+  rb_define_const(mFox, "ICONLIST_ROWS", SWIG_From_int(static_cast< int >(ICONLIST_ROWS)));
+  rb_define_const(mFox, "ICONLIST_COLUMNS", SWIG_From_int(static_cast< int >(ICONLIST_COLUMNS)));
+  rb_define_const(mFox, "ICONLIST_NORMAL", SWIG_From_int(static_cast< int >(ICONLIST_NORMAL)));
+  
+  SwigClassFXIconItem.klass = rb_define_class_under(mFox, "FXIconItem", ((swig_class *) SWIGTYPE_p_FXObject->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXIconItem, (void *) &SwigClassFXIconItem);
+  rb_define_alloc_func(SwigClassFXIconItem.klass, _wrap_FXIconItem_allocate);
+  rb_define_method(SwigClassFXIconItem.klass, "initialize", VALUEFUNC(_wrap_new_FXIconItem), -1);
+  rb_define_const(SwigClassFXIconItem.klass, "SELECTED", SWIG_From_int(static_cast< int >(FXIconItem::SELECTED)));
+  rb_define_const(SwigClassFXIconItem.klass, "FOCUS", SWIG_From_int(static_cast< int >(FXIconItem::FOCUS)));
+  rb_define_const(SwigClassFXIconItem.klass, "DISABLED", SWIG_From_int(static_cast< int >(FXIconItem::DISABLED)));
+  rb_define_const(SwigClassFXIconItem.klass, "DRAGGABLE", SWIG_From_int(static_cast< int >(FXIconItem::DRAGGABLE)));
+  rb_define_const(SwigClassFXIconItem.klass, "BIGICONOWNED", SWIG_From_int(static_cast< int >(FXIconItem::BIGICONOWNED)));
+  rb_define_const(SwigClassFXIconItem.klass, "MINIICONOWNED", SWIG_From_int(static_cast< int >(FXIconItem::MINIICONOWNED)));
+  rb_define_method(SwigClassFXIconItem.klass, "getText", VALUEFUNC(_wrap_FXIconItem_getText), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "getBigIcon", VALUEFUNC(_wrap_FXIconItem_getBigIcon), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "getMiniIcon", VALUEFUNC(_wrap_FXIconItem_getMiniIcon), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "setData", VALUEFUNC(_wrap_FXIconItem_setData), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "getData", VALUEFUNC(_wrap_FXIconItem_getData), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "hasFocus", VALUEFUNC(_wrap_FXIconItem_hasFocus), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "isSelected", VALUEFUNC(_wrap_FXIconItem_isSelected), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "isEnabled", VALUEFUNC(_wrap_FXIconItem_isEnabled), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "isDraggable", VALUEFUNC(_wrap_FXIconItem_isDraggable), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "save", VALUEFUNC(_wrap_FXIconItem_save), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "load", VALUEFUNC(_wrap_FXIconItem_load), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "draw", VALUEFUNC(_wrap_FXIconItem_draw), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "hitItem", VALUEFUNC(_wrap_FXIconItem_hitItem), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "drawBigIcon", VALUEFUNC(_wrap_FXIconItem_drawBigIcon), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "drawMiniIcon", VALUEFUNC(_wrap_FXIconItem_drawMiniIcon), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "drawDetails", VALUEFUNC(_wrap_FXIconItem_drawDetails), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "setText", VALUEFUNC(_wrap_FXIconItem_setText), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "setBigIcon", VALUEFUNC(_wrap_FXIconItem_setBigIcon), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "setMiniIcon", VALUEFUNC(_wrap_FXIconItem_setMiniIcon), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "setFocus", VALUEFUNC(_wrap_FXIconItem_setFocus), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "setSelected", VALUEFUNC(_wrap_FXIconItem_setSelected), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "setEnabled", VALUEFUNC(_wrap_FXIconItem_setEnabled), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "setDraggable", VALUEFUNC(_wrap_FXIconItem_setDraggable), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "getWidth", VALUEFUNC(_wrap_FXIconItem_getWidth), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "getHeight", VALUEFUNC(_wrap_FXIconItem_getHeight), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "create", VALUEFUNC(_wrap_FXIconItem_create), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "detach", VALUEFUNC(_wrap_FXIconItem_detach), -1);
+  rb_define_method(SwigClassFXIconItem.klass, "destroy", VALUEFUNC(_wrap_FXIconItem_destroy), -1);
+  SwigClassFXIconItem.mark = (void (*)(void *)) FXRbIconItem::markfunc;
+  SwigClassFXIconItem.destroy = (void (*)(void *)) FXRbIconItem::freefunc;
+  SwigClassFXIconItem.trackObjects = 0;
+  
+  SWIGTYPE_p_FXIconItem->dcast = (swig_dycast_func) FXIconItem_dynamic_cast;
+  
+  
+  SwigClassFXIconList.klass = rb_define_class_under(mFox, "FXIconList", ((swig_class *) SWIGTYPE_p_FXScrollArea->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXIconList, (void *) &SwigClassFXIconList);
+  rb_define_alloc_func(SwigClassFXIconList.klass, _wrap_FXIconList_allocate);
+  rb_define_method(SwigClassFXIconList.klass, "initialize", VALUEFUNC(_wrap_new_FXIconList), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onPaint", VALUEFUNC(_wrap_FXIconList_onPaint), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onEnter", VALUEFUNC(_wrap_FXIconList_onEnter), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onLeave", VALUEFUNC(_wrap_FXIconList_onLeave), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onUngrabbed", VALUEFUNC(_wrap_FXIconList_onUngrabbed), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onKeyPress", VALUEFUNC(_wrap_FXIconList_onKeyPress), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onKeyRelease", VALUEFUNC(_wrap_FXIconList_onKeyRelease), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXIconList_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXIconList_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onRightBtnPress", VALUEFUNC(_wrap_FXIconList_onRightBtnPress), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onRightBtnRelease", VALUEFUNC(_wrap_FXIconList_onRightBtnRelease), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onMotion", VALUEFUNC(_wrap_FXIconList_onMotion), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onQueryTip", VALUEFUNC(_wrap_FXIconList_onQueryTip), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onQueryHelp", VALUEFUNC(_wrap_FXIconList_onQueryHelp), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onTipTimer", VALUEFUNC(_wrap_FXIconList_onTipTimer), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onCmdSelectAll", VALUEFUNC(_wrap_FXIconList_onCmdSelectAll), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onCmdDeselectAll", VALUEFUNC(_wrap_FXIconList_onCmdDeselectAll), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onCmdSelectInverse", VALUEFUNC(_wrap_FXIconList_onCmdSelectInverse), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onCmdArrangeByRows", VALUEFUNC(_wrap_FXIconList_onCmdArrangeByRows), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onUpdArrangeByRows", VALUEFUNC(_wrap_FXIconList_onUpdArrangeByRows), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onCmdArrangeByColumns", VALUEFUNC(_wrap_FXIconList_onCmdArrangeByColumns), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onUpdArrangeByColumns", VALUEFUNC(_wrap_FXIconList_onUpdArrangeByColumns), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onCmdShowDetails", VALUEFUNC(_wrap_FXIconList_onCmdShowDetails), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onUpdShowDetails", VALUEFUNC(_wrap_FXIconList_onUpdShowDetails), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onCmdShowBigIcons", VALUEFUNC(_wrap_FXIconList_onCmdShowBigIcons), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onUpdShowBigIcons", VALUEFUNC(_wrap_FXIconList_onUpdShowBigIcons), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onCmdShowMiniIcons", VALUEFUNC(_wrap_FXIconList_onCmdShowMiniIcons), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onUpdShowMiniIcons", VALUEFUNC(_wrap_FXIconList_onUpdShowMiniIcons), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onHeaderChanged", VALUEFUNC(_wrap_FXIconList_onHeaderChanged), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onHeaderResize", VALUEFUNC(_wrap_FXIconList_onHeaderResize), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onFocusIn", VALUEFUNC(_wrap_FXIconList_onFocusIn), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onFocusOut", VALUEFUNC(_wrap_FXIconList_onFocusOut), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onClicked", VALUEFUNC(_wrap_FXIconList_onClicked), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onDoubleClicked", VALUEFUNC(_wrap_FXIconList_onDoubleClicked), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onTripleClicked", VALUEFUNC(_wrap_FXIconList_onTripleClicked), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onCommand", VALUEFUNC(_wrap_FXIconList_onCommand), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onAutoScroll", VALUEFUNC(_wrap_FXIconList_onAutoScroll), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onLookupTimer", VALUEFUNC(_wrap_FXIconList_onLookupTimer), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXIconList_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXIconList_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXIconList.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXIconList_onCmdSetIntValue), -1);
+  rb_define_singleton_method(SwigClassFXIconList.klass, "ascending", VALUEFUNC(_wrap_FXIconList_ascending), -1);
+  rb_define_singleton_method(SwigClassFXIconList.klass, "descending", VALUEFUNC(_wrap_FXIconList_descending), -1);
+  rb_define_singleton_method(SwigClassFXIconList.klass, "ascendingCase", VALUEFUNC(_wrap_FXIconList_ascendingCase), -1);
+  rb_define_singleton_method(SwigClassFXIconList.klass, "descendingCase", VALUEFUNC(_wrap_FXIconList_descendingCase), -1);
+  rb_define_const(SwigClassFXIconList.klass, "ID_SHOW_DETAILS", SWIG_From_int(static_cast< int >(FXIconList::ID_SHOW_DETAILS)));
+  rb_define_const(SwigClassFXIconList.klass, "ID_SHOW_MINI_ICONS", SWIG_From_int(static_cast< int >(FXIconList::ID_SHOW_MINI_ICONS)));
+  rb_define_const(SwigClassFXIconList.klass, "ID_SHOW_BIG_ICONS", SWIG_From_int(static_cast< int >(FXIconList::ID_SHOW_BIG_ICONS)));
+  rb_define_const(SwigClassFXIconList.klass, "ID_ARRANGE_BY_ROWS", SWIG_From_int(static_cast< int >(FXIconList::ID_ARRANGE_BY_ROWS)));
+  rb_define_const(SwigClassFXIconList.klass, "ID_ARRANGE_BY_COLUMNS", SWIG_From_int(static_cast< int >(FXIconList::ID_ARRANGE_BY_COLUMNS)));
+  rb_define_const(SwigClassFXIconList.klass, "ID_HEADER_CHANGE", SWIG_From_int(static_cast< int >(FXIconList::ID_HEADER_CHANGE)));
+  rb_define_const(SwigClassFXIconList.klass, "ID_LOOKUPTIMER", SWIG_From_int(static_cast< int >(FXIconList::ID_LOOKUPTIMER)));
+  rb_define_const(SwigClassFXIconList.klass, "ID_SELECT_ALL", SWIG_From_int(static_cast< int >(FXIconList::ID_SELECT_ALL)));
+  rb_define_const(SwigClassFXIconList.klass, "ID_DESELECT_ALL", SWIG_From_int(static_cast< int >(FXIconList::ID_DESELECT_ALL)));
+  rb_define_const(SwigClassFXIconList.klass, "ID_SELECT_INVERSE", SWIG_From_int(static_cast< int >(FXIconList::ID_SELECT_INVERSE)));
+  rb_define_const(SwigClassFXIconList.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXIconList::ID_LAST)));
+  rb_define_method(SwigClassFXIconList.klass, "getNumItems", VALUEFUNC(_wrap_FXIconList_getNumItems), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getNumRows", VALUEFUNC(_wrap_FXIconList_getNumRows), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getNumCols", VALUEFUNC(_wrap_FXIconList_getNumCols), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getHeader", VALUEFUNC(_wrap_FXIconList_getHeader), -1);
+  rb_define_method(SwigClassFXIconList.klass, "setHeaders", VALUEFUNC(_wrap_FXIconList_setHeaders), -1);
+  rb_define_method(SwigClassFXIconList.klass, "appendHeader", VALUEFUNC(_wrap_FXIconList_appendHeader), -1);
+  rb_define_method(SwigClassFXIconList.klass, "removeHeader", VALUEFUNC(_wrap_FXIconList_removeHeader), -1);
+  rb_define_method(SwigClassFXIconList.klass, "setHeaderText", VALUEFUNC(_wrap_FXIconList_setHeaderText), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getHeaderText", VALUEFUNC(_wrap_FXIconList_getHeaderText), -1);
+  rb_define_method(SwigClassFXIconList.klass, "setHeaderIcon", VALUEFUNC(_wrap_FXIconList_setHeaderIcon), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getHeaderIcon", VALUEFUNC(_wrap_FXIconList_getHeaderIcon), -1);
+  rb_define_method(SwigClassFXIconList.klass, "setHeaderSize", VALUEFUNC(_wrap_FXIconList_setHeaderSize), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getHeaderSize", VALUEFUNC(_wrap_FXIconList_getHeaderSize), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getNumHeaders", VALUEFUNC(_wrap_FXIconList_getNumHeaders), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getItem", VALUEFUNC(_wrap_FXIconList_getItem), -1);
+  rb_define_method(SwigClassFXIconList.klass, "setItem", VALUEFUNC(_wrap_FXIconList_setItem), -1);
+  rb_define_method(SwigClassFXIconList.klass, "fillItems", VALUEFUNC(_wrap_FXIconList_fillItems), -1);
+  rb_define_method(SwigClassFXIconList.klass, "insertItem", VALUEFUNC(_wrap_FXIconList_insertItem), -1);
+  rb_define_method(SwigClassFXIconList.klass, "appendItem", VALUEFUNC(_wrap_FXIconList_appendItem), -1);
+  rb_define_alias(SwigClassFXIconList.klass, "<<", "appendItem");
+  rb_define_method(SwigClassFXIconList.klass, "prependItem", VALUEFUNC(_wrap_FXIconList_prependItem), -1);
+  rb_define_method(SwigClassFXIconList.klass, "moveItem", VALUEFUNC(_wrap_FXIconList_moveItem), -1);
+  rb_define_method(SwigClassFXIconList.klass, "extractItem", VALUEFUNC(_wrap_FXIconList_extractItem), -1);
+  rb_define_method(SwigClassFXIconList.klass, "removeItem", VALUEFUNC(_wrap_FXIconList_removeItem), -1);
+  rb_define_method(SwigClassFXIconList.klass, "clearItems", VALUEFUNC(_wrap_FXIconList_clearItems), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getItemWidth", VALUEFUNC(_wrap_FXIconList_getItemWidth), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getItemHeight", VALUEFUNC(_wrap_FXIconList_getItemHeight), -1);
+  rb_define_method(SwigClassFXIconList.klass, "findItem", VALUEFUNC(_wrap_FXIconList_findItem), -1);
+  rb_define_method(SwigClassFXIconList.klass, "findItemByData", VALUEFUNC(_wrap_FXIconList_findItemByData), -1);
+  rb_define_method(SwigClassFXIconList.klass, "setItemText", VALUEFUNC(_wrap_FXIconList_setItemText), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getItemText", VALUEFUNC(_wrap_FXIconList_getItemText), -1);
+  rb_define_method(SwigClassFXIconList.klass, "setItemBigIcon", VALUEFUNC(_wrap_FXIconList_setItemBigIcon), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getItemBigIcon", VALUEFUNC(_wrap_FXIconList_getItemBigIcon), -1);
+  rb_define_method(SwigClassFXIconList.klass, "setItemMiniIcon", VALUEFUNC(_wrap_FXIconList_setItemMiniIcon), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getItemMiniIcon", VALUEFUNC(_wrap_FXIconList_getItemMiniIcon), -1);
+  rb_define_method(SwigClassFXIconList.klass, "setItemData", VALUEFUNC(_wrap_FXIconList_setItemData), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getItemData", VALUEFUNC(_wrap_FXIconList_getItemData), -1);
+  rb_define_method(SwigClassFXIconList.klass, "isItemSelected", VALUEFUNC(_wrap_FXIconList_isItemSelected), -1);
+  rb_define_method(SwigClassFXIconList.klass, "isItemCurrent", VALUEFUNC(_wrap_FXIconList_isItemCurrent), -1);
+  rb_define_method(SwigClassFXIconList.klass, "isItemVisible", VALUEFUNC(_wrap_FXIconList_isItemVisible), -1);
+  rb_define_method(SwigClassFXIconList.klass, "isItemEnabled", VALUEFUNC(_wrap_FXIconList_isItemEnabled), -1);
+  rb_define_method(SwigClassFXIconList.klass, "hitItem", VALUEFUNC(_wrap_FXIconList_hitItem), -1);
+  rb_define_method(SwigClassFXIconList.klass, "updateItem", VALUEFUNC(_wrap_FXIconList_updateItem), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getCurrentItem", VALUEFUNC(_wrap_FXIconList_getCurrentItem), -1);
+  rb_define_method(SwigClassFXIconList.klass, "setAnchorItem", VALUEFUNC(_wrap_FXIconList_setAnchorItem), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getAnchorItem", VALUEFUNC(_wrap_FXIconList_getAnchorItem), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getCursorItem", VALUEFUNC(_wrap_FXIconList_getCursorItem), -1);
+  rb_define_method(SwigClassFXIconList.klass, "sortItems", VALUEFUNC(_wrap_FXIconList_sortItems), -1);
+  rb_define_method(SwigClassFXIconList.klass, "setFont", VALUEFUNC(_wrap_FXIconList_setFont), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getFont", VALUEFUNC(_wrap_FXIconList_getFont), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getTextColor", VALUEFUNC(_wrap_FXIconList_getTextColor), -1);
+  rb_define_method(SwigClassFXIconList.klass, "setTextColor", VALUEFUNC(_wrap_FXIconList_setTextColor), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getSelBackColor", VALUEFUNC(_wrap_FXIconList_getSelBackColor), -1);
+  rb_define_method(SwigClassFXIconList.klass, "setSelBackColor", VALUEFUNC(_wrap_FXIconList_setSelBackColor), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getSelTextColor", VALUEFUNC(_wrap_FXIconList_getSelTextColor), -1);
+  rb_define_method(SwigClassFXIconList.klass, "setSelTextColor", VALUEFUNC(_wrap_FXIconList_setSelTextColor), -1);
+  rb_define_method(SwigClassFXIconList.klass, "setItemSpace", VALUEFUNC(_wrap_FXIconList_setItemSpace), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getItemSpace", VALUEFUNC(_wrap_FXIconList_getItemSpace), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getListStyle", VALUEFUNC(_wrap_FXIconList_getListStyle), -1);
+  rb_define_method(SwigClassFXIconList.klass, "setListStyle", VALUEFUNC(_wrap_FXIconList_setListStyle), -1);
+  rb_define_method(SwigClassFXIconList.klass, "setHelpText", VALUEFUNC(_wrap_FXIconList_setHelpText), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getHelpText", VALUEFUNC(_wrap_FXIconList_getHelpText), -1);
+  rb_define_method(SwigClassFXIconList.klass, "save", VALUEFUNC(_wrap_FXIconList_save), -1);
+  rb_define_method(SwigClassFXIconList.klass, "load", VALUEFUNC(_wrap_FXIconList_load), -1);
+  rb_define_method(SwigClassFXIconList.klass, "create", VALUEFUNC(_wrap_FXIconList_create), -1);
+  rb_define_method(SwigClassFXIconList.klass, "detach", VALUEFUNC(_wrap_FXIconList_detach), -1);
+  rb_define_method(SwigClassFXIconList.klass, "destroy", VALUEFUNC(_wrap_FXIconList_destroy), -1);
+  rb_define_method(SwigClassFXIconList.klass, "resize", VALUEFUNC(_wrap_FXIconList_resize), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXIconList_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXIconList_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXIconList_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXIconList_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXIconList.klass, "canFocus", VALUEFUNC(_wrap_FXIconList_canFocus), -1);
+  rb_define_method(SwigClassFXIconList.klass, "setFocus", VALUEFUNC(_wrap_FXIconList_setFocus), -1);
+  rb_define_method(SwigClassFXIconList.klass, "killFocus", VALUEFUNC(_wrap_FXIconList_killFocus), -1);
+  rb_define_method(SwigClassFXIconList.klass, "changeFocus", VALUEFUNC(_wrap_FXIconList_changeFocus), -1);
+  rb_define_method(SwigClassFXIconList.klass, "setDefault", VALUEFUNC(_wrap_FXIconList_setDefault), -1);
+  rb_define_method(SwigClassFXIconList.klass, "enable", VALUEFUNC(_wrap_FXIconList_enable), -1);
+  rb_define_method(SwigClassFXIconList.klass, "disable", VALUEFUNC(_wrap_FXIconList_disable), -1);
+  rb_define_method(SwigClassFXIconList.klass, "raiseWindow", VALUEFUNC(_wrap_FXIconList_raiseWindow), -1);
+  rb_define_method(SwigClassFXIconList.klass, "lower", VALUEFUNC(_wrap_FXIconList_lower), -1);
+  rb_define_method(SwigClassFXIconList.klass, "move", VALUEFUNC(_wrap_FXIconList_move), -1);
+  rb_define_method(SwigClassFXIconList.klass, "layout", VALUEFUNC(_wrap_FXIconList_layout), -1);
+  rb_define_method(SwigClassFXIconList.klass, "recalc", VALUEFUNC(_wrap_FXIconList_recalc), -1);
+  rb_define_method(SwigClassFXIconList.klass, "reparent", VALUEFUNC(_wrap_FXIconList_reparent), -1);
+  rb_define_method(SwigClassFXIconList.klass, "show", VALUEFUNC(_wrap_FXIconList_show), -1);
+  rb_define_method(SwigClassFXIconList.klass, "hide", VALUEFUNC(_wrap_FXIconList_hide), -1);
+  rb_define_method(SwigClassFXIconList.klass, "isComposite", VALUEFUNC(_wrap_FXIconList_isComposite), -1);
+  rb_define_method(SwigClassFXIconList.klass, "contains", VALUEFUNC(_wrap_FXIconList_contains), -1);
+  rb_define_method(SwigClassFXIconList.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXIconList_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXIconList.klass, "setBackColor", VALUEFUNC(_wrap_FXIconList_setBackColor), -1);
+  rb_define_method(SwigClassFXIconList.klass, "tr", VALUEFUNC(_wrap_FXIconList_tr), -1);
+  rb_define_method(SwigClassFXIconList.klass, "dropEnable", VALUEFUNC(_wrap_FXIconList_dropEnable), -1);
+  rb_define_method(SwigClassFXIconList.klass, "dropDisable", VALUEFUNC(_wrap_FXIconList_dropDisable), -1);
+  rb_define_method(SwigClassFXIconList.klass, "setShape", VALUEFUNC(_wrap_FXIconList_setShape), -1);
+  rb_define_method(SwigClassFXIconList.klass, "clearShape", VALUEFUNC(_wrap_FXIconList_clearShape), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getViewportHeight", VALUEFUNC(_wrap_FXIconList_getViewportHeight), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getViewportWidth", VALUEFUNC(_wrap_FXIconList_getViewportWidth), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getContentHeight", VALUEFUNC(_wrap_FXIconList_getContentHeight), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getContentWidth", VALUEFUNC(_wrap_FXIconList_getContentWidth), -1);
+  rb_define_method(SwigClassFXIconList.klass, "position", VALUEFUNC(_wrap_FXIconList_position), -1);
+  rb_define_method(SwigClassFXIconList.klass, "selectItem", VALUEFUNC(_wrap_FXIconList_selectItem), -1);
+  rb_define_method(SwigClassFXIconList.klass, "deselectItem", VALUEFUNC(_wrap_FXIconList_deselectItem), -1);
+  rb_define_method(SwigClassFXIconList.klass, "toggleItem", VALUEFUNC(_wrap_FXIconList_toggleItem), -1);
+  rb_define_method(SwigClassFXIconList.klass, "selectInRectangle", VALUEFUNC(_wrap_FXIconList_selectInRectangle), -1);
+  rb_define_method(SwigClassFXIconList.klass, "extendSelection", VALUEFUNC(_wrap_FXIconList_extendSelection), -1);
+  rb_define_method(SwigClassFXIconList.klass, "killSelection", VALUEFUNC(_wrap_FXIconList_killSelection), -1);
+  rb_define_method(SwigClassFXIconList.klass, "setCurrentItem", VALUEFUNC(_wrap_FXIconList_setCurrentItem), -1);
+  rb_define_method(SwigClassFXIconList.klass, "getItemAt", VALUEFUNC(_wrap_FXIconList_getItemAt), -1);
+  rb_define_method(SwigClassFXIconList.klass, "makeItemVisible", VALUEFUNC(_wrap_FXIconList_makeItemVisible), -1);
+  rb_define_method(SwigClassFXIconList.klass, "enableItem", VALUEFUNC(_wrap_FXIconList_enableItem), -1);
+  rb_define_method(SwigClassFXIconList.klass, "disableItem", VALUEFUNC(_wrap_FXIconList_disableItem), -1);
+  SwigClassFXIconList.mark = (void (*)(void *)) FXRbIconList::markfunc;
+  SwigClassFXIconList.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXIconList.trackObjects = 0;
+  
+  SWIGTYPE_p_FXIconList->dcast = (swig_dycast_func) FXIconList_dynamic_cast;
+  
+  rb_define_const(mFox, "FILELIST_SHOWHIDDEN", SWIG_From_int(static_cast< int >(FILELIST_SHOWHIDDEN)));
+  rb_define_const(mFox, "FILELIST_SHOWDIRS", SWIG_From_int(static_cast< int >(FILELIST_SHOWDIRS)));
+  rb_define_const(mFox, "FILELIST_SHOWFILES", SWIG_From_int(static_cast< int >(FILELIST_SHOWFILES)));
+  rb_define_const(mFox, "FILELIST_SHOWIMAGES", SWIG_From_int(static_cast< int >(FILELIST_SHOWIMAGES)));
+  rb_define_const(mFox, "FILELIST_NO_OWN_ASSOC", SWIG_From_int(static_cast< int >(FILELIST_NO_OWN_ASSOC)));
+  rb_define_const(mFox, "FILELIST_NO_PARENT", SWIG_From_int(static_cast< int >(FILELIST_NO_PARENT)));
+  
+  SwigClassFXFileItem.klass = rb_define_class_under(mFox, "FXFileItem", ((swig_class *) SWIGTYPE_p_FXIconItem->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXFileItem, (void *) &SwigClassFXFileItem);
+  rb_define_alloc_func(SwigClassFXFileItem.klass, _wrap_FXFileItem_allocate);
+  rb_define_method(SwigClassFXFileItem.klass, "initialize", VALUEFUNC(_wrap_new_FXFileItem), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "isFile", VALUEFUNC(_wrap_FXFileItem_isFile), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "isDirectory", VALUEFUNC(_wrap_FXFileItem_isDirectory), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "isShare", VALUEFUNC(_wrap_FXFileItem_isShare), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "isExecutable", VALUEFUNC(_wrap_FXFileItem_isExecutable), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "isSymlink", VALUEFUNC(_wrap_FXFileItem_isSymlink), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "isChardev", VALUEFUNC(_wrap_FXFileItem_isChardev), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "isBlockdev", VALUEFUNC(_wrap_FXFileItem_isBlockdev), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "isFifo", VALUEFUNC(_wrap_FXFileItem_isFifo), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "isSocket", VALUEFUNC(_wrap_FXFileItem_isSocket), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "getAssoc", VALUEFUNC(_wrap_FXFileItem_getAssoc), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "getSize", VALUEFUNC(_wrap_FXFileItem_getSize), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "getDate", VALUEFUNC(_wrap_FXFileItem_getDate), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "save", VALUEFUNC(_wrap_FXFileItem_save), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "load", VALUEFUNC(_wrap_FXFileItem_load), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "draw", VALUEFUNC(_wrap_FXFileItem_draw), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "hitItem", VALUEFUNC(_wrap_FXFileItem_hitItem), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "drawBigIcon", VALUEFUNC(_wrap_FXFileItem_drawBigIcon), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "drawMiniIcon", VALUEFUNC(_wrap_FXFileItem_drawMiniIcon), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "drawDetails", VALUEFUNC(_wrap_FXFileItem_drawDetails), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "setText", VALUEFUNC(_wrap_FXFileItem_setText), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "setBigIcon", VALUEFUNC(_wrap_FXFileItem_setBigIcon), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "setMiniIcon", VALUEFUNC(_wrap_FXFileItem_setMiniIcon), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "setFocus", VALUEFUNC(_wrap_FXFileItem_setFocus), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "setSelected", VALUEFUNC(_wrap_FXFileItem_setSelected), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "setEnabled", VALUEFUNC(_wrap_FXFileItem_setEnabled), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "setDraggable", VALUEFUNC(_wrap_FXFileItem_setDraggable), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "getWidth", VALUEFUNC(_wrap_FXFileItem_getWidth), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "getHeight", VALUEFUNC(_wrap_FXFileItem_getHeight), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "create", VALUEFUNC(_wrap_FXFileItem_create), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "detach", VALUEFUNC(_wrap_FXFileItem_detach), -1);
+  rb_define_method(SwigClassFXFileItem.klass, "destroy", VALUEFUNC(_wrap_FXFileItem_destroy), -1);
+  SwigClassFXFileItem.mark = (void (*)(void *)) FXRbFileItem::markfunc;
+  SwigClassFXFileItem.destroy = (void (*)(void *)) FXRbFileItem::freefunc;
+  SwigClassFXFileItem.trackObjects = 0;
+  
+  SwigClassFXFileList.klass = rb_define_class_under(mFox, "FXFileList", ((swig_class *) SWIGTYPE_p_FXIconList->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXFileList, (void *) &SwigClassFXFileList);
+  rb_define_alloc_func(SwigClassFXFileList.klass, _wrap_FXFileList_allocate);
+  rb_define_method(SwigClassFXFileList.klass, "initialize", VALUEFUNC(_wrap_new_FXFileList), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onOpenTimer", VALUEFUNC(_wrap_FXFileList_onOpenTimer), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onRefreshTimer", VALUEFUNC(_wrap_FXFileList_onRefreshTimer), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onDNDEnter", VALUEFUNC(_wrap_FXFileList_onDNDEnter), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onDNDLeave", VALUEFUNC(_wrap_FXFileList_onDNDLeave), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onDNDMotion", VALUEFUNC(_wrap_FXFileList_onDNDMotion), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onDNDDrop", VALUEFUNC(_wrap_FXFileList_onDNDDrop), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onDNDRequest", VALUEFUNC(_wrap_FXFileList_onDNDRequest), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onBeginDrag", VALUEFUNC(_wrap_FXFileList_onBeginDrag), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onEndDrag", VALUEFUNC(_wrap_FXFileList_onEndDrag), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onDragged", VALUEFUNC(_wrap_FXFileList_onDragged), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXFileList_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onCmdGetStringValue", VALUEFUNC(_wrap_FXFileList_onCmdGetStringValue), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onCmdSetStringValue", VALUEFUNC(_wrap_FXFileList_onCmdSetStringValue), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onCmdDirectoryUp", VALUEFUNC(_wrap_FXFileList_onCmdDirectoryUp), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onUpdDirectoryUp", VALUEFUNC(_wrap_FXFileList_onUpdDirectoryUp), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onCmdSortByName", VALUEFUNC(_wrap_FXFileList_onCmdSortByName), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onUpdSortByName", VALUEFUNC(_wrap_FXFileList_onUpdSortByName), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onCmdSortByType", VALUEFUNC(_wrap_FXFileList_onCmdSortByType), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onUpdSortByType", VALUEFUNC(_wrap_FXFileList_onUpdSortByType), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onCmdSortBySize", VALUEFUNC(_wrap_FXFileList_onCmdSortBySize), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onUpdSortBySize", VALUEFUNC(_wrap_FXFileList_onUpdSortBySize), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onCmdSortByTime", VALUEFUNC(_wrap_FXFileList_onCmdSortByTime), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onUpdSortByTime", VALUEFUNC(_wrap_FXFileList_onUpdSortByTime), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onCmdSortByUser", VALUEFUNC(_wrap_FXFileList_onCmdSortByUser), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onUpdSortByUser", VALUEFUNC(_wrap_FXFileList_onUpdSortByUser), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onCmdSortByGroup", VALUEFUNC(_wrap_FXFileList_onCmdSortByGroup), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onUpdSortByGroup", VALUEFUNC(_wrap_FXFileList_onUpdSortByGroup), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onCmdSortReverse", VALUEFUNC(_wrap_FXFileList_onCmdSortReverse), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onUpdSortReverse", VALUEFUNC(_wrap_FXFileList_onUpdSortReverse), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onCmdSortCase", VALUEFUNC(_wrap_FXFileList_onCmdSortCase), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onUpdSortCase", VALUEFUNC(_wrap_FXFileList_onUpdSortCase), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onCmdSetPattern", VALUEFUNC(_wrap_FXFileList_onCmdSetPattern), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onUpdSetPattern", VALUEFUNC(_wrap_FXFileList_onUpdSetPattern), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onCmdSetDirectory", VALUEFUNC(_wrap_FXFileList_onCmdSetDirectory), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onUpdSetDirectory", VALUEFUNC(_wrap_FXFileList_onUpdSetDirectory), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onCmdToggleHidden", VALUEFUNC(_wrap_FXFileList_onCmdToggleHidden), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onUpdToggleHidden", VALUEFUNC(_wrap_FXFileList_onUpdToggleHidden), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onCmdShowHidden", VALUEFUNC(_wrap_FXFileList_onCmdShowHidden), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onUpdShowHidden", VALUEFUNC(_wrap_FXFileList_onUpdShowHidden), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onCmdHideHidden", VALUEFUNC(_wrap_FXFileList_onCmdHideHidden), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onUpdHideHidden", VALUEFUNC(_wrap_FXFileList_onUpdHideHidden), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onCmdToggleImages", VALUEFUNC(_wrap_FXFileList_onCmdToggleImages), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onUpdToggleImages", VALUEFUNC(_wrap_FXFileList_onUpdToggleImages), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onCmdHeader", VALUEFUNC(_wrap_FXFileList_onCmdHeader), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onUpdHeader", VALUEFUNC(_wrap_FXFileList_onUpdHeader), -1);
+  rb_define_method(SwigClassFXFileList.klass, "onCmdRefresh", VALUEFUNC(_wrap_FXFileList_onCmdRefresh), -1);
+  rb_define_singleton_method(SwigClassFXFileList.klass, "ascending", VALUEFUNC(_wrap_FXFileList_ascending), -1);
+  rb_define_singleton_method(SwigClassFXFileList.klass, "descending", VALUEFUNC(_wrap_FXFileList_descending), -1);
+  rb_define_singleton_method(SwigClassFXFileList.klass, "ascendingCase", VALUEFUNC(_wrap_FXFileList_ascendingCase), -1);
+  rb_define_singleton_method(SwigClassFXFileList.klass, "descendingCase", VALUEFUNC(_wrap_FXFileList_descendingCase), -1);
+  rb_define_singleton_method(SwigClassFXFileList.klass, "ascendingType", VALUEFUNC(_wrap_FXFileList_ascendingType), -1);
+  rb_define_singleton_method(SwigClassFXFileList.klass, "descendingType", VALUEFUNC(_wrap_FXFileList_descendingType), -1);
+  rb_define_singleton_method(SwigClassFXFileList.klass, "ascendingSize", VALUEFUNC(_wrap_FXFileList_ascendingSize), -1);
+  rb_define_singleton_method(SwigClassFXFileList.klass, "descendingSize", VALUEFUNC(_wrap_FXFileList_descendingSize), -1);
+  rb_define_singleton_method(SwigClassFXFileList.klass, "ascendingTime", VALUEFUNC(_wrap_FXFileList_ascendingTime), -1);
+  rb_define_singleton_method(SwigClassFXFileList.klass, "descendingTime", VALUEFUNC(_wrap_FXFileList_descendingTime), -1);
+  rb_define_singleton_method(SwigClassFXFileList.klass, "ascendingUser", VALUEFUNC(_wrap_FXFileList_ascendingUser), -1);
+  rb_define_singleton_method(SwigClassFXFileList.klass, "descendingUser", VALUEFUNC(_wrap_FXFileList_descendingUser), -1);
+  rb_define_singleton_method(SwigClassFXFileList.klass, "ascendingGroup", VALUEFUNC(_wrap_FXFileList_ascendingGroup), -1);
+  rb_define_singleton_method(SwigClassFXFileList.klass, "descendingGroup", VALUEFUNC(_wrap_FXFileList_descendingGroup), -1);
+  rb_define_const(SwigClassFXFileList.klass, "ID_REFRESHTIMER", SWIG_From_int(static_cast< int >(FXFileList::ID_REFRESHTIMER)));
+  rb_define_const(SwigClassFXFileList.klass, "ID_OPENTIMER", SWIG_From_int(static_cast< int >(FXFileList::ID_OPENTIMER)));
+  rb_define_const(SwigClassFXFileList.klass, "ID_SORT_BY_NAME", SWIG_From_int(static_cast< int >(FXFileList::ID_SORT_BY_NAME)));
+  rb_define_const(SwigClassFXFileList.klass, "ID_SORT_BY_TYPE", SWIG_From_int(static_cast< int >(FXFileList::ID_SORT_BY_TYPE)));
+  rb_define_const(SwigClassFXFileList.klass, "ID_SORT_BY_SIZE", SWIG_From_int(static_cast< int >(FXFileList::ID_SORT_BY_SIZE)));
+  rb_define_const(SwigClassFXFileList.klass, "ID_SORT_BY_TIME", SWIG_From_int(static_cast< int >(FXFileList::ID_SORT_BY_TIME)));
+  rb_define_const(SwigClassFXFileList.klass, "ID_SORT_BY_USER", SWIG_From_int(static_cast< int >(FXFileList::ID_SORT_BY_USER)));
+  rb_define_const(SwigClassFXFileList.klass, "ID_SORT_BY_GROUP", SWIG_From_int(static_cast< int >(FXFileList::ID_SORT_BY_GROUP)));
+  rb_define_const(SwigClassFXFileList.klass, "ID_SORT_REVERSE", SWIG_From_int(static_cast< int >(FXFileList::ID_SORT_REVERSE)));
+  rb_define_const(SwigClassFXFileList.klass, "ID_SORT_CASE", SWIG_From_int(static_cast< int >(FXFileList::ID_SORT_CASE)));
+  rb_define_const(SwigClassFXFileList.klass, "ID_DIRECTORY_UP", SWIG_From_int(static_cast< int >(FXFileList::ID_DIRECTORY_UP)));
+  rb_define_const(SwigClassFXFileList.klass, "ID_SET_PATTERN", SWIG_From_int(static_cast< int >(FXFileList::ID_SET_PATTERN)));
+  rb_define_const(SwigClassFXFileList.klass, "ID_SET_DIRECTORY", SWIG_From_int(static_cast< int >(FXFileList::ID_SET_DIRECTORY)));
+  rb_define_const(SwigClassFXFileList.klass, "ID_SHOW_HIDDEN", SWIG_From_int(static_cast< int >(FXFileList::ID_SHOW_HIDDEN)));
+  rb_define_const(SwigClassFXFileList.klass, "ID_HIDE_HIDDEN", SWIG_From_int(static_cast< int >(FXFileList::ID_HIDE_HIDDEN)));
+  rb_define_const(SwigClassFXFileList.klass, "ID_TOGGLE_HIDDEN", SWIG_From_int(static_cast< int >(FXFileList::ID_TOGGLE_HIDDEN)));
+  rb_define_const(SwigClassFXFileList.klass, "ID_TOGGLE_IMAGES", SWIG_From_int(static_cast< int >(FXFileList::ID_TOGGLE_IMAGES)));
+  rb_define_const(SwigClassFXFileList.klass, "ID_REFRESH", SWIG_From_int(static_cast< int >(FXFileList::ID_REFRESH)));
+  rb_define_const(SwigClassFXFileList.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXFileList::ID_LAST)));
+  rb_define_method(SwigClassFXFileList.klass, "scan", VALUEFUNC(_wrap_FXFileList_scan), -1);
+  rb_define_method(SwigClassFXFileList.klass, "setCurrentFile", VALUEFUNC(_wrap_FXFileList_setCurrentFile), -1);
+  rb_define_method(SwigClassFXFileList.klass, "getCurrentFile", VALUEFUNC(_wrap_FXFileList_getCurrentFile), -1);
+  rb_define_method(SwigClassFXFileList.klass, "setDirectory", VALUEFUNC(_wrap_FXFileList_setDirectory), -1);
+  rb_define_method(SwigClassFXFileList.klass, "getDirectory", VALUEFUNC(_wrap_FXFileList_getDirectory), -1);
+  rb_define_method(SwigClassFXFileList.klass, "setPattern", VALUEFUNC(_wrap_FXFileList_setPattern), -1);
+  rb_define_method(SwigClassFXFileList.klass, "getPattern", VALUEFUNC(_wrap_FXFileList_getPattern), -1);
+  rb_define_method(SwigClassFXFileList.klass, "isItemDirectory", VALUEFUNC(_wrap_FXFileList_isItemDirectory), -1);
+  rb_define_method(SwigClassFXFileList.klass, "isItemShare", VALUEFUNC(_wrap_FXFileList_isItemShare), -1);
+  rb_define_method(SwigClassFXFileList.klass, "isItemFile", VALUEFUNC(_wrap_FXFileList_isItemFile), -1);
+  rb_define_method(SwigClassFXFileList.klass, "isItemExecutable", VALUEFUNC(_wrap_FXFileList_isItemExecutable), -1);
+  rb_define_method(SwigClassFXFileList.klass, "getItemFilename", VALUEFUNC(_wrap_FXFileList_getItemFilename), -1);
+  rb_define_method(SwigClassFXFileList.klass, "getItemPathname", VALUEFUNC(_wrap_FXFileList_getItemPathname), -1);
+  rb_define_method(SwigClassFXFileList.klass, "getItemAssoc", VALUEFUNC(_wrap_FXFileList_getItemAssoc), -1);
+  rb_define_method(SwigClassFXFileList.klass, "getMatchMode", VALUEFUNC(_wrap_FXFileList_getMatchMode), -1);
+  rb_define_method(SwigClassFXFileList.klass, "setMatchMode", VALUEFUNC(_wrap_FXFileList_setMatchMode), -1);
+  rb_define_method(SwigClassFXFileList.klass, "getHiddenFilesShown", VALUEFUNC(_wrap_FXFileList_getHiddenFilesShown), -1);
+  rb_define_method(SwigClassFXFileList.klass, "setHiddenFilesShown", VALUEFUNC(_wrap_FXFileList_setHiddenFilesShown), -1);
+  rb_define_method(SwigClassFXFileList.klass, "getOnlyDirectoriesShown", VALUEFUNC(_wrap_FXFileList_getOnlyDirectoriesShown), -1);
+  rb_define_method(SwigClassFXFileList.klass, "setOnlyDirectoriesShown", VALUEFUNC(_wrap_FXFileList_setOnlyDirectoriesShown), -1);
+  rb_define_method(SwigClassFXFileList.klass, "showOnlyFiles", VALUEFUNC(_wrap_FXFileList_showOnlyFiles), -1);
+  rb_define_method(SwigClassFXFileList.klass, "getShowImages", VALUEFUNC(_wrap_FXFileList_getShowImages), -1);
+  rb_define_method(SwigClassFXFileList.klass, "setShowImages", VALUEFUNC(_wrap_FXFileList_setShowImages), -1);
+  rb_define_method(SwigClassFXFileList.klass, "getImageSize", VALUEFUNC(_wrap_FXFileList_getImageSize), -1);
+  rb_define_method(SwigClassFXFileList.klass, "setImageSize", VALUEFUNC(_wrap_FXFileList_setImageSize), -1);
+  rb_define_method(SwigClassFXFileList.klass, "parentDirsShown?", VALUEFUNC(_wrap_FXFileList_parentDirsShownq___), -1);
+  rb_define_method(SwigClassFXFileList.klass, "parentDirsShown=", VALUEFUNC(_wrap_FXFileList_parentDirsShowne___), -1);
+  rb_define_method(SwigClassFXFileList.klass, "setAssociations", VALUEFUNC(_wrap_FXFileList_setAssociations), -1);
+  rb_define_method(SwigClassFXFileList.klass, "getAssociations", VALUEFUNC(_wrap_FXFileList_getAssociations), -1);
+  rb_define_method(SwigClassFXFileList.klass, "save", VALUEFUNC(_wrap_FXFileList_save), -1);
+  rb_define_method(SwigClassFXFileList.klass, "load", VALUEFUNC(_wrap_FXFileList_load), -1);
+  rb_define_method(SwigClassFXFileList.klass, "create", VALUEFUNC(_wrap_FXFileList_create), -1);
+  rb_define_method(SwigClassFXFileList.klass, "detach", VALUEFUNC(_wrap_FXFileList_detach), -1);
+  rb_define_method(SwigClassFXFileList.klass, "destroy", VALUEFUNC(_wrap_FXFileList_destroy), -1);
+  rb_define_method(SwigClassFXFileList.klass, "resize", VALUEFUNC(_wrap_FXFileList_resize), -1);
+  rb_define_method(SwigClassFXFileList.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXFileList_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXFileList.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXFileList_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXFileList.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXFileList_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXFileList.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXFileList_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXFileList.klass, "canFocus", VALUEFUNC(_wrap_FXFileList_canFocus), -1);
+  rb_define_method(SwigClassFXFileList.klass, "setFocus", VALUEFUNC(_wrap_FXFileList_setFocus), -1);
+  rb_define_method(SwigClassFXFileList.klass, "killFocus", VALUEFUNC(_wrap_FXFileList_killFocus), -1);
+  rb_define_method(SwigClassFXFileList.klass, "changeFocus", VALUEFUNC(_wrap_FXFileList_changeFocus), -1);
+  rb_define_method(SwigClassFXFileList.klass, "setDefault", VALUEFUNC(_wrap_FXFileList_setDefault), -1);
+  rb_define_method(SwigClassFXFileList.klass, "enable", VALUEFUNC(_wrap_FXFileList_enable), -1);
+  rb_define_method(SwigClassFXFileList.klass, "disable", VALUEFUNC(_wrap_FXFileList_disable), -1);
+  rb_define_method(SwigClassFXFileList.klass, "raiseWindow", VALUEFUNC(_wrap_FXFileList_raiseWindow), -1);
+  rb_define_method(SwigClassFXFileList.klass, "lower", VALUEFUNC(_wrap_FXFileList_lower), -1);
+  rb_define_method(SwigClassFXFileList.klass, "move", VALUEFUNC(_wrap_FXFileList_move), -1);
+  rb_define_method(SwigClassFXFileList.klass, "layout", VALUEFUNC(_wrap_FXFileList_layout), -1);
+  rb_define_method(SwigClassFXFileList.klass, "recalc", VALUEFUNC(_wrap_FXFileList_recalc), -1);
+  rb_define_method(SwigClassFXFileList.klass, "reparent", VALUEFUNC(_wrap_FXFileList_reparent), -1);
+  rb_define_method(SwigClassFXFileList.klass, "show", VALUEFUNC(_wrap_FXFileList_show), -1);
+  rb_define_method(SwigClassFXFileList.klass, "hide", VALUEFUNC(_wrap_FXFileList_hide), -1);
+  rb_define_method(SwigClassFXFileList.klass, "isComposite", VALUEFUNC(_wrap_FXFileList_isComposite), -1);
+  rb_define_method(SwigClassFXFileList.klass, "contains", VALUEFUNC(_wrap_FXFileList_contains), -1);
+  rb_define_method(SwigClassFXFileList.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXFileList_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXFileList.klass, "setBackColor", VALUEFUNC(_wrap_FXFileList_setBackColor), -1);
+  rb_define_method(SwigClassFXFileList.klass, "tr", VALUEFUNC(_wrap_FXFileList_tr), -1);
+  rb_define_method(SwigClassFXFileList.klass, "dropEnable", VALUEFUNC(_wrap_FXFileList_dropEnable), -1);
+  rb_define_method(SwigClassFXFileList.klass, "dropDisable", VALUEFUNC(_wrap_FXFileList_dropDisable), -1);
+  rb_define_method(SwigClassFXFileList.klass, "setShape", VALUEFUNC(_wrap_FXFileList_setShape), -1);
+  rb_define_method(SwigClassFXFileList.klass, "clearShape", VALUEFUNC(_wrap_FXFileList_clearShape), -1);
+  rb_define_method(SwigClassFXFileList.klass, "getViewportHeight", VALUEFUNC(_wrap_FXFileList_getViewportHeight), -1);
+  rb_define_method(SwigClassFXFileList.klass, "getViewportWidth", VALUEFUNC(_wrap_FXFileList_getViewportWidth), -1);
+  rb_define_method(SwigClassFXFileList.klass, "getContentHeight", VALUEFUNC(_wrap_FXFileList_getContentHeight), -1);
+  rb_define_method(SwigClassFXFileList.klass, "getContentWidth", VALUEFUNC(_wrap_FXFileList_getContentWidth), -1);
+  rb_define_method(SwigClassFXFileList.klass, "position", VALUEFUNC(_wrap_FXFileList_position), -1);
+  rb_define_method(SwigClassFXFileList.klass, "selectItem", VALUEFUNC(_wrap_FXFileList_selectItem), -1);
+  rb_define_method(SwigClassFXFileList.klass, "deselectItem", VALUEFUNC(_wrap_FXFileList_deselectItem), -1);
+  rb_define_method(SwigClassFXFileList.klass, "toggleItem", VALUEFUNC(_wrap_FXFileList_toggleItem), -1);
+  rb_define_method(SwigClassFXFileList.klass, "selectInRectangle", VALUEFUNC(_wrap_FXFileList_selectInRectangle), -1);
+  rb_define_method(SwigClassFXFileList.klass, "extendSelection", VALUEFUNC(_wrap_FXFileList_extendSelection), -1);
+  rb_define_method(SwigClassFXFileList.klass, "killSelection", VALUEFUNC(_wrap_FXFileList_killSelection), -1);
+  rb_define_method(SwigClassFXFileList.klass, "setCurrentItem", VALUEFUNC(_wrap_FXFileList_setCurrentItem), -1);
+  rb_define_method(SwigClassFXFileList.klass, "getItemAt", VALUEFUNC(_wrap_FXFileList_getItemAt), -1);
+  rb_define_method(SwigClassFXFileList.klass, "makeItemVisible", VALUEFUNC(_wrap_FXFileList_makeItemVisible), -1);
+  rb_define_method(SwigClassFXFileList.klass, "enableItem", VALUEFUNC(_wrap_FXFileList_enableItem), -1);
+  rb_define_method(SwigClassFXFileList.klass, "disableItem", VALUEFUNC(_wrap_FXFileList_disableItem), -1);
+  SwigClassFXFileList.mark = (void (*)(void *)) FXRbFileList::markfunc;
+  SwigClassFXFileList.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXFileList.trackObjects = 0;
+}
+
diff --git a/ext/fox16_c/icons_wrap.cpp b/ext/fox16_c/icons_wrap.cpp
new file mode 100644
index 00000000..5dde13bc
--- /dev/null
+++ b/ext/fox16_c/icons_wrap.cpp
@@ -0,0 +1,16190 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 3.0.12
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+
+#ifndef SWIGRUBY
+#define SWIGRUBY
+#endif
+
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
+};
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic C API SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "4"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/*  Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN           0x1
+
+
+/*
+   Flags/methods for returning states.
+
+   The SWIG conversion methods, as ConvertPtr, return an integer
+   that tells if the conversion was successful or not. And if not,
+   an error code can be returned (see swigerrors.swg for the codes).
+
+   Use the following macros/flags to set or process the returning
+   states.
+
+   In old versions of SWIG, code such as the following was usually written:
+
+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+       // success code
+     } else {
+       //fail code
+     }
+
+   Now you can be more explicit:
+
+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+    } else {
+      // fail code
+    }
+
+   which is the same really, but now you can also do
+
+    Type *ptr;
+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+      if (SWIG_IsNewObj(res) {
+        ...
+	delete *ptr;
+      } else {
+        ...
+      }
+    } else {
+      // fail code
+    }
+
+   I.e., now SWIG_ConvertPtr can return new objects and you can
+   identify the case and take care of the deallocation. Of course that
+   also requires SWIG_ConvertPtr to return new result values, such as
+
+      int SWIG_ConvertPtr(obj, ptr,...) {
+        if (<obj is ok>) {
+          if (<need new object>) {
+            *ptr = <ptr to new allocated object>;
+            return SWIG_NEWOBJ;
+          } else {
+            *ptr = <ptr to old object>;
+            return SWIG_OLDOBJ;
+          }
+        } else {
+          return SWIG_BADOBJ;
+        }
+      }
+
+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+   SWIG errors code.
+
+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+   allows to return the 'cast rank', for example, if you have this
+
+       int food(double)
+       int fooi(int);
+
+   and you call
+
+      food(1)   // cast rank '1'  (1 -> 1.0)
+      fooi(1)   // cast rank '0'
+
+   just use the SWIG_AddCast()/SWIG_CheckState()
+*/
+
+#define SWIG_OK                    (0)
+#define SWIG_ERROR                 (-1)
+#define SWIG_IsOK(r)               (r >= 0)
+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT         (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ                (SWIG_ERROR)
+#define SWIG_OLDOBJ                (SWIG_OK)
+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+#  ifndef SWIG_TypeRank
+#    define SWIG_TypeRank             unsigned long
+#  endif
+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
+#    define SWIG_MAXCASTRANK          (2)
+#  endif
+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+#  define SWIG_AddCast(r) (r)
+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *, int *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store information on one type */
+typedef struct swig_type_info {
+  const char             *name;			/* mangled name of this type */
+  const char             *str;			/* human readable name of this type */
+  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
+  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
+  void                   *clientdata;		/* language specific type data */
+  int                    owndata;		/* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
+  swig_converter_func     converter;		/* function to cast the void pointers */
+  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
+  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
+  size_t                 size;		        /* Number of types in this module */
+  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
+  swig_type_info         **type_initial;	/* Array of initially generated type structures */
+  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
+  void                    *clientdata;		/* Language specific module data */
+} swig_module_info;
+
+/*
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+  }
+  return (int)((l1 - f1) - (l2 - f2));
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCmp(const char *nb, const char *tb) {
+  int equiv = 1;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (equiv != 0 && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
+}
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
+}
+
+/*
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+  swig_type_info *lastty = ty;
+  if (!ty || !ty->dcast) return ty;
+  while (ty && (ty->dcast)) {
+    ty = (*ty->dcast)(ptr);
+    if (ty) lastty = ty;
+  }
+  return lastty;
+}
+
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+  return ty->name;
+}
+
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (!type) return NULL;
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
+  }
+  else
+    return type->name;
+}
+
+/*
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+  swig_cast_info *cast = ti->cast;
+  /* if (ti->clientdata == clientdata) return; */
+  ti->clientdata = clientdata;
+
+  while (cast) {
+    if (!cast->converter) {
+      swig_type_info *tc = cast->type;
+      if (!tc->clientdata) {
+	SWIG_TypeClientData(tc, clientdata);
+      }
+    }
+    cast = cast->next;
+  }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientData(ti, clientdata);
+  ti->owndata = 1;
+}
+
+/*
+  Search for a swig_type_info structure only by mangled name
+  Search is a O(log #types)
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+                            swig_module_info *end,
+		            const char *name) {
+  swig_module_info *iter = start;
+  do {
+    if (iter->size) {
+      size_t l = 0;
+      size_t r = iter->size - 1;
+      do {
+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
+	size_t i = (l + r) >> 1;
+	const char *iname = iter->types[i]->name;
+	if (iname) {
+	  int compare = strcmp(name, iname);
+	  if (compare == 0) {
+	    return iter->types[i];
+	  } else if (compare < 0) {
+	    if (i) {
+	      r = i - 1;
+	    } else {
+	      break;
+	    }
+	  } else if (compare > 0) {
+	    l = i + 1;
+	  }
+	} else {
+	  break; /* should never happen */
+	}
+      } while (l <= r);
+    }
+    iter = iter->next;
+  } while (iter != end);
+  return 0;
+}
+
+/*
+  Search for a swig_type_info structure for either a mangled name or a human readable name.
+  It first searches the mangled names of the types, which is a O(log #types)
+  If a type is not found it then searches the human readable names, which is O(#types).
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+                     swig_module_info *end,
+		     const char *name) {
+  /* STEP 1: Search the name field using binary search */
+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+  if (ret) {
+    return ret;
+  } else {
+    /* STEP 2: If the type hasn't been found, do a complete search
+       of the str field (the human readable name) */
+    swig_module_info *iter = start;
+    do {
+      size_t i = 0;
+      for (; i < iter->size; ++i) {
+	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+	  return iter->types[i];
+      }
+      iter = iter->next;
+    } while (iter != end);
+  }
+
+  /* neither found a match */
+  return 0;
+}
+
+/*
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+
+/*
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = (unsigned char)((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = (unsigned char)((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (unsigned char)(d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (unsigned char)(d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/*
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/*  Errors in SWIG */
+#define  SWIG_UnknownError    	   -1
+#define  SWIG_IOError        	   -2
+#define  SWIG_RuntimeError   	   -3
+#define  SWIG_IndexError     	   -4
+#define  SWIG_TypeError      	   -5
+#define  SWIG_DivisionByZero 	   -6
+#define  SWIG_OverflowError  	   -7
+#define  SWIG_SyntaxError    	   -8
+#define  SWIG_ValueError     	   -9
+#define  SWIG_SystemError    	   -10
+#define  SWIG_AttributeError 	   -11
+#define  SWIG_MemoryError    	   -12
+#define  SWIG_NullReferenceError   -13
+
+
+
+      #include <ruby.h>
+
+      #if defined(RB_METHOD_DEFINITION_DECL)
+      # define RUBY_VALUE_METHOD_FUNC(func) (func)
+      # define RUBY_INT_METHOD_FUNC(func) (func)
+      # define RUBY_VOID_METHOD_FUNC(func) (func)
+      # define RUBY_VOIDP_METHOD_FUNC(func) (func)
+      #else
+      # define RUBY_VALUE_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
+      # define RUBY_INT_METHOD_FUNC(func) ((int (*)(ANYARGS))(func))
+      # define RUBY_VOID_METHOD_FUNC(func) ((void (*)(ANYARGS))(func))
+      # define RUBY_VOIDP_METHOD_FUNC(func) ((void *(*)(ANYARGS))(func))
+      #endif
+
+
+/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
+ * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
+ * issue for now by disabling this.
+ * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
+ */
+#ifdef rb_intern
+# undef rb_intern
+#endif
+
+/* Remove global macros defined in Ruby's win32.h */
+#ifdef write
+# undef write
+#endif
+#ifdef read
+# undef read
+#endif
+#ifdef bind
+# undef bind
+#endif
+#ifdef close
+# undef close
+#endif
+#ifdef connect
+# undef connect
+#endif
+
+
+/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
+#ifndef NUM2LL
+#define NUM2LL(x) NUM2LONG((x))
+#endif
+#ifndef LL2NUM
+#define LL2NUM(x) INT2NUM((long) (x))
+#endif
+#ifndef ULL2NUM
+#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
+#endif
+
+/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
+#ifndef NUM2ULL
+#ifdef HAVE_LONG_LONG
+#define NUM2ULL(x) rb_num2ull((x))
+#else
+#define NUM2ULL(x) NUM2ULONG(x)
+#endif
+#endif
+
+/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
+/* Define these for older versions so we can just write code the new way */
+#ifndef RSTRING_LEN
+# define RSTRING_LEN(x) RSTRING(x)->len
+#endif
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(x) RSTRING(x)->ptr
+#endif
+#ifndef RSTRING_END
+# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
+#endif
+#ifndef RARRAY_LEN
+# define RARRAY_LEN(x) RARRAY(x)->len
+#endif
+#ifndef RARRAY_PTR
+# define RARRAY_PTR(x) RARRAY(x)->ptr
+#endif
+#ifndef RFLOAT_VALUE
+# define RFLOAT_VALUE(x) RFLOAT(x)->value
+#endif
+#ifndef DOUBLE2NUM
+# define DOUBLE2NUM(x) rb_float_new(x)
+#endif
+#ifndef RHASH_TBL
+# define RHASH_TBL(x) (RHASH(x)->tbl)
+#endif
+#ifndef RHASH_ITER_LEV
+# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
+#endif
+#ifndef RHASH_IFNONE
+# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
+#endif
+#ifndef RHASH_SIZE
+# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
+#endif
+#ifndef RHASH_EMPTY_P
+# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
+#endif
+#ifndef RSTRUCT_LEN
+# define RSTRUCT_LEN(x) RSTRUCT(x)->len
+#endif
+#ifndef RSTRUCT_PTR
+# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
+#endif
+
+
+
+/*
+ * Need to be very careful about how these macros are defined, especially
+ * when compiling C++ code or C code with an ANSI C compiler.
+ *
+ * VALUEFUNC(f) is a macro used to typecast a C function that implements
+ * a Ruby method so that it can be passed as an argument to API functions
+ * like rb_define_method() and rb_define_singleton_method().
+ *
+ * VOIDFUNC(f) is a macro used to typecast a C function that implements
+ * either the "mark" or "free" stuff for a Ruby Data object, so that it
+ * can be passed as an argument to API functions like Data_Wrap_Struct()
+ * and Data_Make_Struct().
+ */
+ 
+#ifdef __cplusplus
+#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
+#    define PROTECTFUNC(f) ((VALUE (*)()) f)
+#    define VALUEFUNC(f) ((VALUE (*)()) f)
+#    define VOIDFUNC(f)  ((void (*)()) f)
+#  else
+#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
+#      define PROTECTFUNC(f) ((VALUE (*)()) f)
+#      define VALUEFUNC(f) ((VALUE (*)()) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    else /* These definitions should work for Ruby 1.7+ */
+#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
+#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    endif
+#  endif
+#else
+#  define VALUEFUNC(f) (f)
+#  define VOIDFUNC(f) (f)
+#endif
+
+/* Don't use for expressions have side effect */
+#ifndef RB_STRING_VALUE
+#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
+#endif
+#ifndef StringValue
+#define StringValue(s) RB_STRING_VALUE(s)
+#endif
+#ifndef StringValuePtr
+#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
+#endif
+#ifndef StringValueLen
+#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
+#endif
+#ifndef SafeStringValue
+#define SafeStringValue(v) do {\
+    StringValue(v);\
+    rb_check_safe_str(v);\
+} while (0)
+#endif
+
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
+#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
+#endif
+
+static VALUE _mSWIG = Qnil;
+
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+
+/* Define some additional error types */
+#define SWIG_ObjectPreviouslyDeletedError  -100
+
+
+/* Define custom exceptions for errors that do not map to existing Ruby
+   exceptions.  Note this only works for C++ since a global cannot be
+   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/
+
+SWIGINTERN VALUE 
+getNullReferenceError(void) {
+  static int init = 0;
+  static VALUE rb_eNullReferenceError ;
+  if (!init) {
+    init = 1;
+    rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
+  }
+  return rb_eNullReferenceError;
+} 
+
+SWIGINTERN VALUE 
+getObjectPreviouslyDeletedError(void) {
+  static int init = 0;
+  static VALUE rb_eObjectPreviouslyDeleted ;
+  if (!init) {
+    init = 1;
+    rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
+  }
+  return rb_eObjectPreviouslyDeleted;
+} 
+
+
+SWIGINTERN VALUE
+SWIG_Ruby_ErrorType(int SWIG_code) {
+  VALUE type;
+  switch (SWIG_code) {
+  case SWIG_MemoryError:
+    type = rb_eNoMemError;
+    break;
+  case SWIG_IOError:
+    type = rb_eIOError;
+    break;
+  case SWIG_RuntimeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_IndexError:
+    type = rb_eIndexError;
+    break;
+  case SWIG_TypeError:
+    type = rb_eTypeError;
+    break;
+  case SWIG_DivisionByZero:
+    type = rb_eZeroDivError;
+    break;
+  case SWIG_OverflowError:
+    type = rb_eRangeError;
+    break;
+  case SWIG_SyntaxError:
+    type = rb_eSyntaxError;
+    break;
+  case SWIG_ValueError:
+    type = rb_eArgError;
+    break;
+  case SWIG_SystemError:
+    type = rb_eFatal;
+    break;
+  case SWIG_AttributeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_NullReferenceError:
+    type = getNullReferenceError();
+    break;
+  case SWIG_ObjectPreviouslyDeletedError:
+    type = getObjectPreviouslyDeletedError();
+    break;
+  case SWIG_UnknownError:
+    type = rb_eRuntimeError;
+    break;
+  default:
+    type = rb_eRuntimeError;
+  }
+  return type;
+}
+
+
+/* This function is called when a user inputs a wrong argument to
+   a method.
+ */
+SWIGINTERN 
+const char* Ruby_Format_TypeError( const char* msg,
+				   const char* type, 
+				   const char* name, 
+				   const int argn,
+				   VALUE input )
+{
+  char buf[128];
+  VALUE str;
+  VALUE asStr;
+  if ( msg && *msg )
+    {
+      str = rb_str_new2(msg);
+    }
+  else
+    {
+      str = rb_str_new(NULL, 0);
+    }
+
+  str = rb_str_cat2( str, "Expected argument " );
+  sprintf( buf, "%d of type ", argn-1 );
+  str = rb_str_cat2( str, buf );
+  str = rb_str_cat2( str, type );
+  str = rb_str_cat2( str, ", but got " );
+  str = rb_str_cat2( str, rb_obj_classname(input) );
+  str = rb_str_cat2( str, " " );
+  asStr = rb_inspect(input);
+  if ( RSTRING_LEN(asStr) > 30 )
+    {
+      str = rb_str_cat( str, StringValuePtr(asStr), 30 );
+      str = rb_str_cat2( str, "..." );
+    }
+  else
+    {
+      str = rb_str_append( str, asStr );
+    }
+
+  if ( name )
+    {
+      str = rb_str_cat2( str, "\n\tin SWIG method '" );
+      str = rb_str_cat2( str, name );
+      str = rb_str_cat2( str, "'" );
+    }
+
+  return StringValuePtr( str );
+}
+
+/* This function is called when an overloaded method fails */
+SWIGINTERN 
+void Ruby_Format_OverloadedError(
+				 const int argc,
+				 const int maxargs,
+				 const char* method, 
+				 const char* prototypes 
+				 )
+{
+  const char* msg = "Wrong # of arguments";
+  if ( argc <= maxargs ) msg = "Wrong arguments";
+  rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
+	   "Possible C/C++ prototypes are:\n%s",
+	   msg, method, prototypes);
+}
+
+/* -----------------------------------------------------------------------------
+ * rubytracking.swg
+ *
+ * This file contains support for tracking mappings from 
+ * Ruby objects to C++ objects.  This functionality is needed
+ * to implement mark functions for Ruby's mark and sweep
+ * garbage collector.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(ST_DATA_T_DEFINED)
+/* Needs to be explicitly included for Ruby 1.8 and earlier */
+#include <st.h>
+#endif
+
+/* Ruby 1.8 actually assumes the first case. */
+#if SIZEOF_VOIDP == SIZEOF_LONG
+#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
+#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
+#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
+#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
+#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
+#else
+#  error sizeof(void*) is not the same as long or long long
+#endif
+
+/* Global hash table to store Trackings from C/C++
+   structs to Ruby Objects. 
+*/
+static st_table* swig_ruby_trackings = NULL;
+
+static VALUE swig_ruby_trackings_count(ID id, VALUE *var) {
+  return SWIG2NUM(swig_ruby_trackings->num_entries);
+}
+
+
+/* Setup a hash table to store Trackings */
+SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
+  /* Create a hash table to store Trackings from C++
+     objects to Ruby objects. */
+
+  /* Try to see if some other .so has already created a 
+     tracking hash table, which we keep hidden in an instance var
+     in the SWIG module.
+     This is done to allow multiple DSOs to share the same
+     tracking table.
+  */
+  VALUE trackings_value = Qnil;
+  /* change the variable name so that we can mix modules
+     compiled with older SWIG's - this used to be called "@__trackings__" */
+  ID trackings_id = rb_intern( "@__safetrackings__" );
+  VALUE verbose = rb_gv_get("VERBOSE");
+  rb_gv_set("VERBOSE", Qfalse);
+  trackings_value = rb_ivar_get( _mSWIG, trackings_id );
+  rb_gv_set("VERBOSE", verbose);
+
+  /* The trick here is that we have to store the hash table
+  pointer in a Ruby variable. We do not want Ruby's GC to
+  treat this pointer as a Ruby object, so we convert it to
+  a Ruby numeric value. */
+  if (trackings_value == Qnil) {
+    /* No, it hasn't.  Create one ourselves */
+    swig_ruby_trackings = st_init_numtable();
+    rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
+  } else {
+    swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
+  }
+
+        rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", RUBY_VALUE_METHOD_FUNC(swig_ruby_trackings_count), RUBY_VOID_METHOD_FUNC((rb_gvar_setter_t*)NULL))
+;
+}
+
+/* Add a Tracking from a C/C++ struct to a Ruby object */
+SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
+  /* Store the mapping to the global hash table. */
+  st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
+}
+
+/* Get the Ruby object that owns the specified C/C++ struct */
+SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
+  /* Now lookup the value stored in the global hash table */
+  VALUE value;
+
+  if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
+    return value;
+  } else {
+    return Qnil;
+  }
+}
+
+/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
+   is very important to remove objects once they are destroyed
+   since the same memory address may be reused later to create
+   a new object. */
+SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
+  /* Delete the object from the hash table */
+  st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
+}
+
+/* This is a helper method that unlinks a Ruby object from its
+   underlying C++ object.  This is needed if the lifetime of the
+   Ruby object is longer than the C++ object */
+SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
+  VALUE object = SWIG_RubyInstanceFor(ptr);
+
+  if (object != Qnil) {
+    if (TYPE(object) != T_DATA)
+      abort();
+    DATA_PTR(object) = 0;
+  }
+}
+
+/* This is a helper method that iterates over all the trackings
+   passing the C++ object pointer and its related Ruby object
+   to the passed callback function. */
+
+/* Proxy method to abstract the internal trackings datatype */
+      static int swig_ruby_internal_iterate_callback(st_data_t ptr, st_data_t obj, st_data_t meth) {
+        ((void(*)(void*, VALUE))meth)((void*)ptr, (VALUE)obj);
+
+  return ST_CONTINUE;
+}
+
+SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
+  st_foreach(swig_ruby_trackings, RUBY_INT_METHOD_FUNC(swig_ruby_internal_iterate_callback), (st_data_t)meth);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Ruby API portion that goes into the runtime
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGINTERN VALUE
+SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
+  if (NIL_P(target)) {
+    target = o;
+  } else {
+    if (TYPE(target) != T_ARRAY) {
+      VALUE o2 = target;
+      target = rb_ary_new();
+      rb_ary_push(target, o2);
+    }
+    rb_ary_push(target, o);
+  }
+  return target;
+}
+
+/* For ruby1.8.4 and earlier. */
+#ifndef RUBY_INIT_STACK
+   RUBY_EXTERN void Init_stack(VALUE* addr);
+#  define RUBY_INIT_STACK \
+   VALUE variable_in_this_stack_frame; \
+   Init_stack(&variable_in_this_stack_frame);
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* -----------------------------------------------------------------------------
+ * rubyrun.swg
+ *
+ * This file contains the runtime support for Ruby modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
+#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
+#define swig_owntype                                    swig_ruby_owntype
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) 		SWIG_Ruby_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
+#define SWIG_Error(code, msg)            		rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
+#define SWIG_fail                        		goto fail				 
+
+
+/* Ruby-specific SWIG API */
+
+#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
+#define SWIG_define_class(ty)                        	SWIG_Ruby_define_class(ty)
+#define SWIG_NewClassInstance(value, ty)             	SWIG_Ruby_NewClassInstance(value, ty)
+#define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
+#define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  
+
+#include "assert.h"
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  VALUE klass;
+  VALUE mImpl;
+  void  (*mark)(void *);
+  void  (*destroy)(void *);
+  int trackObjects;
+} swig_class;
+
+
+/* Global pointer used to keep some internal SWIG stuff */
+static VALUE _cSWIG_Pointer = Qnil;
+static VALUE swig_runtime_data_type_pointer = Qnil;
+
+/* Global IDs used to keep some internal SWIG stuff */
+static ID swig_arity_id = 0;
+static ID swig_call_id  = 0;
+
+/*
+  If your swig extension is to be run within an embedded ruby and has
+  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
+  This will reset ruby's stack frame on each entry point from the main 
+  program the first time a virtual director function is invoked (in a 
+  non-recursive way).
+  If this is not done, you run the risk of Ruby trashing the stack.
+*/
+
+#ifdef RUBY_EMBEDDED
+
+#  define SWIG_INIT_STACK                            \
+      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
+      ++swig_virtual_calls;
+#  define SWIG_RELEASE_STACK --swig_virtual_calls;
+#  define Ruby_DirectorTypeMismatchException(x) \
+          rb_raise( rb_eTypeError, "%s", x ); return c_result;
+
+      static unsigned int swig_virtual_calls = 0;
+
+#else  /* normal non-embedded extension */
+
+#  define SWIG_INIT_STACK
+#  define SWIG_RELEASE_STACK
+#  define Ruby_DirectorTypeMismatchException(x) \
+          throw Swig::DirectorTypeMismatchException( x );
+
+#endif  /* RUBY_EMBEDDED */
+
+
+SWIGRUNTIME VALUE 
+getExceptionClass(void) {
+  static int init = 0;
+  static VALUE rubyExceptionClass ;
+  if (!init) {
+    init = 1;
+    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
+  }
+  return rubyExceptionClass;
+} 
+
+/* This code checks to see if the Ruby object being raised as part
+   of an exception inherits from the Ruby class Exception.  If so,
+   the object is simply returned.  If not, then a new Ruby exception
+   object is created and that will be returned to Ruby.*/
+SWIGRUNTIME VALUE
+SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
+  VALUE exceptionClass = getExceptionClass();
+  if (rb_obj_is_kind_of(obj, exceptionClass)) {
+    return obj;
+  }  else {
+    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
+  }
+}
+
+/* Initialize Ruby runtime support */
+SWIGRUNTIME void
+SWIG_Ruby_InitRuntime(void)
+{
+  if (_mSWIG == Qnil) {
+    _mSWIG = rb_define_module("SWIG");
+    swig_call_id  = rb_intern("call");
+    swig_arity_id = rb_intern("arity");
+  }
+}
+
+/* Define Ruby class for C type */
+SWIGRUNTIME void
+SWIG_Ruby_define_class(swig_type_info *type)
+{
+  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+  sprintf(klass_name, "TYPE%s", type->name);
+  if (NIL_P(_cSWIG_Pointer)) {
+    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
+    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
+  }
+  rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
+  free((void *) klass_name);
+}
+
+/* Create a new pointer object */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
+{
+  int own =  flags & SWIG_POINTER_OWN; 
+  int track;
+  char *klass_name;
+  swig_class *sklass;
+  VALUE klass;
+  VALUE obj;
+  
+  if (!ptr)
+    return Qnil;
+  
+  if (type->clientdata) {
+    sklass = (swig_class *) type->clientdata;
+		
+    /* Are we tracking this class and have we already returned this Ruby object? */
+    track = sklass->trackObjects;
+    if (track) {
+      obj = SWIG_RubyInstanceFor(ptr);
+      
+      /* Check the object's type and make sure it has the correct type.
+        It might not in cases where methods do things like 
+        downcast methods. */
+      if (obj != Qnil) {
+        VALUE value = rb_iv_get(obj, "@__swigtype__");
+        const char* type_name = RSTRING_PTR(value);
+				
+        if (strcmp(type->name, type_name) == 0) {
+          return obj;
+        }
+      }
+    }
+
+    /* Create a new Ruby object */
+    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
+			   ( own ? VOIDFUNC(sklass->destroy) : 
+			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
+			     ), ptr);
+
+    /* If tracking is on for this class then track this object. */
+    if (track) {
+      SWIG_RubyAddTracking(ptr, obj);
+    }
+  } else {
+    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+    sprintf(klass_name, "TYPE%s", type->name);
+    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
+    free((void *) klass_name);
+    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
+  }
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  
+  return obj;
+}
+
+/* Create a new class instance (always owned) */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
+{
+  VALUE obj;
+  swig_class *sklass = (swig_class *) type->clientdata;
+  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  return obj;
+}
+
+/* Get type mangle from class name */
+SWIGRUNTIMEINLINE char *
+SWIG_Ruby_MangleStr(VALUE obj)
+{
+  VALUE stype = rb_iv_get(obj, "@__swigtype__");
+  return StringValuePtr(stype);
+}
+
+/* Acquire a pointer value */
+typedef struct {
+  void (*datafree)(void *);
+  int own;
+} swig_ruby_owntype;
+
+SWIGRUNTIME swig_ruby_owntype
+SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
+  swig_ruby_owntype oldown = {0, 0};
+  if (obj) {
+    oldown.datafree = RDATA(obj)->dfree;
+    RDATA(obj)->dfree = own.datafree;
+  }
+  return oldown;
+}
+
+/* Convert a pointer value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
+{
+  char *c;
+  swig_cast_info *tc;
+  void *vptr = 0;
+
+  /* Grab the pointer */
+  if (NIL_P(obj)) {
+    if (ptr)
+      *ptr = 0;
+    return SWIG_OK;
+  } else {
+    if (TYPE(obj) != T_DATA) {
+      return SWIG_ERROR;
+    }
+    Data_Get_Struct(obj, void, vptr);
+  }
+  
+  if (own) {
+    own->datafree = RDATA(obj)->dfree;
+    own->own = 0;
+  }
+    
+  /* Check to see if the input object is giving up ownership
+     of the underlying C struct or C++ object.  If so then we
+     need to reset the destructor since the Ruby object no 
+     longer owns the underlying C++ object.*/ 
+  if (flags & SWIG_POINTER_DISOWN) {
+    /* Is tracking on for this class? */
+    int track = 0;
+    if (ty && ty->clientdata) {
+      swig_class *sklass = (swig_class *) ty->clientdata;
+      track = sklass->trackObjects;
+    }
+		
+    if (track) {
+      /* We are tracking objects for this class.  Thus we change the destructor
+       * to SWIG_RubyRemoveTracking.  This allows us to
+       * remove the mapping from the C++ to Ruby object
+       * when the Ruby object is garbage collected.  If we don't
+       * do this, then it is possible we will return a reference 
+       * to a Ruby object that no longer exists thereby crashing Ruby. */
+      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
+    } else {    
+      RDATA(obj)->dfree = 0;
+    }
+  }
+
+  /* Do type-checking if type info was provided */
+  if (ty) {
+    if (ty->clientdata) {
+      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
+        if (vptr == 0) {
+          /* The object has already been deleted */
+          return SWIG_ObjectPreviouslyDeletedError;
+        }
+      }
+    }
+    if ((c = SWIG_MangleStr(obj)) == NULL) {
+      return SWIG_ERROR;
+    }
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) {
+      return SWIG_ERROR;
+    } else {
+      if (ptr) {
+        if (tc->type == ty) {
+          *ptr = vptr;
+        } else {
+          int newmemory = 0;
+          *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
+          if (newmemory == SWIG_CAST_NEW_MEMORY) {
+            assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+            if (own)
+              own->own = own->own | SWIG_CAST_NEW_MEMORY;
+          }
+        }
+      }
+    }
+  } else {
+    if (ptr)
+      *ptr = vptr;
+  }
+  
+  return SWIG_OK;
+}
+
+/* Check convert */
+SWIGRUNTIMEINLINE int
+SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
+{
+  char *c = SWIG_MangleStr(obj);
+  if (!c) return 0;
+  return SWIG_TypeCheck(c,ty) != 0;
+}
+
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r, ptr, sz);
+  strcpy(r, type->name);
+  return rb_str_new2(result);
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c;
+
+  if (TYPE(obj) != T_STRING) goto type_error;
+  c = StringValuePtr(obj);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') goto type_error;
+  c++;
+  c = SWIG_UnpackData(c, ptr, sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) goto type_error;
+  }
+  return SWIG_OK;
+
+ type_error:
+  return SWIG_ERROR;
+}
+
+SWIGRUNTIME swig_module_info *
+SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
+{
+  VALUE pointer;
+  swig_module_info *ret = 0;
+  VALUE verbose = rb_gv_get("VERBOSE");
+
+ /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
+  rb_gv_set("VERBOSE", Qfalse);
+  
+  /* first check if pointer already created */
+  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  if (pointer != Qnil) {
+    Data_Get_Struct(pointer, swig_module_info, ret);
+  }
+
+  /* reinstate warnings */
+  rb_gv_set("VERBOSE", verbose);
+  return ret;
+}
+
+SWIGRUNTIME void 
+SWIG_Ruby_SetModule(swig_module_info *pointer)
+{
+  /* register a new class */
+  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
+  /* create and store the structure pointer to a global variable */
+  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
+  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
+}
+
+/* This function can be used to check whether a proc or method or similarly
+   callable function has been passed.  Usually used in a %typecheck, like:
+
+   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
+        $result = SWIG_Ruby_isCallable( $input );
+   }
+ */
+SWIGINTERN
+int SWIG_Ruby_isCallable( VALUE proc )
+{
+  if ( rb_respond_to( proc, swig_call_id ) )
+    return 1;
+  return 0;
+}
+
+/* This function can be used to check the arity (number of arguments)
+   a proc or method can take.  Usually used in a %typecheck.
+   Valid arities will be that equal to minimal or those < 0
+   which indicate a variable number of parameters at the end.
+ */
+SWIGINTERN
+int SWIG_Ruby_arity( VALUE proc, int minimal )
+{
+  if ( rb_respond_to( proc, swig_arity_id ) )
+    {
+      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
+      int arity = NUM2INT(num);
+      if ( arity < 0 && (arity+1) < -minimal ) return 1;
+      if ( arity == minimal ) return 1;
+      return 1;
+    }
+  return 0;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
+
+
+
+  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) 
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_p_FX4Splitter swig_types[0]
+#define SWIGTYPE_p_FX7Segment swig_types[1]
+#define SWIGTYPE_p_FXAccelTable swig_types[2]
+#define SWIGTYPE_p_FXApp swig_types[3]
+#define SWIGTYPE_p_FXArrowButton swig_types[4]
+#define SWIGTYPE_p_FXBMPIcon swig_types[5]
+#define SWIGTYPE_p_FXBMPImage swig_types[6]
+#define SWIGTYPE_p_FXBitmap swig_types[7]
+#define SWIGTYPE_p_FXBitmapFrame swig_types[8]
+#define SWIGTYPE_p_FXCURCursor swig_types[9]
+#define SWIGTYPE_p_FXCanvas swig_types[10]
+#define SWIGTYPE_p_FXColorBar swig_types[11]
+#define SWIGTYPE_p_FXColorRing swig_types[12]
+#define SWIGTYPE_p_FXColorSelector swig_types[13]
+#define SWIGTYPE_p_FXColorWell swig_types[14]
+#define SWIGTYPE_p_FXColorWheel swig_types[15]
+#define SWIGTYPE_p_FXComboBox swig_types[16]
+#define SWIGTYPE_p_FXComposite swig_types[17]
+#define SWIGTYPE_p_FXCursor swig_types[18]
+#define SWIGTYPE_p_FXDataTarget swig_types[19]
+#define SWIGTYPE_p_FXDebugTarget swig_types[20]
+#define SWIGTYPE_p_FXDelegator swig_types[21]
+#define SWIGTYPE_p_FXDial swig_types[22]
+#define SWIGTYPE_p_FXDict swig_types[23]
+#define SWIGTYPE_p_FXDirBox swig_types[24]
+#define SWIGTYPE_p_FXDirSelector swig_types[25]
+#define SWIGTYPE_p_FXDockBar swig_types[26]
+#define SWIGTYPE_p_FXDockHandler swig_types[27]
+#define SWIGTYPE_p_FXDockSite swig_types[28]
+#define SWIGTYPE_p_FXDockTitle swig_types[29]
+#define SWIGTYPE_p_FXDocument swig_types[30]
+#define SWIGTYPE_p_FXDragCorner swig_types[31]
+#define SWIGTYPE_p_FXDrawable swig_types[32]
+#define SWIGTYPE_p_FXDriveBox swig_types[33]
+#define SWIGTYPE_p_FXFileDict swig_types[34]
+#define SWIGTYPE_p_FXFileSelector swig_types[35]
+#define SWIGTYPE_p_FXFileStream swig_types[36]
+#define SWIGTYPE_p_FXFont swig_types[37]
+#define SWIGTYPE_p_FXFontSelector swig_types[38]
+#define SWIGTYPE_p_FXFrame swig_types[39]
+#define SWIGTYPE_p_FXGIFCursor swig_types[40]
+#define SWIGTYPE_p_FXGIFIcon swig_types[41]
+#define SWIGTYPE_p_FXGIFImage swig_types[42]
+#define SWIGTYPE_p_FXGradientBar swig_types[43]
+#define SWIGTYPE_p_FXGroupBox swig_types[44]
+#define SWIGTYPE_p_FXHeader swig_types[45]
+#define SWIGTYPE_p_FXHeaderItem swig_types[46]
+#define SWIGTYPE_p_FXHorizontalFrame swig_types[47]
+#define SWIGTYPE_p_FXHorizontalSeparator swig_types[48]
+#define SWIGTYPE_p_FXICOIcon swig_types[49]
+#define SWIGTYPE_p_FXICOImage swig_types[50]
+#define SWIGTYPE_p_FXIcon swig_types[51]
+#define SWIGTYPE_p_FXIconDict swig_types[52]
+#define SWIGTYPE_p_FXIconSource swig_types[53]
+#define SWIGTYPE_p_FXId swig_types[54]
+#define SWIGTYPE_p_FXImage swig_types[55]
+#define SWIGTYPE_p_FXImageFrame swig_types[56]
+#define SWIGTYPE_p_FXImageView swig_types[57]
+#define SWIGTYPE_p_FXJPGIcon swig_types[58]
+#define SWIGTYPE_p_FXJPGImage swig_types[59]
+#define SWIGTYPE_p_FXKnob swig_types[60]
+#define SWIGTYPE_p_FXListBox swig_types[61]
+#define SWIGTYPE_p_FXMainWindow swig_types[62]
+#define SWIGTYPE_p_FXMatrix swig_types[63]
+#define SWIGTYPE_p_FXMemoryStream swig_types[64]
+#define SWIGTYPE_p_FXObject swig_types[65]
+#define SWIGTYPE_p_FXPCXIcon swig_types[66]
+#define SWIGTYPE_p_FXPCXImage swig_types[67]
+#define SWIGTYPE_p_FXPNGIcon swig_types[68]
+#define SWIGTYPE_p_FXPNGImage swig_types[69]
+#define SWIGTYPE_p_FXPPMIcon swig_types[70]
+#define SWIGTYPE_p_FXPPMImage swig_types[71]
+#define SWIGTYPE_p_FXPacker swig_types[72]
+#define SWIGTYPE_p_FXPopup swig_types[73]
+#define SWIGTYPE_p_FXProgressBar swig_types[74]
+#define SWIGTYPE_p_FXRGBIcon swig_types[75]
+#define SWIGTYPE_p_FXRGBImage swig_types[76]
+#define SWIGTYPE_p_FXRealSlider swig_types[77]
+#define SWIGTYPE_p_FXRealSpinner swig_types[78]
+#define SWIGTYPE_p_FXRecentFiles swig_types[79]
+#define SWIGTYPE_p_FXRegistry swig_types[80]
+#define SWIGTYPE_p_FXRootWindow swig_types[81]
+#define SWIGTYPE_p_FXRuler swig_types[82]
+#define SWIGTYPE_p_FXRulerView swig_types[83]
+#define SWIGTYPE_p_FXScrollArea swig_types[84]
+#define SWIGTYPE_p_FXScrollBar swig_types[85]
+#define SWIGTYPE_p_FXScrollCorner swig_types[86]
+#define SWIGTYPE_p_FXScrollWindow swig_types[87]
+#define SWIGTYPE_p_FXSeparator swig_types[88]
+#define SWIGTYPE_p_FXSettings swig_types[89]
+#define SWIGTYPE_p_FXShell swig_types[90]
+#define SWIGTYPE_p_FXShutter swig_types[91]
+#define SWIGTYPE_p_FXShutterItem swig_types[92]
+#define SWIGTYPE_p_FXSlider swig_types[93]
+#define SWIGTYPE_p_FXSpinner swig_types[94]
+#define SWIGTYPE_p_FXSplashWindow swig_types[95]
+#define SWIGTYPE_p_FXSplitter swig_types[96]
+#define SWIGTYPE_p_FXSpring swig_types[97]
+#define SWIGTYPE_p_FXStatusBar swig_types[98]
+#define SWIGTYPE_p_FXStatusLine swig_types[99]
+#define SWIGTYPE_p_FXStream swig_types[100]
+#define SWIGTYPE_p_FXStringDict swig_types[101]
+#define SWIGTYPE_p_FXSwitcher swig_types[102]
+#define SWIGTYPE_p_FXTGAIcon swig_types[103]
+#define SWIGTYPE_p_FXTGAImage swig_types[104]
+#define SWIGTYPE_p_FXTIFIcon swig_types[105]
+#define SWIGTYPE_p_FXTIFImage swig_types[106]
+#define SWIGTYPE_p_FXTabBar swig_types[107]
+#define SWIGTYPE_p_FXTabBook swig_types[108]
+#define SWIGTYPE_p_FXTextField swig_types[109]
+#define SWIGTYPE_p_FXToolBar swig_types[110]
+#define SWIGTYPE_p_FXToolBarGrip swig_types[111]
+#define SWIGTYPE_p_FXToolBarShell swig_types[112]
+#define SWIGTYPE_p_FXToolBarTab swig_types[113]
+#define SWIGTYPE_p_FXToolTip swig_types[114]
+#define SWIGTYPE_p_FXTopWindow swig_types[115]
+#define SWIGTYPE_p_FXTranslator swig_types[116]
+#define SWIGTYPE_p_FXTreeListBox swig_types[117]
+#define SWIGTYPE_p_FXVerticalFrame swig_types[118]
+#define SWIGTYPE_p_FXVerticalSeparator swig_types[119]
+#define SWIGTYPE_p_FXVisual swig_types[120]
+#define SWIGTYPE_p_FXWindow swig_types[121]
+#define SWIGTYPE_p_FXXBMIcon swig_types[122]
+#define SWIGTYPE_p_FXXBMImage swig_types[123]
+#define SWIGTYPE_p_FXXPMIcon swig_types[124]
+#define SWIGTYPE_p_FXXPMImage swig_types[125]
+#define SWIGTYPE_p_char swig_types[126]
+#define SWIGTYPE_p_double swig_types[127]
+#define SWIGTYPE_p_float swig_types[128]
+#define SWIGTYPE_p_int swig_types[129]
+#define SWIGTYPE_p_long swig_types[130]
+#define SWIGTYPE_p_p_char swig_types[131]
+#define SWIGTYPE_p_short swig_types[132]
+#define SWIGTYPE_p_unsigned_char swig_types[133]
+#define SWIGTYPE_p_unsigned_int swig_types[134]
+#define SWIGTYPE_p_unsigned_long swig_types[135]
+#define SWIGTYPE_p_unsigned_short swig_types[136]
+static swig_type_info *swig_types[138];
+static swig_module_info swig_module = {swig_types, 137, 0, 0, 0, 0};
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
+
+/* -------- TYPES TABLE (END) -------- */
+
+#define SWIG_init    Init_icons
+#define SWIG_name    "Icons"
+
+
+
+#define SWIG_RUBY_THREAD_BEGIN_BLOCK
+#define SWIG_RUBY_THREAD_END_BLOCK
+
+
+#define SWIGVERSION 0x030012 
+#define SWIG_VERSION SWIGVERSION
+
+
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
+
+
+#include <stdexcept>
+
+
+#include "FXRbCommon.h"
+
+
+inline FXColor to_FXColor(VALUE obj){
+  if(TYPE(obj)==T_STRING){
+    return fxcolorfromname(StringValuePtr(obj));
+    }
+  else if(TYPE(obj)==T_SYMBOL){
+    return fxcolorfromname(rb_id2name(SYM2ID(obj)));
+    }
+  else{
+    return NUM2ULONG(obj);
+    }
+  }
+
+
+inline FXString to_FXString(VALUE obj){
+  if(!NIL_P(obj)){
+    Check_Type(obj,T_STRING);
+    return FXString(StringValuePtr(obj));
+    }
+  else{
+    return FXString::null;
+    }
+  }
+
+
+inline FXbool to_FXbool(VALUE obj){
+  if (obj == Qtrue || obj == Qfalse){
+    return (obj == Qtrue) ? TRUE : FALSE;
+    }
+  else{
+    return static_cast<FXbool>(NUM2UINT(obj));
+    }
+  }
+
+
+static swig_type_info* FXEventTypeInfo=0;
+
+inline void* to_FXEvent(VALUE obj){
+  void* ptr;
+  if(!FXEventTypeInfo){
+    FXEventTypeInfo=SWIG_TypeQuery("FXEvent *");
+    FXASSERT(FXEventTypeInfo!=0);
+    }
+  SWIG_ConvertPtr(obj,&ptr,FXEventTypeInfo,1);
+  return ptr;
+  }
+
+SWIGINTERN FXIcon *new_FXIcon(FXApp *a,FXColor const *PIXELS=0,FXColor clr=0,FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbIcon(a,PIXELS,clr,opts,w,h);
+      }
+
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
+
+
+  #define SWIG_From_long   LONG2NUM 
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_long  (unsigned long value)
+{
+  return ULONG2NUM(value); 
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_int  (unsigned int value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+
+SWIGINTERN VALUE
+SWIG_ruby_failed(VALUE, VALUE)
+{
+  return Qnil;
+} 
+
+
+/*@SWIG:/usr/share/swig3.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE pargs){VALUE *args=(VALUE *)pargs;
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  long *res = (long *)(args[1]);
+  *res = type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj);
+  return obj;
+}
+/*@SWIG@*/
+
+SWIGINTERN int
+SWIG_AsVal_long (VALUE obj, long* val)
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
+    long v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_VALUE_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_VALUE_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_int (VALUE obj, int *val)
+{
+  long v;
+  int res = SWIG_AsVal_long (obj, &v);
+  if (SWIG_IsOK(res)) {
+    if ((v < INT_MIN || v > INT_MAX)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = static_cast< int >(v);
+    }
+  }  
+  return res;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_bool (VALUE obj, bool *val)
+{
+  if (obj == Qtrue) {
+    if (val) *val = true;
+    return SWIG_OK;
+  } else if (obj == Qfalse) {
+    if (val) *val = false;
+    return SWIG_OK;
+  } else {
+    int res = 0;
+    if (SWIG_AsVal_int (obj, &res) == SWIG_OK) {    
+      if (val) *val = res ? true : false;
+      return SWIG_OK;
+    }
+  }  
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_bool  (bool value)
+{
+  return value ? Qtrue : Qfalse;
+}
+
+
+static swig_type_info *FXIcon_dynamic_cast(void **ptr) {
+    FXIcon **ppIcon = reinterpret_cast<FXIcon **>(ptr);
+    FXBMPIcon *pBMPIcon=dynamic_cast<FXBMPIcon*>(*ppIcon);
+    if(pBMPIcon){
+      *ptr=reinterpret_cast<void*>(pBMPIcon);
+      return SWIG_TypeQuery("FXBMPIcon *");
+      }
+    FXGIFIcon *pGIFIcon=dynamic_cast<FXGIFIcon*>(*ppIcon);
+    if(pGIFIcon){
+      *ptr=reinterpret_cast<void*>(pGIFIcon);
+      return SWIG_TypeQuery("FXGIFIcon *");
+      }
+    FXICOIcon *pICOIcon=dynamic_cast<FXICOIcon*>(*ppIcon);
+    if(pICOIcon){
+      *ptr=reinterpret_cast<void*>(pICOIcon);
+      return SWIG_TypeQuery("FXICOIcon *");
+      }
+    FXJPGIcon *pJPGIcon=dynamic_cast<FXJPGIcon*>(*ppIcon);
+    if(pJPGIcon){
+      *ptr=reinterpret_cast<void*>(pJPGIcon);
+      return SWIG_TypeQuery("FXJPGIcon *");
+      }
+    FXPCXIcon *pPCXIcon=dynamic_cast<FXPCXIcon*>(*ppIcon);
+    if(pPCXIcon){
+      *ptr=reinterpret_cast<void*>(pPCXIcon);
+      return SWIG_TypeQuery("FXPCXIcon *");
+      }
+    FXPNGIcon *pPNGIcon=dynamic_cast<FXPNGIcon*>(*ppIcon);
+    if(pPNGIcon){
+      *ptr=reinterpret_cast<void*>(pPNGIcon);
+      return SWIG_TypeQuery("FXPNGIcon *");
+      }
+    FXPPMIcon *pPPMIcon=dynamic_cast<FXPPMIcon*>(*ppIcon);
+    if(pPPMIcon){
+      *ptr=reinterpret_cast<void*>(pPPMIcon);
+      return SWIG_TypeQuery("FXPPMIcon *");
+      }
+    FXRGBIcon *pRGBIcon=dynamic_cast<FXRGBIcon*>(*ppIcon);
+    if(pRGBIcon){
+      *ptr=reinterpret_cast<void*>(pRGBIcon);
+      return SWIG_TypeQuery("FXRGBIcon *");
+      }
+    FXTGAIcon *pTGAIcon=dynamic_cast<FXTGAIcon*>(*ppIcon);
+    if(pTGAIcon){
+      *ptr=reinterpret_cast<void*>(pTGAIcon);
+      return SWIG_TypeQuery("FXTGAIcon *");
+      }
+    FXTIFIcon *pTIFIcon=dynamic_cast<FXTIFIcon*>(*ppIcon);
+    if(pTIFIcon){
+      *ptr=reinterpret_cast<void*>(pTIFIcon);
+      return SWIG_TypeQuery("FXTIFIcon *");
+      }
+    FXXBMIcon *pXBMIcon=dynamic_cast<FXXBMIcon*>(*ppIcon);
+    if(pXBMIcon){
+      *ptr=reinterpret_cast<void*>(pXBMIcon);
+      return SWIG_TypeQuery("FXXBMIcon *");
+      }
+    FXXPMIcon *pXPMIcon=dynamic_cast<FXXPMIcon*>(*ppIcon);
+    if(pXPMIcon){
+      *ptr=reinterpret_cast<void*>(pXPMIcon);
+      return SWIG_TypeQuery("FXXPMIcon *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXIconSource *new_FXIconSource(FXApp *a){
+      return new FXRbIconSource(a);
+      }
+SWIGINTERN VALUE FXBMPIcon_fileExt(){
+      return to_ruby(FXBMPIcon::fileExt);
+      }
+SWIGINTERN VALUE FXBMPIcon_mimeType(){
+      return to_ruby(FXBMPIcon::mimeType);
+      }
+SWIGINTERN FXBMPIcon *new_FXBMPIcon(FXApp *a,void const *pix=0,FXColor clr=0,FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbBMPIcon(a,pix,clr,opts,w,h);
+      }
+
+  /**
+   * Load an BMP (Microsoft Bitmap) file from a stream.
+   * Upon successful return, the pixel array and size are returned.
+   * If an error occurred, the pixel array is set to NULL.
+   */
+  VALUE fxloadBMP(FXStream& store){
+    FXColor* data;
+    FXint width;
+    FXint height;
+    if(fxloadBMP(store,data,width,height)){
+      VALUE ary=rb_ary_new();
+      rb_ary_push(ary,FXRbMakeColorArray(data,width,height));
+      FXFREE(&data);
+      rb_ary_push(ary,to_ruby(width));
+      rb_ary_push(ary,to_ruby(height));
+      return ary;
+      }
+    else{
+      return Qnil;
+      }
+    }
+
+SWIGINTERN VALUE FXGIFIcon_fileExt(){
+      return to_ruby(FXGIFIcon::fileExt);
+      }
+SWIGINTERN VALUE FXGIFIcon_mimeType(){
+      return to_ruby(FXGIFIcon::mimeType);
+      }
+SWIGINTERN FXGIFIcon *new_FXGIFIcon(FXApp *a,void const *pix=0,FXColor clr=0,FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbGIFIcon(a,pix,clr,opts,w,h);
+      }
+SWIGINTERN VALUE FXICOIcon_fileExt(){
+      return to_ruby(FXICOIcon::fileExt);
+      }
+SWIGINTERN VALUE FXICOIcon_mimeType(){
+      return to_ruby(FXICOIcon::mimeType);
+      }
+SWIGINTERN FXICOIcon *new_FXICOIcon(FXApp *a,void const *pix=0,FXColor clr=0,FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbICOIcon(a,pix,clr,opts,w,h);
+      }
+
+/**
+ * Load an ICO (Microsoft icon format) file from a stream.
+ * Upon successful return, the pixel array and size are returned.
+ * If an error occurred, the pixel array is set to NULL.
+ */
+VALUE fxloadICO(FXStream& store){
+  FXColor* data;
+  FXint width;
+  FXint height;
+  FXint xspot;
+  FXint yspot;
+  if(fxloadICO(store,data,width,height,xspot,yspot)){
+    VALUE ary=rb_ary_new();
+    rb_ary_push(ary,FXRbMakeColorArray(data,width,height));
+    FXFREE(&data);
+    rb_ary_push(ary,to_ruby(width));
+    rb_ary_push(ary,to_ruby(height));
+    rb_ary_push(ary,to_ruby(xspot));
+    rb_ary_push(ary,to_ruby(yspot));
+    return ary;
+    }
+  else{
+    return Qnil;
+    }
+  }
+
+SWIGINTERN VALUE FXJPGIcon_fileExt(){
+      return to_ruby(FXJPGIcon::fileExt);
+      }
+SWIGINTERN VALUE FXJPGIcon_mimeType(){
+      return to_ruby(FXJPGIcon::mimeType);
+      }
+SWIGINTERN bool FXJPGIcon_isSupported(){ return FXJPGIcon::supported; }
+SWIGINTERN FXJPGIcon *new_FXJPGIcon(FXApp *a,void const *pix=0,FXColor clr=0,FXuint opts=0,FXint w=1,FXint h=1,FXint q=75){
+      return new FXRbJPGIcon(a,pix,clr,opts,w,h,q);
+      }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_int  (int value)
+{    
+  return SWIG_From_long  (value);
+}
+
+
+  /**
+   * Load an JPEG (Joint Photographics Experts Group) file from a stream.
+   * Upon successful return, the pixel array and size are returned.
+   * If an error occurred, the pixel array is set to NULL.
+   */
+  VALUE fxloadJPG(FXStream& store){
+    FXColor* data;
+    FXint width,height,quality;
+    if(fxloadJPG(store,data,width,height,quality)){
+      VALUE ary=rb_ary_new();
+      rb_ary_push(ary,FXRbMakeColorArray(data,width,height));
+      FXFREE(&data);
+      rb_ary_push(ary,to_ruby(width));
+      rb_ary_push(ary,to_ruby(height));
+      rb_ary_push(ary,to_ruby(quality));
+      return ary;
+      }
+    else{
+      return Qnil;
+      }
+    }
+
+SWIGINTERN VALUE FXPCXIcon_fileExt(){
+      return to_ruby(FXPCXIcon::fileExt);
+      }
+SWIGINTERN VALUE FXPCXIcon_mimeType(){
+      return to_ruby(FXPCXIcon::mimeType);
+      }
+SWIGINTERN FXPCXIcon *new_FXPCXIcon(FXApp *a,void const *pix=0,FXColor clr=0,FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbPCXIcon(a,pix,clr,opts,w,h);
+      }
+
+  /**
+   * Load an PCX (PC Paintbrush) file from a stream.
+   * Upon successful return, the pixel array and size are returned.
+   * If an error occurred, the pixel array is set to NULL.
+   */
+  VALUE fxloadPCX(FXStream& store){
+    FXColor* data;
+    FXint width;
+    FXint height;
+    if(fxloadPCX(store,data,width,height)){
+      VALUE ary=rb_ary_new();
+      rb_ary_push(ary,FXRbMakeColorArray(data,width,height));
+      FXFREE(&data);
+      rb_ary_push(ary,to_ruby(width));
+      rb_ary_push(ary,to_ruby(height));
+      return ary;
+      }
+    else{
+      return Qnil;
+      }
+    }
+
+SWIGINTERN VALUE FXPNGIcon_fileExt(){
+      return to_ruby(FXPNGIcon::fileExt);
+      }
+SWIGINTERN VALUE FXPNGIcon_mimeType(){
+      return to_ruby(FXPNGIcon::mimeType);
+      }
+SWIGINTERN bool FXPNGIcon_isSupported(){ return FXPNGIcon::supported; }
+SWIGINTERN FXPNGIcon *new_FXPNGIcon(FXApp *a,void const *pix=0,FXColor clr=0,FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbPNGIcon(a,pix,clr,opts,w,h);
+      }
+
+  /**
+   * Load an PNG (Portable Network Graphics) file from a stream.
+   * Upon successful return, the pixel array and size are returned.
+   * If an error occurred, the pixel array is set to NULL.
+   */
+  VALUE fxloadPNG(FXStream& store){
+    FXColor* data;
+    FXint width;
+    FXint height;
+    if(fxloadPNG(store,data,width,height)){
+      VALUE ary=rb_ary_new();
+      rb_ary_push(ary,FXRbMakeColorArray(data,width,height));
+      FXFREE(&data);
+      rb_ary_push(ary,to_ruby(width));
+      rb_ary_push(ary,to_ruby(height));
+      return ary;
+      }
+    else{
+      return Qnil;
+      }
+    }
+
+SWIGINTERN VALUE FXPPMIcon_fileExt(){
+      return to_ruby(FXPPMIcon::fileExt);
+      }
+SWIGINTERN VALUE FXPPMIcon_mimeType(){
+      return to_ruby(FXPPMIcon::mimeType);
+      }
+SWIGINTERN FXPPMIcon *new_FXPPMIcon(FXApp *a,void const *pix=0,FXColor clr=FXRGB(192,192,192),FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbPPMIcon(a,pix,clr,opts,w,h);
+      }
+
+  /**
+   * Load an PPM (Portable Pixmap Format) file from a stream.
+   * Upon successful return, the pixel array and size are returned.
+   * If an error occurred, the pixel array is set to NULL.
+   */
+  VALUE fxloadPPM(FXStream& store){
+    FXColor* data;
+    FXint width;
+    FXint height;
+    if(fxloadPPM(store,data,width,height)){
+      VALUE ary=rb_ary_new();
+      rb_ary_push(ary,FXRbMakeColorArray(data,width,height));
+      FXFREE(&data);
+      rb_ary_push(ary,to_ruby(width));
+      rb_ary_push(ary,to_ruby(height));
+      return ary;
+      }
+    else{
+      return Qnil;
+      }
+    }
+
+SWIGINTERN VALUE FXRGBIcon_fileExt(){
+      return to_ruby(FXRGBIcon::fileExt);
+      }
+SWIGINTERN VALUE FXRGBIcon_mimeType(){
+      return to_ruby(FXRGBIcon::mimeType);
+      }
+SWIGINTERN FXRGBIcon *new_FXRGBIcon(FXApp *a,void const *pix=0,FXColor clr=0,FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbRGBIcon(a,pix,clr,opts,w,h);
+      }
+
+  /**
+   * Load an RGB (SGI IRIS RGB) file from a stream.
+   * Upon successful return, the pixel array and size are returned.
+   * If an error occurred, the pixel array is set to NULL.
+   */
+  VALUE fxloadRGB(FXStream& store){
+    FXColor* data;
+    FXint width;
+    FXint height;
+    if(fxloadRGB(store,data,width,height)){
+      VALUE ary=rb_ary_new();
+      rb_ary_push(ary,FXRbMakeColorArray(data,width,height));
+      FXFREE(&data);
+      rb_ary_push(ary,to_ruby(width));
+      rb_ary_push(ary,to_ruby(height));
+      return ary;
+      }
+    else{
+      return Qnil;
+      }
+    }
+
+SWIGINTERN VALUE FXTGAIcon_fileExt(){
+      return to_ruby(FXTGAIcon::fileExt);
+      }
+SWIGINTERN VALUE FXTGAIcon_mimeType(){
+      return to_ruby(FXTGAIcon::mimeType);
+      }
+SWIGINTERN FXTGAIcon *new_FXTGAIcon(FXApp *a,void const *pix=0,FXColor clr=0,FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbTGAIcon(a,pix,clr,opts,w,h);
+      }
+
+  /// Load a Targa Image from a stream
+  VALUE fxloadTGA(FXStream& store){
+    FXColor* data;
+    FXint width;
+    FXint height;
+    if(fxloadTGA(store,data,width,height)){
+      VALUE ary=rb_ary_new();
+      rb_ary_push(ary,FXRbMakeColorArray(data,width,height));
+      FXFREE(&data);
+      rb_ary_push(ary,to_ruby(width));
+      rb_ary_push(ary,to_ruby(height));
+      return ary;
+      }
+    else{
+      return Qnil;
+      }
+    }
+
+SWIGINTERN VALUE FXTIFIcon_fileExt(){
+      return to_ruby(FXTIFIcon::fileExt);
+      }
+SWIGINTERN VALUE FXTIFIcon_mimeType(){
+      return to_ruby(FXTIFIcon::mimeType);
+      }
+SWIGINTERN bool FXTIFIcon_isSupported(){ return FXTIFIcon::supported; }
+SWIGINTERN FXTIFIcon *new_FXTIFIcon(FXApp *a,void const *pix=0,FXColor clr=0,FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbTIFIcon(a,pix,clr,opts,w,h);
+      }
+SWIGINTERN VALUE FXXBMIcon_fileExt(){
+      return to_ruby(FXXBMIcon::fileExt);
+      }
+SWIGINTERN VALUE FXXBMIcon_mimeType(){
+      return to_ruby(FXXBMIcon::mimeType);
+      }
+SWIGINTERN FXXBMIcon *new_FXXBMIcon(FXApp *a,FXuchar const *pixels=0,FXuchar const *mask=0,FXColor clr=FXRGB(192,192,192),FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbXBMIcon(a,pixels,mask,clr,opts,w,h);
+      }
+SWIGINTERN VALUE FXXPMIcon_fileExt(){
+      return to_ruby(FXXPMIcon::fileExt);
+      }
+SWIGINTERN VALUE FXXPMIcon_mimeType(){
+      return to_ruby(FXXPMIcon::mimeType);
+      }
+SWIGINTERN FXXPMIcon *new_FXXPMIcon(FXApp *a,FXchar const **pix=0,FXColor clr=0,FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbXPMIcon(a,pix,clr,opts,w,h);
+      }
+
+  /// Load an X Pixmap file from a stream
+  VALUE fxloadXPM(FXStream& store){
+    FXColor* data;
+    FXint width;
+    FXint height;
+    if(fxloadXPM(store,data,width,height)){
+      VALUE ary=rb_ary_new();
+      rb_ary_push(ary,FXRbMakeColorArray(data,width,height));
+      FXFREE(&data);
+      rb_ary_push(ary,to_ruby(width));
+      rb_ary_push(ary,to_ruby(height));
+      return ary;
+      }
+    else{
+      return Qnil;
+      }
+    }
+
+  /// Load an X Pixmap file from an array of strings
+  VALUE fxloadXPM(VALUE strArray){
+    long len,i;
+    VALUE str;
+    const FXchar **pix;
+    FXColor* data;
+    FXint width;
+    FXint height;
+    VALUE ary=Qnil;
+
+    // Confirm that the input is an array of strings
+    Check_Type(strArray,T_ARRAY);
+    len=RARRAY_LEN(strArray);
+    for(i=0; i<len; i++){
+      str=rb_ary_entry(strArray,i);
+      Check_Type(str,T_STRING);
+      }
+
+    // Convert to a C array
+    if(FXMALLOC(&pix,FXchar*,len)){
+      for(i=0; i<len; i++){
+        str=rb_ary_entry(strArray,i);
+	pix[i]=StringValuePtr(str);
+	}
+      if(fxloadXPM(pix,data,width,height)){
+	ary=rb_ary_new();
+	rb_ary_push(ary,FXRbMakeColorArray(data,width,height));
+	FXFREE(&data);
+	rb_ary_push(ary,to_ruby(width));
+	rb_ary_push(ary,to_ruby(height));
+	}
+      FXFREE(&pix);
+      }
+    return ary;
+    }
+
+static swig_class SwigClassFXIcon;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXIcon_allocate(VALUE self)
+#else
+_wrap_FXIcon_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXIcon);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXIcon(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXColor *arg2 = (FXColor *) 0 ;
+  FXColor arg3 = (FXColor) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 1 ;
+  FXint arg6 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  
+  if ((argc < 1) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXIcon", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      arg2=NULL;
+      if(argv[1]!=Qnil){
+        Check_Type(argv[1],T_ARRAY);
+        if(FXMALLOC(&arg2,FXColor,RARRAY_LEN(argv[1]))){
+          for(long i=0; i<RARRAY_LEN(argv[1]); i++){
+            arg2[i]=static_cast<FXColor>(NUM2UINT(rb_ary_entry(argv[1],i)));
+          }
+        }
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = to_FXColor(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXIcon *)new_FXIcon(arg1,(unsigned int const *)arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  FXFREE(&arg2);
+  return self;
+fail:
+  FXFREE(&arg2);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_getTransparentColor(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon const *","getTransparentColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  result = (FXColor)((FXIcon const *)arg1)->getTransparentColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_setTransparentColor(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon *","setTransparentColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTransparentColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_save(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXIcon_save((FXIcon const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_load(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXIcon_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_create(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  FXIcon_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_detach(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  FXIcon_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_destroy(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  FXIcon_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_resize(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXIcon_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_restore(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  FXIcon_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_render(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  FXIcon_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_release(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  FXIcon_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_scale(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXIcon_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_mirror(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXIcon_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_rotate(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXIcon_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_crop(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXIcon_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_fill(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXIcon_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_fade(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXIcon_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_xshear(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXIcon_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_yshear(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXIcon_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXIcon_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXIcon_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_gradient(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXIcon_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_blend(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXIcon_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXIcon_savePixels((FXIcon const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIcon_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXIcon *arg1 = (FXIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIcon *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXIcon_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXIconSource;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXIconSource_allocate(VALUE self)
+#else
+_wrap_FXIconSource_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXIconSource);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXIconSource(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIconSource *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXIconSource", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXIconSource *)new_FXIconSource(arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconSource_save(int argc, VALUE *argv, VALUE self) {
+  FXIconSource *arg1 = (FXIconSource *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconSource, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconSource const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconSource * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXIconSource_save((FXIconSource const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconSource_load(int argc, VALUE *argv, VALUE self) {
+  FXIconSource *arg1 = (FXIconSource *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconSource, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconSource *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconSource * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXIconSource_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconSource_loadIconFile(int argc, VALUE *argv, VALUE self) {
+  FXIconSource *arg1 = (FXIconSource *) 0 ;
+  FXString *arg2 = 0 ;
+  FXString const &arg3_defvalue = FXString::null ;
+  FXString *arg3 = (FXString *) &arg3_defvalue ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  SwigValueWrapper< FXString > p3 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconSource, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconSource const *","loadIconFile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconSource * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    p3 = to_FXString(argv[1]); arg3 = &p3;
+  }
+  result = (FXIcon *)FXIconSource_loadIconFile((FXIconSource const *)arg1,(FXString const &)*arg2,(FXString const &)*arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconSource_loadIconData(int argc, VALUE *argv, VALUE self) {
+  FXIconSource *arg1 = (FXIconSource *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXString const &arg3_defvalue = FXString::null ;
+  FXString *arg3 = (FXString *) &arg3_defvalue ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  SwigValueWrapper< FXString > p3 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconSource, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconSource const *","loadIconData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconSource * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","loadIconData", 2, argv[0] )); 
+  }
+  if (argc > 1) {
+    p3 = to_FXString(argv[1]); arg3 = &p3;
+  }
+  result = (FXIcon *)FXIconSource_loadIconData((FXIconSource const *)arg1,(void const *)arg2,(FXString const &)*arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconSource_loadIconStream(int argc, VALUE *argv, VALUE self) {
+  FXIconSource *arg1 = (FXIconSource *) 0 ;
+  FXStream *arg2 = 0 ;
+  FXString const &arg3_defvalue = FXString::null ;
+  FXString *arg3 = (FXString *) &arg3_defvalue ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconSource, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconSource const *","loadIconStream", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconSource * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadIconStream", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadIconStream", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  if (argc > 1) {
+    p3 = to_FXString(argv[1]); arg3 = &p3;
+  }
+  result = (FXIcon *)FXIconSource_loadIconStream((FXIconSource const *)arg1,*arg2,(FXString const &)*arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconSource_loadImageFile(int argc, VALUE *argv, VALUE self) {
+  FXIconSource *arg1 = (FXIconSource *) 0 ;
+  FXString *arg2 = 0 ;
+  FXString const &arg3_defvalue = FXString::null ;
+  FXString *arg3 = (FXString *) &arg3_defvalue ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  SwigValueWrapper< FXString > p3 ;
+  FXImage *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconSource, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconSource const *","loadImageFile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconSource * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    p3 = to_FXString(argv[1]); arg3 = &p3;
+  }
+  result = (FXImage *)FXIconSource_loadImageFile((FXIconSource const *)arg1,(FXString const &)*arg2,(FXString const &)*arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXImage, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconSource_loadImageData(int argc, VALUE *argv, VALUE self) {
+  FXIconSource *arg1 = (FXIconSource *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXString const &arg3_defvalue = FXString::null ;
+  FXString *arg3 = (FXString *) &arg3_defvalue ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  SwigValueWrapper< FXString > p3 ;
+  FXImage *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconSource, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconSource const *","loadImageData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconSource * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","loadImageData", 2, argv[0] )); 
+  }
+  if (argc > 1) {
+    p3 = to_FXString(argv[1]); arg3 = &p3;
+  }
+  result = (FXImage *)FXIconSource_loadImageData((FXIconSource const *)arg1,(void const *)arg2,(FXString const &)*arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXImage, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconSource_loadImageStream(int argc, VALUE *argv, VALUE self) {
+  FXIconSource *arg1 = (FXIconSource *) 0 ;
+  FXStream *arg2 = 0 ;
+  FXString const &arg3_defvalue = FXString::null ;
+  FXString *arg3 = (FXString *) &arg3_defvalue ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  FXImage *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconSource, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconSource const *","loadImageStream", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconSource * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadImageStream", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadImageStream", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  if (argc > 1) {
+    p3 = to_FXString(argv[1]); arg3 = &p3;
+  }
+  result = (FXImage *)FXIconSource_loadImageStream((FXIconSource const *)arg1,*arg2,(FXString const &)*arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXImage, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconSource_loadScaledIconFile(int argc, VALUE *argv, VALUE self) {
+  FXIconSource *arg1 = (FXIconSource *) 0 ;
+  FXString *arg2 = 0 ;
+  FXint arg3 = (FXint) 32 ;
+  FXint arg4 = (FXint) 0 ;
+  FXString const &arg5_defvalue = FXString::null ;
+  FXString *arg5 = (FXString *) &arg5_defvalue ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  SwigValueWrapper< FXString > p5 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconSource, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconSource const *","loadScaledIconFile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconSource * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    p5 = to_FXString(argv[3]); arg5 = &p5;
+  }
+  result = (FXIcon *)FXIconSource_loadScaledIconFile((FXIconSource const *)arg1,(FXString const &)*arg2,arg3,arg4,(FXString const &)*arg5);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconSource_loadScaledIconData(int argc, VALUE *argv, VALUE self) {
+  FXIconSource *arg1 = (FXIconSource *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXint arg3 = (FXint) 32 ;
+  FXint arg4 = (FXint) 0 ;
+  FXString const &arg5_defvalue = FXString::null ;
+  FXString *arg5 = (FXString *) &arg5_defvalue ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  SwigValueWrapper< FXString > p5 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconSource, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconSource const *","loadScaledIconData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconSource * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","loadScaledIconData", 2, argv[0] )); 
+  }
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    p5 = to_FXString(argv[3]); arg5 = &p5;
+  }
+  result = (FXIcon *)FXIconSource_loadScaledIconData((FXIconSource const *)arg1,(void const *)arg2,arg3,arg4,(FXString const &)*arg5);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconSource_loadScaledIconStream(int argc, VALUE *argv, VALUE self) {
+  FXIconSource *arg1 = (FXIconSource *) 0 ;
+  FXStream *arg2 = 0 ;
+  FXint arg3 = (FXint) 32 ;
+  FXint arg4 = (FXint) 0 ;
+  FXString const &arg5_defvalue = FXString::null ;
+  FXString *arg5 = (FXString *) &arg5_defvalue ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXString > p5 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconSource, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconSource const *","loadScaledIconStream", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconSource * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadScaledIconStream", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadScaledIconStream", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    p5 = to_FXString(argv[3]); arg5 = &p5;
+  }
+  result = (FXIcon *)FXIconSource_loadScaledIconStream((FXIconSource const *)arg1,*arg2,arg3,arg4,(FXString const &)*arg5);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconSource_loadScaledImageFile(int argc, VALUE *argv, VALUE self) {
+  FXIconSource *arg1 = (FXIconSource *) 0 ;
+  FXString *arg2 = 0 ;
+  FXint arg3 = (FXint) 32 ;
+  FXint arg4 = (FXint) 0 ;
+  FXString const &arg5_defvalue = FXString::null ;
+  FXString *arg5 = (FXString *) &arg5_defvalue ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  SwigValueWrapper< FXString > p5 ;
+  FXImage *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconSource, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconSource const *","loadScaledImageFile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconSource * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    p5 = to_FXString(argv[3]); arg5 = &p5;
+  }
+  result = (FXImage *)FXIconSource_loadScaledImageFile((FXIconSource const *)arg1,(FXString const &)*arg2,arg3,arg4,(FXString const &)*arg5);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXImage, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconSource_loadScaledImageData(int argc, VALUE *argv, VALUE self) {
+  FXIconSource *arg1 = (FXIconSource *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXint arg3 = (FXint) 32 ;
+  FXint arg4 = (FXint) 0 ;
+  FXString const &arg5_defvalue = FXString::null ;
+  FXString *arg5 = (FXString *) &arg5_defvalue ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 ;
+  SwigValueWrapper< FXString > p5 ;
+  FXImage *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconSource, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconSource const *","loadScaledImageData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconSource * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","loadScaledImageData", 2, argv[0] )); 
+  }
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    p5 = to_FXString(argv[3]); arg5 = &p5;
+  }
+  result = (FXImage *)FXIconSource_loadScaledImageData((FXIconSource const *)arg1,(void const *)arg2,arg3,arg4,(FXString const &)*arg5);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXImage, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXIconSource_loadScaledImageStream(int argc, VALUE *argv, VALUE self) {
+  FXIconSource *arg1 = (FXIconSource *) 0 ;
+  FXStream *arg2 = 0 ;
+  FXint arg3 = (FXint) 32 ;
+  FXint arg4 = (FXint) 0 ;
+  FXString const &arg5_defvalue = FXString::null ;
+  FXString *arg5 = (FXString *) &arg5_defvalue ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXString > p5 ;
+  FXImage *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXIconSource, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXIconSource const *","loadScaledImageStream", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXIconSource * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadScaledImageStream", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadScaledImageStream", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    p5 = to_FXString(argv[3]); arg5 = &p5;
+  }
+  result = (FXImage *)FXIconSource_loadScaledImageStream((FXIconSource const *)arg1,*arg2,arg3,arg4,(FXString const &)*arg5);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXImage, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXBMPIcon;
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXBMPIcon_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXBMPIcon_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXBMPIcon_allocate(VALUE self)
+#else
+_wrap_FXBMPIcon_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXBMPIcon);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXBMPIcon(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXColor arg3 = (FXColor) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 1 ;
+  FXint arg6 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXBMPIcon *result = 0 ;
+  
+  if ((argc < 1) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXBMPIcon", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      if (argv[1] != Qnil) {
+        Check_Type(argv[1], T_STRING);
+        arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
+      } else {
+        arg2 = NULL;
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = to_FXColor(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXBMPIcon *)new_FXBMPIcon(arg1,(void const *)arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_save(int argc, VALUE *argv, VALUE self) {
+  FXBMPIcon *arg1 = (FXBMPIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPIcon const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXBMPIcon_save((FXBMPIcon const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_load(int argc, VALUE *argv, VALUE self) {
+  FXBMPIcon *arg1 = (FXBMPIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPIcon *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXBMPIcon_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_create(int argc, VALUE *argv, VALUE self) {
+  FXBMPIcon *arg1 = (FXBMPIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPIcon *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPIcon * >(argp1);
+  FXBMPIcon_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_detach(int argc, VALUE *argv, VALUE self) {
+  FXBMPIcon *arg1 = (FXBMPIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPIcon *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPIcon * >(argp1);
+  FXBMPIcon_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_destroy(int argc, VALUE *argv, VALUE self) {
+  FXBMPIcon *arg1 = (FXBMPIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPIcon *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPIcon * >(argp1);
+  FXBMPIcon_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_resize(int argc, VALUE *argv, VALUE self) {
+  FXBMPIcon *arg1 = (FXBMPIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPIcon *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXBMPIcon_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_restore(int argc, VALUE *argv, VALUE self) {
+  FXBMPIcon *arg1 = (FXBMPIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPIcon *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPIcon * >(argp1);
+  FXBMPIcon_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_render(int argc, VALUE *argv, VALUE self) {
+  FXBMPIcon *arg1 = (FXBMPIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPIcon *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPIcon * >(argp1);
+  FXBMPIcon_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_release(int argc, VALUE *argv, VALUE self) {
+  FXBMPIcon *arg1 = (FXBMPIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPIcon *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPIcon * >(argp1);
+  FXBMPIcon_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_scale(int argc, VALUE *argv, VALUE self) {
+  FXBMPIcon *arg1 = (FXBMPIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPIcon *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXBMPIcon_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_mirror(int argc, VALUE *argv, VALUE self) {
+  FXBMPIcon *arg1 = (FXBMPIcon *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPIcon *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPIcon * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXBMPIcon_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_rotate(int argc, VALUE *argv, VALUE self) {
+  FXBMPIcon *arg1 = (FXBMPIcon *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPIcon *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXBMPIcon_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_crop(int argc, VALUE *argv, VALUE self) {
+  FXBMPIcon *arg1 = (FXBMPIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPIcon *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXBMPIcon_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_fill(int argc, VALUE *argv, VALUE self) {
+  FXBMPIcon *arg1 = (FXBMPIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPIcon *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXBMPIcon_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_fade(int argc, VALUE *argv, VALUE self) {
+  FXBMPIcon *arg1 = (FXBMPIcon *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPIcon *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXBMPIcon_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_xshear(int argc, VALUE *argv, VALUE self) {
+  FXBMPIcon *arg1 = (FXBMPIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPIcon *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXBMPIcon_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_yshear(int argc, VALUE *argv, VALUE self) {
+  FXBMPIcon *arg1 = (FXBMPIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPIcon *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXBMPIcon_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXBMPIcon *arg1 = (FXBMPIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPIcon *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXBMPIcon_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXBMPIcon *arg1 = (FXBMPIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPIcon *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXBMPIcon_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_gradient(int argc, VALUE *argv, VALUE self) {
+  FXBMPIcon *arg1 = (FXBMPIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPIcon *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXBMPIcon_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_blend(int argc, VALUE *argv, VALUE self) {
+  FXBMPIcon *arg1 = (FXBMPIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPIcon *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXBMPIcon_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXBMPIcon *arg1 = (FXBMPIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPIcon const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXBMPIcon_savePixels((FXBMPIcon const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPIcon_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXBMPIcon *arg1 = (FXBMPIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPIcon *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXBMPIcon_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxloadBMP(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxloadBMP", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxloadBMP", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (VALUE)fxloadBMP(*arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxsaveBMP(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  FXColor *arg2 = (FXColor *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxsaveBMP", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxsaveBMP", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  {
+    arg2=NULL;
+    if(argv[1]!=Qnil){
+      Check_Type(argv[1],T_ARRAY);
+      if(FXMALLOC(&arg2,FXColor,RARRAY_LEN(argv[1]))){
+        for(long i=0; i<RARRAY_LEN(argv[1]); i++){
+          arg2[i]=static_cast<FXColor>(NUM2UINT(rb_ary_entry(argv[1],i)));
+        }
+      }
+    }
+  }
+  arg3 = NUM2INT(argv[2]);
+  arg4 = NUM2INT(argv[3]);
+  result = (bool)fxsaveBMP(*arg1,(unsigned int const *)arg2,arg3,arg4);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  FXFREE(&arg2);
+  return vresult;
+fail:
+  FXFREE(&arg2);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxcheckBMP(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxcheckBMP", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxcheckBMP", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (bool)fxcheckBMP(*arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXGIFIcon;
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXGIFIcon_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXGIFIcon_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXGIFIcon_allocate(VALUE self)
+#else
+_wrap_FXGIFIcon_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXGIFIcon);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXGIFIcon(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXColor arg3 = (FXColor) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 1 ;
+  FXint arg6 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXGIFIcon *result = 0 ;
+  
+  if ((argc < 1) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXGIFIcon", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      if (argv[1] != Qnil) {
+        Check_Type(argv[1], T_STRING);
+        arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
+      } else {
+        arg2 = NULL;
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = to_FXColor(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXGIFIcon *)new_FXGIFIcon(arg1,(void const *)arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_save(int argc, VALUE *argv, VALUE self) {
+  FXGIFIcon *arg1 = (FXGIFIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFIcon const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXGIFIcon_save((FXGIFIcon const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_load(int argc, VALUE *argv, VALUE self) {
+  FXGIFIcon *arg1 = (FXGIFIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFIcon *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXGIFIcon_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_create(int argc, VALUE *argv, VALUE self) {
+  FXGIFIcon *arg1 = (FXGIFIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFIcon *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFIcon * >(argp1);
+  FXGIFIcon_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_detach(int argc, VALUE *argv, VALUE self) {
+  FXGIFIcon *arg1 = (FXGIFIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFIcon *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFIcon * >(argp1);
+  FXGIFIcon_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_destroy(int argc, VALUE *argv, VALUE self) {
+  FXGIFIcon *arg1 = (FXGIFIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFIcon *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFIcon * >(argp1);
+  FXGIFIcon_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_resize(int argc, VALUE *argv, VALUE self) {
+  FXGIFIcon *arg1 = (FXGIFIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFIcon *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXGIFIcon_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_restore(int argc, VALUE *argv, VALUE self) {
+  FXGIFIcon *arg1 = (FXGIFIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFIcon *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFIcon * >(argp1);
+  FXGIFIcon_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_render(int argc, VALUE *argv, VALUE self) {
+  FXGIFIcon *arg1 = (FXGIFIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFIcon *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFIcon * >(argp1);
+  FXGIFIcon_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_release(int argc, VALUE *argv, VALUE self) {
+  FXGIFIcon *arg1 = (FXGIFIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFIcon *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFIcon * >(argp1);
+  FXGIFIcon_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_scale(int argc, VALUE *argv, VALUE self) {
+  FXGIFIcon *arg1 = (FXGIFIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFIcon *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXGIFIcon_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_mirror(int argc, VALUE *argv, VALUE self) {
+  FXGIFIcon *arg1 = (FXGIFIcon *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFIcon *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFIcon * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXGIFIcon_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_rotate(int argc, VALUE *argv, VALUE self) {
+  FXGIFIcon *arg1 = (FXGIFIcon *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFIcon *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXGIFIcon_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_crop(int argc, VALUE *argv, VALUE self) {
+  FXGIFIcon *arg1 = (FXGIFIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFIcon *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXGIFIcon_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_fill(int argc, VALUE *argv, VALUE self) {
+  FXGIFIcon *arg1 = (FXGIFIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFIcon *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXGIFIcon_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_fade(int argc, VALUE *argv, VALUE self) {
+  FXGIFIcon *arg1 = (FXGIFIcon *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFIcon *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXGIFIcon_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_xshear(int argc, VALUE *argv, VALUE self) {
+  FXGIFIcon *arg1 = (FXGIFIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFIcon *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXGIFIcon_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_yshear(int argc, VALUE *argv, VALUE self) {
+  FXGIFIcon *arg1 = (FXGIFIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFIcon *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXGIFIcon_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXGIFIcon *arg1 = (FXGIFIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFIcon *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXGIFIcon_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXGIFIcon *arg1 = (FXGIFIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFIcon *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXGIFIcon_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_gradient(int argc, VALUE *argv, VALUE self) {
+  FXGIFIcon *arg1 = (FXGIFIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFIcon *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXGIFIcon_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_blend(int argc, VALUE *argv, VALUE self) {
+  FXGIFIcon *arg1 = (FXGIFIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFIcon *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXGIFIcon_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXGIFIcon *arg1 = (FXGIFIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFIcon const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXGIFIcon_savePixels((FXGIFIcon const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFIcon_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXGIFIcon *arg1 = (FXGIFIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFIcon *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXGIFIcon_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXICOIcon;
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXICOIcon_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXICOIcon_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXICOIcon_allocate(VALUE self)
+#else
+_wrap_FXICOIcon_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXICOIcon);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXICOIcon(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXColor arg3 = (FXColor) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 1 ;
+  FXint arg6 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXICOIcon *result = 0 ;
+  
+  if ((argc < 1) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXICOIcon", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      if (argv[1] != Qnil) {
+        Check_Type(argv[1], T_STRING);
+        arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
+      } else {
+        arg2 = NULL;
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = to_FXColor(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXICOIcon *)new_FXICOIcon(arg1,(void const *)arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_save(int argc, VALUE *argv, VALUE self) {
+  FXICOIcon *arg1 = (FXICOIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOIcon const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXICOIcon_save((FXICOIcon const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_load(int argc, VALUE *argv, VALUE self) {
+  FXICOIcon *arg1 = (FXICOIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOIcon *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXICOIcon_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_create(int argc, VALUE *argv, VALUE self) {
+  FXICOIcon *arg1 = (FXICOIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOIcon *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOIcon * >(argp1);
+  FXICOIcon_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_detach(int argc, VALUE *argv, VALUE self) {
+  FXICOIcon *arg1 = (FXICOIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOIcon *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOIcon * >(argp1);
+  FXICOIcon_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_destroy(int argc, VALUE *argv, VALUE self) {
+  FXICOIcon *arg1 = (FXICOIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOIcon *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOIcon * >(argp1);
+  FXICOIcon_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_resize(int argc, VALUE *argv, VALUE self) {
+  FXICOIcon *arg1 = (FXICOIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOIcon *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXICOIcon_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_restore(int argc, VALUE *argv, VALUE self) {
+  FXICOIcon *arg1 = (FXICOIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOIcon *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOIcon * >(argp1);
+  FXICOIcon_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_render(int argc, VALUE *argv, VALUE self) {
+  FXICOIcon *arg1 = (FXICOIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOIcon *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOIcon * >(argp1);
+  FXICOIcon_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_release(int argc, VALUE *argv, VALUE self) {
+  FXICOIcon *arg1 = (FXICOIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOIcon *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOIcon * >(argp1);
+  FXICOIcon_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_scale(int argc, VALUE *argv, VALUE self) {
+  FXICOIcon *arg1 = (FXICOIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOIcon *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXICOIcon_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_mirror(int argc, VALUE *argv, VALUE self) {
+  FXICOIcon *arg1 = (FXICOIcon *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOIcon *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOIcon * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXICOIcon_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_rotate(int argc, VALUE *argv, VALUE self) {
+  FXICOIcon *arg1 = (FXICOIcon *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOIcon *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXICOIcon_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_crop(int argc, VALUE *argv, VALUE self) {
+  FXICOIcon *arg1 = (FXICOIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOIcon *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXICOIcon_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_fill(int argc, VALUE *argv, VALUE self) {
+  FXICOIcon *arg1 = (FXICOIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOIcon *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXICOIcon_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_fade(int argc, VALUE *argv, VALUE self) {
+  FXICOIcon *arg1 = (FXICOIcon *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOIcon *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXICOIcon_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_xshear(int argc, VALUE *argv, VALUE self) {
+  FXICOIcon *arg1 = (FXICOIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOIcon *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXICOIcon_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_yshear(int argc, VALUE *argv, VALUE self) {
+  FXICOIcon *arg1 = (FXICOIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOIcon *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXICOIcon_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXICOIcon *arg1 = (FXICOIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOIcon *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXICOIcon_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXICOIcon *arg1 = (FXICOIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOIcon *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXICOIcon_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_gradient(int argc, VALUE *argv, VALUE self) {
+  FXICOIcon *arg1 = (FXICOIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOIcon *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXICOIcon_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_blend(int argc, VALUE *argv, VALUE self) {
+  FXICOIcon *arg1 = (FXICOIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOIcon *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXICOIcon_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXICOIcon *arg1 = (FXICOIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOIcon const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXICOIcon_savePixels((FXICOIcon const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOIcon_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXICOIcon *arg1 = (FXICOIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOIcon *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXICOIcon_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxloadICO(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxloadICO", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxloadICO", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (VALUE)fxloadICO(*arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxsaveICO(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  FXColor *arg2 = (FXColor *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 = (FXint) -1 ;
+  FXint arg6 = (FXint) -1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxsaveICO", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxsaveICO", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  {
+    arg2=NULL;
+    if(argv[1]!=Qnil){
+      Check_Type(argv[1],T_ARRAY);
+      if(FXMALLOC(&arg2,FXColor,RARRAY_LEN(argv[1]))){
+        for(long i=0; i<RARRAY_LEN(argv[1]); i++){
+          arg2[i]=static_cast<FXColor>(NUM2UINT(rb_ary_entry(argv[1],i)));
+        }
+      }
+    }
+  }
+  arg3 = NUM2INT(argv[2]);
+  arg4 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  result = (bool)fxsaveICO(*arg1,(unsigned int const *)arg2,arg3,arg4,arg5,arg6);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  FXFREE(&arg2);
+  return vresult;
+fail:
+  FXFREE(&arg2);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxcheckICO(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxcheckICO", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxcheckICO", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (bool)fxcheckICO(*arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXJPGIcon;
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXJPGIcon_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXJPGIcon_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_supported_Sq_(int argc, VALUE *argv, VALUE self) {
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (bool)FXJPGIcon_isSupported();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXJPGIcon_allocate(VALUE self)
+#else
+_wrap_FXJPGIcon_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXJPGIcon);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXJPGIcon(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXColor arg3 = (FXColor) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 1 ;
+  FXint arg6 = (FXint) 1 ;
+  FXint arg7 = (FXint) 75 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXJPGIcon *result = 0 ;
+  
+  if ((argc < 1) || (argc > 7)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXJPGIcon", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      if (argv[1] != Qnil) {
+        Check_Type(argv[1], T_STRING);
+        arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
+      } else {
+        arg2 = NULL;
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = to_FXColor(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXJPGIcon *)new_FXJPGIcon(arg1,(void const *)arg2,arg3,arg4,arg5,arg6,arg7);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_setQuality(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon *","setQuality", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setQuality(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_getQuality(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon const *","getQuality", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  result = (FXint)((FXJPGIcon const *)arg1)->getQuality();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_save(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXJPGIcon_save((FXJPGIcon const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_load(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXJPGIcon_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_create(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  FXJPGIcon_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_detach(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  FXJPGIcon_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_destroy(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  FXJPGIcon_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_resize(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXJPGIcon_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_restore(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  FXJPGIcon_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_render(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  FXJPGIcon_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_release(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  FXJPGIcon_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_scale(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXJPGIcon_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_mirror(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXJPGIcon_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_rotate(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXJPGIcon_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_crop(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXJPGIcon_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_fill(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXJPGIcon_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_fade(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXJPGIcon_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_xshear(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXJPGIcon_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_yshear(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXJPGIcon_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXJPGIcon_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXJPGIcon_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_gradient(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXJPGIcon_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_blend(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXJPGIcon_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXJPGIcon_savePixels((FXJPGIcon const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGIcon_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXJPGIcon *arg1 = (FXJPGIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGIcon *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXJPGIcon_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxloadJPG(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxloadJPG", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxloadJPG", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (VALUE)fxloadJPG(*arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxsaveJPG(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  FXColor *arg2 = (FXColor *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 5) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxsaveJPG", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxsaveJPG", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  {
+    arg2=NULL;
+    if(argv[1]!=Qnil){
+      Check_Type(argv[1],T_ARRAY);
+      if(FXMALLOC(&arg2,FXColor,RARRAY_LEN(argv[1]))){
+        for(long i=0; i<RARRAY_LEN(argv[1]); i++){
+          arg2[i]=static_cast<FXColor>(NUM2UINT(rb_ary_entry(argv[1],i)));
+        }
+      }
+    }
+  }
+  arg3 = NUM2INT(argv[2]);
+  arg4 = NUM2INT(argv[3]);
+  arg5 = NUM2INT(argv[4]);
+  result = (bool)fxsaveJPG(*arg1,(unsigned int const *)arg2,arg3,arg4,arg5);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  FXFREE(&arg2);
+  return vresult;
+fail:
+  FXFREE(&arg2);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxcheckJPG(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxcheckJPG", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxcheckJPG", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (bool)fxcheckJPG(*arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXPCXIcon;
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXPCXIcon_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXPCXIcon_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXPCXIcon_allocate(VALUE self)
+#else
+_wrap_FXPCXIcon_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXPCXIcon);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXPCXIcon(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXColor arg3 = (FXColor) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 1 ;
+  FXint arg6 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPCXIcon *result = 0 ;
+  
+  if ((argc < 1) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXPCXIcon", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      if (argv[1] != Qnil) {
+        Check_Type(argv[1], T_STRING);
+        arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
+      } else {
+        arg2 = NULL;
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = to_FXColor(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXPCXIcon *)new_FXPCXIcon(arg1,(void const *)arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_save(int argc, VALUE *argv, VALUE self) {
+  FXPCXIcon *arg1 = (FXPCXIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXIcon const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXPCXIcon_save((FXPCXIcon const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_load(int argc, VALUE *argv, VALUE self) {
+  FXPCXIcon *arg1 = (FXPCXIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXIcon *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXPCXIcon_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_create(int argc, VALUE *argv, VALUE self) {
+  FXPCXIcon *arg1 = (FXPCXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXIcon *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXIcon * >(argp1);
+  FXPCXIcon_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_detach(int argc, VALUE *argv, VALUE self) {
+  FXPCXIcon *arg1 = (FXPCXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXIcon *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXIcon * >(argp1);
+  FXPCXIcon_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_destroy(int argc, VALUE *argv, VALUE self) {
+  FXPCXIcon *arg1 = (FXPCXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXIcon *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXIcon * >(argp1);
+  FXPCXIcon_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_resize(int argc, VALUE *argv, VALUE self) {
+  FXPCXIcon *arg1 = (FXPCXIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXIcon *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXPCXIcon_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_restore(int argc, VALUE *argv, VALUE self) {
+  FXPCXIcon *arg1 = (FXPCXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXIcon *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXIcon * >(argp1);
+  FXPCXIcon_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_render(int argc, VALUE *argv, VALUE self) {
+  FXPCXIcon *arg1 = (FXPCXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXIcon *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXIcon * >(argp1);
+  FXPCXIcon_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_release(int argc, VALUE *argv, VALUE self) {
+  FXPCXIcon *arg1 = (FXPCXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXIcon *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXIcon * >(argp1);
+  FXPCXIcon_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_scale(int argc, VALUE *argv, VALUE self) {
+  FXPCXIcon *arg1 = (FXPCXIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXIcon *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXPCXIcon_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_mirror(int argc, VALUE *argv, VALUE self) {
+  FXPCXIcon *arg1 = (FXPCXIcon *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXIcon *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXIcon * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXPCXIcon_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_rotate(int argc, VALUE *argv, VALUE self) {
+  FXPCXIcon *arg1 = (FXPCXIcon *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXIcon *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXPCXIcon_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_crop(int argc, VALUE *argv, VALUE self) {
+  FXPCXIcon *arg1 = (FXPCXIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXIcon *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXPCXIcon_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_fill(int argc, VALUE *argv, VALUE self) {
+  FXPCXIcon *arg1 = (FXPCXIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXIcon *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXPCXIcon_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_fade(int argc, VALUE *argv, VALUE self) {
+  FXPCXIcon *arg1 = (FXPCXIcon *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXIcon *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXPCXIcon_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_xshear(int argc, VALUE *argv, VALUE self) {
+  FXPCXIcon *arg1 = (FXPCXIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXIcon *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXPCXIcon_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_yshear(int argc, VALUE *argv, VALUE self) {
+  FXPCXIcon *arg1 = (FXPCXIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXIcon *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXPCXIcon_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXPCXIcon *arg1 = (FXPCXIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXIcon *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXPCXIcon_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXPCXIcon *arg1 = (FXPCXIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXIcon *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXPCXIcon_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_gradient(int argc, VALUE *argv, VALUE self) {
+  FXPCXIcon *arg1 = (FXPCXIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXIcon *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXPCXIcon_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_blend(int argc, VALUE *argv, VALUE self) {
+  FXPCXIcon *arg1 = (FXPCXIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXIcon *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXPCXIcon_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXPCXIcon *arg1 = (FXPCXIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXIcon const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXPCXIcon_savePixels((FXPCXIcon const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXIcon_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXPCXIcon *arg1 = (FXPCXIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXIcon *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXPCXIcon_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxloadPCX(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxloadPCX", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxloadPCX", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (VALUE)fxloadPCX(*arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxsavePCX(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  FXColor *arg2 = (FXColor *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxsavePCX", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxsavePCX", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  {
+    arg2=NULL;
+    if(argv[1]!=Qnil){
+      Check_Type(argv[1],T_ARRAY);
+      if(FXMALLOC(&arg2,FXColor,RARRAY_LEN(argv[1]))){
+        for(long i=0; i<RARRAY_LEN(argv[1]); i++){
+          arg2[i]=static_cast<FXColor>(NUM2UINT(rb_ary_entry(argv[1],i)));
+        }
+      }
+    }
+  }
+  arg3 = NUM2INT(argv[2]);
+  arg4 = NUM2INT(argv[3]);
+  result = (bool)fxsavePCX(*arg1,(unsigned int const *)arg2,arg3,arg4);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  FXFREE(&arg2);
+  return vresult;
+fail:
+  FXFREE(&arg2);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxcheckPCX(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxcheckPCX", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxcheckPCX", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (bool)fxcheckPCX(*arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXPNGIcon;
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXPNGIcon_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXPNGIcon_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_supported_Sq_(int argc, VALUE *argv, VALUE self) {
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (bool)FXPNGIcon_isSupported();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXPNGIcon_allocate(VALUE self)
+#else
+_wrap_FXPNGIcon_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXPNGIcon);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXPNGIcon(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXColor arg3 = (FXColor) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 1 ;
+  FXint arg6 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPNGIcon *result = 0 ;
+  
+  if ((argc < 1) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXPNGIcon", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      if (argv[1] != Qnil) {
+        Check_Type(argv[1], T_STRING);
+        arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
+      } else {
+        arg2 = NULL;
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = to_FXColor(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXPNGIcon *)new_FXPNGIcon(arg1,(void const *)arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_save(int argc, VALUE *argv, VALUE self) {
+  FXPNGIcon *arg1 = (FXPNGIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGIcon const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXPNGIcon_save((FXPNGIcon const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_load(int argc, VALUE *argv, VALUE self) {
+  FXPNGIcon *arg1 = (FXPNGIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGIcon *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXPNGIcon_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_create(int argc, VALUE *argv, VALUE self) {
+  FXPNGIcon *arg1 = (FXPNGIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGIcon *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGIcon * >(argp1);
+  FXPNGIcon_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_detach(int argc, VALUE *argv, VALUE self) {
+  FXPNGIcon *arg1 = (FXPNGIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGIcon *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGIcon * >(argp1);
+  FXPNGIcon_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_destroy(int argc, VALUE *argv, VALUE self) {
+  FXPNGIcon *arg1 = (FXPNGIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGIcon *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGIcon * >(argp1);
+  FXPNGIcon_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_resize(int argc, VALUE *argv, VALUE self) {
+  FXPNGIcon *arg1 = (FXPNGIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGIcon *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXPNGIcon_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_restore(int argc, VALUE *argv, VALUE self) {
+  FXPNGIcon *arg1 = (FXPNGIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGIcon *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGIcon * >(argp1);
+  FXPNGIcon_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_render(int argc, VALUE *argv, VALUE self) {
+  FXPNGIcon *arg1 = (FXPNGIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGIcon *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGIcon * >(argp1);
+  FXPNGIcon_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_release(int argc, VALUE *argv, VALUE self) {
+  FXPNGIcon *arg1 = (FXPNGIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGIcon *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGIcon * >(argp1);
+  FXPNGIcon_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_scale(int argc, VALUE *argv, VALUE self) {
+  FXPNGIcon *arg1 = (FXPNGIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGIcon *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXPNGIcon_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_mirror(int argc, VALUE *argv, VALUE self) {
+  FXPNGIcon *arg1 = (FXPNGIcon *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGIcon *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGIcon * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXPNGIcon_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_rotate(int argc, VALUE *argv, VALUE self) {
+  FXPNGIcon *arg1 = (FXPNGIcon *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGIcon *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXPNGIcon_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_crop(int argc, VALUE *argv, VALUE self) {
+  FXPNGIcon *arg1 = (FXPNGIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGIcon *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXPNGIcon_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_fill(int argc, VALUE *argv, VALUE self) {
+  FXPNGIcon *arg1 = (FXPNGIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGIcon *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXPNGIcon_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_fade(int argc, VALUE *argv, VALUE self) {
+  FXPNGIcon *arg1 = (FXPNGIcon *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGIcon *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXPNGIcon_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_xshear(int argc, VALUE *argv, VALUE self) {
+  FXPNGIcon *arg1 = (FXPNGIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGIcon *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXPNGIcon_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_yshear(int argc, VALUE *argv, VALUE self) {
+  FXPNGIcon *arg1 = (FXPNGIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGIcon *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXPNGIcon_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXPNGIcon *arg1 = (FXPNGIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGIcon *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXPNGIcon_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXPNGIcon *arg1 = (FXPNGIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGIcon *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXPNGIcon_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_gradient(int argc, VALUE *argv, VALUE self) {
+  FXPNGIcon *arg1 = (FXPNGIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGIcon *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXPNGIcon_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_blend(int argc, VALUE *argv, VALUE self) {
+  FXPNGIcon *arg1 = (FXPNGIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGIcon *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXPNGIcon_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXPNGIcon *arg1 = (FXPNGIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGIcon const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXPNGIcon_savePixels((FXPNGIcon const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGIcon_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXPNGIcon *arg1 = (FXPNGIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGIcon *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXPNGIcon_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxloadPNG(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxloadPNG", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxloadPNG", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (VALUE)fxloadPNG(*arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxsavePNG(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  FXColor *arg2 = (FXColor *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxsavePNG", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxsavePNG", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  {
+    arg2=NULL;
+    if(argv[1]!=Qnil){
+      Check_Type(argv[1],T_ARRAY);
+      if(FXMALLOC(&arg2,FXColor,RARRAY_LEN(argv[1]))){
+        for(long i=0; i<RARRAY_LEN(argv[1]); i++){
+          arg2[i]=static_cast<FXColor>(NUM2UINT(rb_ary_entry(argv[1],i)));
+        }
+      }
+    }
+  }
+  arg3 = NUM2INT(argv[2]);
+  arg4 = NUM2INT(argv[3]);
+  result = (bool)fxsavePNG(*arg1,(unsigned int const *)arg2,arg3,arg4);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  FXFREE(&arg2);
+  return vresult;
+fail:
+  FXFREE(&arg2);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxcheckPNG(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxcheckPNG", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxcheckPNG", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (bool)fxcheckPNG(*arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXPPMIcon;
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXPPMIcon_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXPPMIcon_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXPPMIcon_allocate(VALUE self)
+#else
+_wrap_FXPPMIcon_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXPPMIcon);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXPPMIcon(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXColor arg3 = (FXColor) FXRGB(192,192,192) ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 1 ;
+  FXint arg6 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPPMIcon *result = 0 ;
+  
+  if ((argc < 1) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXPPMIcon", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      if (argv[1] != Qnil) {
+        Check_Type(argv[1], T_STRING);
+        arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
+      } else {
+        arg2 = NULL;
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = to_FXColor(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXPPMIcon *)new_FXPPMIcon(arg1,(void const *)arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_save(int argc, VALUE *argv, VALUE self) {
+  FXPPMIcon *arg1 = (FXPPMIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMIcon const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXPPMIcon_save((FXPPMIcon const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_load(int argc, VALUE *argv, VALUE self) {
+  FXPPMIcon *arg1 = (FXPPMIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMIcon *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXPPMIcon_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_create(int argc, VALUE *argv, VALUE self) {
+  FXPPMIcon *arg1 = (FXPPMIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMIcon *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMIcon * >(argp1);
+  FXPPMIcon_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_detach(int argc, VALUE *argv, VALUE self) {
+  FXPPMIcon *arg1 = (FXPPMIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMIcon *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMIcon * >(argp1);
+  FXPPMIcon_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_destroy(int argc, VALUE *argv, VALUE self) {
+  FXPPMIcon *arg1 = (FXPPMIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMIcon *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMIcon * >(argp1);
+  FXPPMIcon_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_resize(int argc, VALUE *argv, VALUE self) {
+  FXPPMIcon *arg1 = (FXPPMIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMIcon *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXPPMIcon_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_restore(int argc, VALUE *argv, VALUE self) {
+  FXPPMIcon *arg1 = (FXPPMIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMIcon *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMIcon * >(argp1);
+  FXPPMIcon_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_render(int argc, VALUE *argv, VALUE self) {
+  FXPPMIcon *arg1 = (FXPPMIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMIcon *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMIcon * >(argp1);
+  FXPPMIcon_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_release(int argc, VALUE *argv, VALUE self) {
+  FXPPMIcon *arg1 = (FXPPMIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMIcon *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMIcon * >(argp1);
+  FXPPMIcon_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_scale(int argc, VALUE *argv, VALUE self) {
+  FXPPMIcon *arg1 = (FXPPMIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMIcon *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXPPMIcon_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_mirror(int argc, VALUE *argv, VALUE self) {
+  FXPPMIcon *arg1 = (FXPPMIcon *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMIcon *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMIcon * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXPPMIcon_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_rotate(int argc, VALUE *argv, VALUE self) {
+  FXPPMIcon *arg1 = (FXPPMIcon *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMIcon *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXPPMIcon_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_crop(int argc, VALUE *argv, VALUE self) {
+  FXPPMIcon *arg1 = (FXPPMIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMIcon *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXPPMIcon_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_fill(int argc, VALUE *argv, VALUE self) {
+  FXPPMIcon *arg1 = (FXPPMIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMIcon *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXPPMIcon_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_fade(int argc, VALUE *argv, VALUE self) {
+  FXPPMIcon *arg1 = (FXPPMIcon *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMIcon *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXPPMIcon_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_xshear(int argc, VALUE *argv, VALUE self) {
+  FXPPMIcon *arg1 = (FXPPMIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMIcon *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXPPMIcon_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_yshear(int argc, VALUE *argv, VALUE self) {
+  FXPPMIcon *arg1 = (FXPPMIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMIcon *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXPPMIcon_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXPPMIcon *arg1 = (FXPPMIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMIcon *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXPPMIcon_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXPPMIcon *arg1 = (FXPPMIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMIcon *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXPPMIcon_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_gradient(int argc, VALUE *argv, VALUE self) {
+  FXPPMIcon *arg1 = (FXPPMIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMIcon *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXPPMIcon_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_blend(int argc, VALUE *argv, VALUE self) {
+  FXPPMIcon *arg1 = (FXPPMIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMIcon *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXPPMIcon_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXPPMIcon *arg1 = (FXPPMIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMIcon const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXPPMIcon_savePixels((FXPPMIcon const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMIcon_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXPPMIcon *arg1 = (FXPPMIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMIcon *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXPPMIcon_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxloadPPM(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxloadPPM", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxloadPPM", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (VALUE)fxloadPPM(*arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxsavePPM(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  FXColor *arg2 = (FXColor *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxsavePPM", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxsavePPM", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  {
+    arg2=NULL;
+    if(argv[1]!=Qnil){
+      Check_Type(argv[1],T_ARRAY);
+      if(FXMALLOC(&arg2,FXColor,RARRAY_LEN(argv[1]))){
+        for(long i=0; i<RARRAY_LEN(argv[1]); i++){
+          arg2[i]=static_cast<FXColor>(NUM2UINT(rb_ary_entry(argv[1],i)));
+        }
+      }
+    }
+  }
+  arg3 = NUM2INT(argv[2]);
+  arg4 = NUM2INT(argv[3]);
+  result = (bool)fxsavePPM(*arg1,(unsigned int const *)arg2,arg3,arg4);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  FXFREE(&arg2);
+  return vresult;
+fail:
+  FXFREE(&arg2);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxcheckPPM(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxcheckPPM", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxcheckPPM", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (bool)fxcheckPPM(*arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXRGBIcon;
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXRGBIcon_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXRGBIcon_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXRGBIcon_allocate(VALUE self)
+#else
+_wrap_FXRGBIcon_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXRGBIcon);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRGBIcon(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXColor arg3 = (FXColor) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 1 ;
+  FXint arg6 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXRGBIcon *result = 0 ;
+  
+  if ((argc < 1) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXRGBIcon", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      if (argv[1] != Qnil) {
+        Check_Type(argv[1], T_STRING);
+        arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
+      } else {
+        arg2 = NULL;
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = to_FXColor(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXRGBIcon *)new_FXRGBIcon(arg1,(void const *)arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_save(int argc, VALUE *argv, VALUE self) {
+  FXRGBIcon *arg1 = (FXRGBIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBIcon const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXRGBIcon_save((FXRGBIcon const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_load(int argc, VALUE *argv, VALUE self) {
+  FXRGBIcon *arg1 = (FXRGBIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBIcon *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXRGBIcon_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_create(int argc, VALUE *argv, VALUE self) {
+  FXRGBIcon *arg1 = (FXRGBIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBIcon *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBIcon * >(argp1);
+  FXRGBIcon_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_detach(int argc, VALUE *argv, VALUE self) {
+  FXRGBIcon *arg1 = (FXRGBIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBIcon *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBIcon * >(argp1);
+  FXRGBIcon_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_destroy(int argc, VALUE *argv, VALUE self) {
+  FXRGBIcon *arg1 = (FXRGBIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBIcon *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBIcon * >(argp1);
+  FXRGBIcon_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_resize(int argc, VALUE *argv, VALUE self) {
+  FXRGBIcon *arg1 = (FXRGBIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBIcon *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXRGBIcon_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_restore(int argc, VALUE *argv, VALUE self) {
+  FXRGBIcon *arg1 = (FXRGBIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBIcon *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBIcon * >(argp1);
+  FXRGBIcon_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_render(int argc, VALUE *argv, VALUE self) {
+  FXRGBIcon *arg1 = (FXRGBIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBIcon *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBIcon * >(argp1);
+  FXRGBIcon_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_release(int argc, VALUE *argv, VALUE self) {
+  FXRGBIcon *arg1 = (FXRGBIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBIcon *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBIcon * >(argp1);
+  FXRGBIcon_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_scale(int argc, VALUE *argv, VALUE self) {
+  FXRGBIcon *arg1 = (FXRGBIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBIcon *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXRGBIcon_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_mirror(int argc, VALUE *argv, VALUE self) {
+  FXRGBIcon *arg1 = (FXRGBIcon *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBIcon *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBIcon * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXRGBIcon_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_rotate(int argc, VALUE *argv, VALUE self) {
+  FXRGBIcon *arg1 = (FXRGBIcon *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBIcon *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXRGBIcon_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_crop(int argc, VALUE *argv, VALUE self) {
+  FXRGBIcon *arg1 = (FXRGBIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBIcon *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXRGBIcon_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_fill(int argc, VALUE *argv, VALUE self) {
+  FXRGBIcon *arg1 = (FXRGBIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBIcon *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXRGBIcon_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_fade(int argc, VALUE *argv, VALUE self) {
+  FXRGBIcon *arg1 = (FXRGBIcon *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBIcon *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXRGBIcon_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_xshear(int argc, VALUE *argv, VALUE self) {
+  FXRGBIcon *arg1 = (FXRGBIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBIcon *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXRGBIcon_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_yshear(int argc, VALUE *argv, VALUE self) {
+  FXRGBIcon *arg1 = (FXRGBIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBIcon *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXRGBIcon_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXRGBIcon *arg1 = (FXRGBIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBIcon *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXRGBIcon_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXRGBIcon *arg1 = (FXRGBIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBIcon *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXRGBIcon_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_gradient(int argc, VALUE *argv, VALUE self) {
+  FXRGBIcon *arg1 = (FXRGBIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBIcon *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXRGBIcon_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_blend(int argc, VALUE *argv, VALUE self) {
+  FXRGBIcon *arg1 = (FXRGBIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBIcon *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXRGBIcon_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXRGBIcon *arg1 = (FXRGBIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBIcon const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXRGBIcon_savePixels((FXRGBIcon const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBIcon_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXRGBIcon *arg1 = (FXRGBIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBIcon *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXRGBIcon_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxloadRGB(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxloadRGB", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxloadRGB", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (VALUE)fxloadRGB(*arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxsaveRGB(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  FXColor *arg2 = (FXColor *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxsaveRGB", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxsaveRGB", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  {
+    arg2=NULL;
+    if(argv[1]!=Qnil){
+      Check_Type(argv[1],T_ARRAY);
+      if(FXMALLOC(&arg2,FXColor,RARRAY_LEN(argv[1]))){
+        for(long i=0; i<RARRAY_LEN(argv[1]); i++){
+          arg2[i]=static_cast<FXColor>(NUM2UINT(rb_ary_entry(argv[1],i)));
+        }
+      }
+    }
+  }
+  arg3 = NUM2INT(argv[2]);
+  arg4 = NUM2INT(argv[3]);
+  result = (bool)fxsaveRGB(*arg1,(unsigned int const *)arg2,arg3,arg4);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  FXFREE(&arg2);
+  return vresult;
+fail:
+  FXFREE(&arg2);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxcheckRGB(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxcheckRGB", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxcheckRGB", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (bool)fxcheckRGB(*arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXTGAIcon;
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXTGAIcon_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXTGAIcon_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXTGAIcon_allocate(VALUE self)
+#else
+_wrap_FXTGAIcon_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXTGAIcon);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXTGAIcon(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXColor arg3 = (FXColor) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 1 ;
+  FXint arg6 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTGAIcon *result = 0 ;
+  
+  if ((argc < 1) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXTGAIcon", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      if (argv[1] != Qnil) {
+        Check_Type(argv[1], T_STRING);
+        arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
+      } else {
+        arg2 = NULL;
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = to_FXColor(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXTGAIcon *)new_FXTGAIcon(arg1,(void const *)arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_save(int argc, VALUE *argv, VALUE self) {
+  FXTGAIcon *arg1 = (FXTGAIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAIcon const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTGAIcon_save((FXTGAIcon const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_load(int argc, VALUE *argv, VALUE self) {
+  FXTGAIcon *arg1 = (FXTGAIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAIcon *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTGAIcon_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_create(int argc, VALUE *argv, VALUE self) {
+  FXTGAIcon *arg1 = (FXTGAIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAIcon *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAIcon * >(argp1);
+  FXTGAIcon_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_detach(int argc, VALUE *argv, VALUE self) {
+  FXTGAIcon *arg1 = (FXTGAIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAIcon *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAIcon * >(argp1);
+  FXTGAIcon_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_destroy(int argc, VALUE *argv, VALUE self) {
+  FXTGAIcon *arg1 = (FXTGAIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAIcon *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAIcon * >(argp1);
+  FXTGAIcon_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_resize(int argc, VALUE *argv, VALUE self) {
+  FXTGAIcon *arg1 = (FXTGAIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAIcon *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXTGAIcon_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_restore(int argc, VALUE *argv, VALUE self) {
+  FXTGAIcon *arg1 = (FXTGAIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAIcon *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAIcon * >(argp1);
+  FXTGAIcon_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_render(int argc, VALUE *argv, VALUE self) {
+  FXTGAIcon *arg1 = (FXTGAIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAIcon *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAIcon * >(argp1);
+  FXTGAIcon_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_release(int argc, VALUE *argv, VALUE self) {
+  FXTGAIcon *arg1 = (FXTGAIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAIcon *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAIcon * >(argp1);
+  FXTGAIcon_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_scale(int argc, VALUE *argv, VALUE self) {
+  FXTGAIcon *arg1 = (FXTGAIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAIcon *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXTGAIcon_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_mirror(int argc, VALUE *argv, VALUE self) {
+  FXTGAIcon *arg1 = (FXTGAIcon *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAIcon *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAIcon * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXTGAIcon_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_rotate(int argc, VALUE *argv, VALUE self) {
+  FXTGAIcon *arg1 = (FXTGAIcon *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAIcon *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXTGAIcon_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_crop(int argc, VALUE *argv, VALUE self) {
+  FXTGAIcon *arg1 = (FXTGAIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAIcon *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXTGAIcon_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_fill(int argc, VALUE *argv, VALUE self) {
+  FXTGAIcon *arg1 = (FXTGAIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAIcon *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXTGAIcon_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_fade(int argc, VALUE *argv, VALUE self) {
+  FXTGAIcon *arg1 = (FXTGAIcon *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAIcon *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXTGAIcon_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_xshear(int argc, VALUE *argv, VALUE self) {
+  FXTGAIcon *arg1 = (FXTGAIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAIcon *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXTGAIcon_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_yshear(int argc, VALUE *argv, VALUE self) {
+  FXTGAIcon *arg1 = (FXTGAIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAIcon *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXTGAIcon_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXTGAIcon *arg1 = (FXTGAIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAIcon *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXTGAIcon_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXTGAIcon *arg1 = (FXTGAIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAIcon *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXTGAIcon_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_gradient(int argc, VALUE *argv, VALUE self) {
+  FXTGAIcon *arg1 = (FXTGAIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAIcon *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXTGAIcon_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_blend(int argc, VALUE *argv, VALUE self) {
+  FXTGAIcon *arg1 = (FXTGAIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAIcon *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXTGAIcon_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXTGAIcon *arg1 = (FXTGAIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAIcon const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXTGAIcon_savePixels((FXTGAIcon const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAIcon_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXTGAIcon *arg1 = (FXTGAIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAIcon *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXTGAIcon_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxloadTGA(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxloadTGA", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxloadTGA", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (VALUE)fxloadTGA(*arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxsaveTGA(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  FXColor *arg2 = (FXColor *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxsaveTGA", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxsaveTGA", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  {
+    arg2=NULL;
+    if(argv[1]!=Qnil){
+      Check_Type(argv[1],T_ARRAY);
+      if(FXMALLOC(&arg2,FXColor,RARRAY_LEN(argv[1]))){
+        for(long i=0; i<RARRAY_LEN(argv[1]); i++){
+          arg2[i]=static_cast<FXColor>(NUM2UINT(rb_ary_entry(argv[1],i)));
+        }
+      }
+    }
+  }
+  arg3 = NUM2INT(argv[2]);
+  arg4 = NUM2INT(argv[3]);
+  result = (bool)fxsaveTGA(*arg1,(unsigned int const *)arg2,arg3,arg4);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  FXFREE(&arg2);
+  return vresult;
+fail:
+  FXFREE(&arg2);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxcheckTGA(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxcheckTGA", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxcheckTGA", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (bool)fxcheckTGA(*arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXTIFIcon;
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXTIFIcon_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXTIFIcon_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_supported_Sq_(int argc, VALUE *argv, VALUE self) {
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (bool)FXTIFIcon_isSupported();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXTIFIcon_allocate(VALUE self)
+#else
+_wrap_FXTIFIcon_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXTIFIcon);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXTIFIcon(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXColor arg3 = (FXColor) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 1 ;
+  FXint arg6 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTIFIcon *result = 0 ;
+  
+  if ((argc < 1) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXTIFIcon", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      if (argv[1] != Qnil) {
+        Check_Type(argv[1], T_STRING);
+        arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
+      } else {
+        arg2 = NULL;
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = to_FXColor(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXTIFIcon *)new_FXTIFIcon(arg1,(void const *)arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_setCodec(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon *","setCodec", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setCodec(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_getCodec(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon const *","getCodec", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  result = (FXuint)((FXTIFIcon const *)arg1)->getCodec();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_save(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTIFIcon_save((FXTIFIcon const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_load(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTIFIcon_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_create(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  FXTIFIcon_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_detach(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  FXTIFIcon_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_destroy(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  FXTIFIcon_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_resize(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXTIFIcon_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_restore(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  FXTIFIcon_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_render(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  FXTIFIcon_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_release(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  FXTIFIcon_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_scale(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXTIFIcon_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_mirror(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXTIFIcon_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_rotate(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXTIFIcon_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_crop(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXTIFIcon_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_fill(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXTIFIcon_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_fade(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXTIFIcon_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_xshear(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXTIFIcon_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_yshear(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXTIFIcon_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXTIFIcon_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXTIFIcon_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_gradient(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXTIFIcon_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_blend(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXTIFIcon_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXTIFIcon_savePixels((FXTIFIcon const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFIcon_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXTIFIcon *arg1 = (FXTIFIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFIcon *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXTIFIcon_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxcheckTIF(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxcheckTIF", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxcheckTIF", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (bool)fxcheckTIF(*arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXXBMIcon;
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXXBMIcon_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXXBMIcon_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXXBMIcon_allocate(VALUE self)
+#else
+_wrap_FXXBMIcon_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXXBMIcon);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXXBMIcon(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuchar *arg2 = (FXuchar *) 0 ;
+  FXuchar *arg3 = (FXuchar *) 0 ;
+  FXColor arg4 = (FXColor) FXRGB(192,192,192) ;
+  FXuint arg5 = (FXuint) 0 ;
+  FXint arg6 = (FXint) 1 ;
+  FXint arg7 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXXBMIcon *result = 0 ;
+  
+  if ((argc < 1) || (argc > 7)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXXBMIcon", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXuchar const *","FXXBMIcon", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXuchar * >(argp2);
+  }
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXuchar const *","FXXBMIcon", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXuchar * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = to_FXColor(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXXBMIcon *)new_FXXBMIcon(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,arg4,arg5,arg6,arg7);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_save(int argc, VALUE *argv, VALUE self) {
+  FXXBMIcon *arg1 = (FXXBMIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMIcon const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXXBMIcon_save((FXXBMIcon const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_load(int argc, VALUE *argv, VALUE self) {
+  FXXBMIcon *arg1 = (FXXBMIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMIcon *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXXBMIcon_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_create(int argc, VALUE *argv, VALUE self) {
+  FXXBMIcon *arg1 = (FXXBMIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMIcon *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMIcon * >(argp1);
+  FXXBMIcon_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_detach(int argc, VALUE *argv, VALUE self) {
+  FXXBMIcon *arg1 = (FXXBMIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMIcon *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMIcon * >(argp1);
+  FXXBMIcon_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_destroy(int argc, VALUE *argv, VALUE self) {
+  FXXBMIcon *arg1 = (FXXBMIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMIcon *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMIcon * >(argp1);
+  FXXBMIcon_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_resize(int argc, VALUE *argv, VALUE self) {
+  FXXBMIcon *arg1 = (FXXBMIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMIcon *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXXBMIcon_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_restore(int argc, VALUE *argv, VALUE self) {
+  FXXBMIcon *arg1 = (FXXBMIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMIcon *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMIcon * >(argp1);
+  FXXBMIcon_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_render(int argc, VALUE *argv, VALUE self) {
+  FXXBMIcon *arg1 = (FXXBMIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMIcon *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMIcon * >(argp1);
+  FXXBMIcon_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_release(int argc, VALUE *argv, VALUE self) {
+  FXXBMIcon *arg1 = (FXXBMIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMIcon *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMIcon * >(argp1);
+  FXXBMIcon_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_scale(int argc, VALUE *argv, VALUE self) {
+  FXXBMIcon *arg1 = (FXXBMIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMIcon *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXXBMIcon_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_mirror(int argc, VALUE *argv, VALUE self) {
+  FXXBMIcon *arg1 = (FXXBMIcon *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMIcon *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMIcon * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXXBMIcon_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_rotate(int argc, VALUE *argv, VALUE self) {
+  FXXBMIcon *arg1 = (FXXBMIcon *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMIcon *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXXBMIcon_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_crop(int argc, VALUE *argv, VALUE self) {
+  FXXBMIcon *arg1 = (FXXBMIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMIcon *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXXBMIcon_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_fill(int argc, VALUE *argv, VALUE self) {
+  FXXBMIcon *arg1 = (FXXBMIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMIcon *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXXBMIcon_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_fade(int argc, VALUE *argv, VALUE self) {
+  FXXBMIcon *arg1 = (FXXBMIcon *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMIcon *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXXBMIcon_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_xshear(int argc, VALUE *argv, VALUE self) {
+  FXXBMIcon *arg1 = (FXXBMIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMIcon *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXXBMIcon_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_yshear(int argc, VALUE *argv, VALUE self) {
+  FXXBMIcon *arg1 = (FXXBMIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMIcon *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXXBMIcon_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXXBMIcon *arg1 = (FXXBMIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMIcon *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXXBMIcon_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXXBMIcon *arg1 = (FXXBMIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMIcon *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXXBMIcon_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_gradient(int argc, VALUE *argv, VALUE self) {
+  FXXBMIcon *arg1 = (FXXBMIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMIcon *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXXBMIcon_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_blend(int argc, VALUE *argv, VALUE self) {
+  FXXBMIcon *arg1 = (FXXBMIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMIcon *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXXBMIcon_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXXBMIcon *arg1 = (FXXBMIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMIcon const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXXBMIcon_savePixels((FXXBMIcon const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMIcon_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXXBMIcon *arg1 = (FXXBMIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMIcon *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXXBMIcon_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXXPMIcon;
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXXPMIcon_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXXPMIcon_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXXPMIcon_allocate(VALUE self)
+#else
+_wrap_FXXPMIcon_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXXPMIcon);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXXPMIcon(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXchar **arg2 = (FXchar **) 0 ;
+  FXColor arg3 = (FXColor) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 1 ;
+  FXint arg6 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXXPMIcon *result = 0 ;
+  
+  if ((argc < 1) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXXPMIcon", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      arg2 = NULL;
+      if (argv[1] != Qnil) {
+        Check_Type(argv[1], T_ARRAY);
+        if (FXMALLOC(&arg2, FXchar *, RARRAY_LEN(argv[1]))) {
+          for (long i = 0; i < RARRAY_LEN(argv[1]); i++) {
+            VALUE e = rb_ary_entry(argv[1], i);
+            arg2[i] = (FXchar *) StringValuePtr(e);
+          }
+        }
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = to_FXColor(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXXPMIcon *)new_FXXPMIcon(arg1,(char const **)arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  FXFREE(&arg2);
+  return self;
+fail:
+  FXFREE(&arg2);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_save(int argc, VALUE *argv, VALUE self) {
+  FXXPMIcon *arg1 = (FXXPMIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMIcon const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXXPMIcon_save((FXXPMIcon const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_load(int argc, VALUE *argv, VALUE self) {
+  FXXPMIcon *arg1 = (FXXPMIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMIcon *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXXPMIcon_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_create(int argc, VALUE *argv, VALUE self) {
+  FXXPMIcon *arg1 = (FXXPMIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMIcon *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMIcon * >(argp1);
+  FXXPMIcon_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_detach(int argc, VALUE *argv, VALUE self) {
+  FXXPMIcon *arg1 = (FXXPMIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMIcon *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMIcon * >(argp1);
+  FXXPMIcon_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_destroy(int argc, VALUE *argv, VALUE self) {
+  FXXPMIcon *arg1 = (FXXPMIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMIcon *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMIcon * >(argp1);
+  FXXPMIcon_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_resize(int argc, VALUE *argv, VALUE self) {
+  FXXPMIcon *arg1 = (FXXPMIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMIcon *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXXPMIcon_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_restore(int argc, VALUE *argv, VALUE self) {
+  FXXPMIcon *arg1 = (FXXPMIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMIcon *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMIcon * >(argp1);
+  FXXPMIcon_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_render(int argc, VALUE *argv, VALUE self) {
+  FXXPMIcon *arg1 = (FXXPMIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMIcon *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMIcon * >(argp1);
+  FXXPMIcon_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_release(int argc, VALUE *argv, VALUE self) {
+  FXXPMIcon *arg1 = (FXXPMIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMIcon *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMIcon * >(argp1);
+  FXXPMIcon_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_scale(int argc, VALUE *argv, VALUE self) {
+  FXXPMIcon *arg1 = (FXXPMIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMIcon *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXXPMIcon_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_mirror(int argc, VALUE *argv, VALUE self) {
+  FXXPMIcon *arg1 = (FXXPMIcon *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMIcon *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMIcon * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXXPMIcon_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_rotate(int argc, VALUE *argv, VALUE self) {
+  FXXPMIcon *arg1 = (FXXPMIcon *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMIcon *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXXPMIcon_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_crop(int argc, VALUE *argv, VALUE self) {
+  FXXPMIcon *arg1 = (FXXPMIcon *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMIcon *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXXPMIcon_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_fill(int argc, VALUE *argv, VALUE self) {
+  FXXPMIcon *arg1 = (FXXPMIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMIcon *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXXPMIcon_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_fade(int argc, VALUE *argv, VALUE self) {
+  FXXPMIcon *arg1 = (FXXPMIcon *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMIcon *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXXPMIcon_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_xshear(int argc, VALUE *argv, VALUE self) {
+  FXXPMIcon *arg1 = (FXXPMIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMIcon *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXXPMIcon_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_yshear(int argc, VALUE *argv, VALUE self) {
+  FXXPMIcon *arg1 = (FXXPMIcon *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMIcon *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMIcon * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXXPMIcon_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXXPMIcon *arg1 = (FXXPMIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMIcon *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXXPMIcon_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXXPMIcon *arg1 = (FXXPMIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMIcon *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXXPMIcon_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_gradient(int argc, VALUE *argv, VALUE self) {
+  FXXPMIcon *arg1 = (FXXPMIcon *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMIcon *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXXPMIcon_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_blend(int argc, VALUE *argv, VALUE self) {
+  FXXPMIcon *arg1 = (FXXPMIcon *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMIcon *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMIcon * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXXPMIcon_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXXPMIcon *arg1 = (FXXPMIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMIcon const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXXPMIcon_savePixels((FXXPMIcon const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMIcon_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXXPMIcon *arg1 = (FXXPMIcon *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMIcon, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMIcon *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMIcon * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXXPMIcon_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxloadXPM__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxloadXPM", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxloadXPM", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (VALUE)fxloadXPM(*arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxloadXPM__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  VALUE arg1 = (VALUE) 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  arg1 = argv[0];
+  result = (VALUE)fxloadXPM(arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_fxloadXPM(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[1];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 1) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXStream, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_fxloadXPM__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      return _wrap_fxloadXPM__SWIG_1(nargs, args, self);
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 1, "fxloadXPM", 
+    "    VALUE fxloadXPM(FXStream &store)\n"
+    "    VALUE fxloadXPM(VALUE strArray)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxsaveXPM(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  FXColor *arg2 = (FXColor *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  bool arg5 = (bool) true ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val5 ;
+  int ecode5 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxsaveXPM", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxsaveXPM", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  {
+    arg2=NULL;
+    if(argv[1]!=Qnil){
+      Check_Type(argv[1],T_ARRAY);
+      if(FXMALLOC(&arg2,FXColor,RARRAY_LEN(argv[1]))){
+        for(long i=0; i<RARRAY_LEN(argv[1]); i++){
+          arg2[i]=static_cast<FXColor>(NUM2UINT(rb_ary_entry(argv[1],i)));
+        }
+      }
+    }
+  }
+  arg3 = NUM2INT(argv[2]);
+  arg4 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    ecode5 = SWIG_AsVal_bool(argv[4], &val5);
+    if (!SWIG_IsOK(ecode5)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","fxsaveXPM", 5, argv[4] ));
+    } 
+    arg5 = static_cast< bool >(val5);
+  }
+  result = (bool)fxsaveXPM(*arg1,(unsigned int const *)arg2,arg3,arg4,arg5);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  FXFREE(&arg2);
+  return vresult;
+fail:
+  FXFREE(&arg2);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxcheckXPM(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxcheckXPM", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxcheckXPM", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (bool)fxcheckXPM(*arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_FXPNGIconTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *)(FXIcon *) ((FXPNGIcon *) x));
+}
+static void *_p_FXGradientBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShutterItemTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXRGBImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXRGBImage *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXBMPImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXBMPImage *) x));
+}
+static void *_p_FXMatrixTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXDrawableTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXDrawable *) x));
+}
+static void *_p_FXJPGIconTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *)(FXIcon *) ((FXJPGIcon *) x));
+}
+static void *_p_FXPCXImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXPCXImage *) x));
+}
+static void *_p_FXGIFIconTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *)(FXIcon *) ((FXGIFIcon *) x));
+}
+static void *_p_FXHeaderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXSplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSpringTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXBMPIconTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *)(FXIcon *) ((FXBMPIcon *) x));
+}
+static void *_p_FXImageFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXProgressBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXTGAImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXTGAImage *) x));
+}
+static void *_p_FXICOIconTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *)(FXIcon *) ((FXICOIcon *) x));
+}
+static void *_p_FXToolTipTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXICOImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXICOImage *) x));
+}
+static void *_p_FXRealSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXDockSiteTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXPPMImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXPPMImage *) x));
+}
+static void *_p_FXXBMImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXXBMImage *) x));
+}
+static void *_p_FXXPMImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXXPMImage *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXCanvasTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXColorWheelTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXVisualTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXVisual *) x));
+}
+static void *_p_FXScrollBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXFontTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXFont *) x));
+}
+static void *_p_FXComboBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *) ((FXImage *) x));
+}
+static void *_p_FXTIFIconTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *)(FXIcon *) ((FXTIFIcon *) x));
+}
+static void *_p_FXFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXJPGImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXJPGImage *) x));
+}
+static void *_p_FXPNGImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXPNGImage *) x));
+}
+static void *_p_FXGIFImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXGIFImage *) x));
+}
+static void *_p_FXTIFImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXTIFImage *) x));
+}
+static void *_p_FXStatusBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXCursor *) x));
+}
+static void *_p_FXKnobTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXIconTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXIcon *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRulerViewTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXStatusLineTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXMainWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXTGAIconTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *)(FXIcon *) ((FXTGAIcon *) x));
+}
+static void *_p_FXDockBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXPCXIconTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *)(FXIcon *) ((FXPCXIcon *) x));
+}
+static void *_p_FXBitmapTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *) ((FXBitmap *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXRGBIconTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *)(FXIcon *) ((FXRGBIcon *) x));
+}
+static void *_p_FXDialTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXXBMIconTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *)(FXIcon *) ((FXXBMIcon *) x));
+}
+static void *_p_FXToolBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDirBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXPPMIconTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *)(FXIcon *) ((FXPPMIcon *) x));
+}
+static void *_p_FXXPMIconTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *)(FXIcon *) ((FXXPMIcon *) x));
+}
+static void *_p_FXDocumentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDocument *) x));
+}
+static void *_p_FXPNGIconTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *)(FXIcon *) ((FXPNGIcon *) x));
+}
+static void *_p_FXGradientBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXRegistryTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *)(FXSettings *) ((FXRegistry *) x));
+}
+static void *_p_FXHeaderItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXHeaderItem *) x));
+}
+static void *_p_FXShutterItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXRGBImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXRGBImage *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXIconDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXIconDict *) x));
+}
+static void *_p_FXBMPImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXBMPImage *) x));
+}
+static void *_p_FXMatrixTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXFileDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXFileDict *) x));
+}
+static void *_p_FXRecentFilesTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXRecentFiles *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXDrawableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXDrawable *) x));
+}
+static void *_p_FXJPGIconTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *)(FXIcon *) ((FXJPGIcon *) x));
+}
+static void *_p_FXPCXImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXPCXImage *) x));
+}
+static void *_p_FXGIFIconTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *)(FXIcon *) ((FXGIFIcon *) x));
+}
+static void *_p_FXAppTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXApp *) x));
+}
+static void *_p_FXHeaderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXTranslatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXTranslator *) x));
+}
+static void *_p_FX4SplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FXSpringTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXBMPIconTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *)(FXIcon *) ((FXBMPIcon *) x));
+}
+static void *_p_FXImageFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXIdTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXId *) x));
+}
+static void *_p_FXProgressBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXTGAImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXTGAImage *) x));
+}
+static void *_p_FXICOIconTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *)(FXIcon *) ((FXICOIcon *) x));
+}
+static void *_p_FXToolTipTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXICOImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXICOImage *) x));
+}
+static void *_p_FXRealSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXSettingsTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXSettings *) x));
+}
+static void *_p_FXDockSiteTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDebugTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDebugTarget *) x));
+}
+static void *_p_FXDataTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDataTarget *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXPPMImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXPPMImage *) x));
+}
+static void *_p_FXXBMImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXXBMImage *) x));
+}
+static void *_p_FXXPMImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXXPMImage *) x));
+}
+static void *_p_FXCanvasTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXListBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXColorWheelTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXVisualTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXVisual *) x));
+}
+static void *_p_FXScrollBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXFontTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXFont *) x));
+}
+static void *_p_FXComboBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *) ((FXImage *) x));
+}
+static void *_p_FXTIFIconTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *)(FXIcon *) ((FXTIFIcon *) x));
+}
+static void *_p_FXFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXJPGImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXJPGImage *) x));
+}
+static void *_p_FXPNGImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXPNGImage *) x));
+}
+static void *_p_FXGIFImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXGIFImage *) x));
+}
+static void *_p_FXTIFImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXTIFImage *) x));
+}
+static void *_p_FXStringDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXStringDict *) x));
+}
+static void *_p_FXStatusBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXDelegatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDelegator *) x));
+}
+static void *_p_FXAccelTableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXAccelTable *) x));
+}
+static void *_p_FXCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXKnobTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXIconTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXIcon *) x));
+}
+static void *_p_FXIconSourceTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXIconSource *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRulerViewTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXStatusLineTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXTGAIconTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *)(FXIcon *) ((FXTGAIcon *) x));
+}
+static void *_p_FXDockBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDict *) x));
+}
+static void *_p_FXShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXPCXIconTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *)(FXIcon *) ((FXPCXIcon *) x));
+}
+static void *_p_FXBitmapTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *) ((FXBitmap *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXRGBIconTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *)(FXIcon *) ((FXRGBIcon *) x));
+}
+static void *_p_FXDialTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXXBMIconTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *)(FXIcon *) ((FXXBMIcon *) x));
+}
+static void *_p_FXToolBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDirBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXPPMIconTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *)(FXIcon *) ((FXPPMIcon *) x));
+}
+static void *_p_FXXPMIconTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *)(FXIcon *) ((FXXPMIcon *) x));
+}
+static void *_p_FXPNGIconTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *)(FXIcon *) ((FXPNGIcon *) x));
+}
+static void *_p_FXGradientBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShutterItemTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXRGBImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXRGBImage *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXBMPImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXBMPImage *) x));
+}
+static void *_p_FXMatrixTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXJPGIconTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *)(FXIcon *) ((FXJPGIcon *) x));
+}
+static void *_p_FXPCXImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXPCXImage *) x));
+}
+static void *_p_FXGIFIconTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *)(FXIcon *) ((FXGIFIcon *) x));
+}
+static void *_p_FXHeaderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXSplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSpringTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXBMPIconTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *)(FXIcon *) ((FXBMPIcon *) x));
+}
+static void *_p_FXImageFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXProgressBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXTGAImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXTGAImage *) x));
+}
+static void *_p_FXICOIconTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *)(FXIcon *) ((FXICOIcon *) x));
+}
+static void *_p_FXToolTipTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXICOImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXICOImage *) x));
+}
+static void *_p_FXRealSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXDockSiteTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXPPMImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXPPMImage *) x));
+}
+static void *_p_FXXBMImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXXBMImage *) x));
+}
+static void *_p_FXXPMImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXXPMImage *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXCanvasTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXColorWheelTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXScrollBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXComboBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *)  ((FXImage *) x));
+}
+static void *_p_FXTIFIconTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *)(FXIcon *) ((FXTIFIcon *) x));
+}
+static void *_p_FXFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXJPGImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXJPGImage *) x));
+}
+static void *_p_FXPNGImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXPNGImage *) x));
+}
+static void *_p_FXGIFImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXGIFImage *) x));
+}
+static void *_p_FXTIFImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXTIFImage *) x));
+}
+static void *_p_FXStatusBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXKnobTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXIconTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXIcon *) x));
+}
+static void *_p_FXRulerViewTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXStatusLineTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *)  ((FXWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXTGAIconTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *)(FXIcon *) ((FXTGAIcon *) x));
+}
+static void *_p_FXDockBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXPCXIconTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *)(FXIcon *) ((FXPCXIcon *) x));
+}
+static void *_p_FXBitmapTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *)  ((FXBitmap *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXRGBIconTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *)(FXIcon *) ((FXRGBIcon *) x));
+}
+static void *_p_FXDialTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXXBMIconTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *)(FXIcon *) ((FXXBMIcon *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXToolBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXDirBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXPPMIconTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *)(FXIcon *) ((FXPPMIcon *) x));
+}
+static void *_p_FXXPMIconTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *)(FXIcon *) ((FXXPMIcon *) x));
+}
+static void *_p_FXFileStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXFileStream *) x));
+}
+static void *_p_FXMemoryStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXMemoryStream *) x));
+}
+static void *_p_FXICOIconTo_p_FXIcon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXIcon *)  ((FXICOIcon *) x));
+}
+static void *_p_FXJPGIconTo_p_FXIcon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXIcon *)  ((FXJPGIcon *) x));
+}
+static void *_p_FXPCXIconTo_p_FXIcon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXIcon *)  ((FXPCXIcon *) x));
+}
+static void *_p_FXTGAIconTo_p_FXIcon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXIcon *)  ((FXTGAIcon *) x));
+}
+static void *_p_FXBMPIconTo_p_FXIcon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXIcon *)  ((FXBMPIcon *) x));
+}
+static void *_p_FXPNGIconTo_p_FXIcon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXIcon *)  ((FXPNGIcon *) x));
+}
+static void *_p_FXPPMIconTo_p_FXIcon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXIcon *)  ((FXPPMIcon *) x));
+}
+static void *_p_FXTIFIconTo_p_FXIcon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXIcon *)  ((FXTIFIcon *) x));
+}
+static void *_p_FXXBMIconTo_p_FXIcon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXIcon *)  ((FXXBMIcon *) x));
+}
+static void *_p_FXXPMIconTo_p_FXIcon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXIcon *)  ((FXXPMIcon *) x));
+}
+static void *_p_FXGIFIconTo_p_FXIcon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXIcon *)  ((FXGIFIcon *) x));
+}
+static void *_p_FXRGBIconTo_p_FXIcon(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXIcon *)  ((FXRGBIcon *) x));
+}
+static void *_p_FXRGBImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXRGBImage *) x));
+}
+static void *_p_FXGIFIconTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *) (FXIcon *) ((FXGIFIcon *) x));
+}
+static void *_p_FXJPGIconTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *) (FXIcon *) ((FXJPGIcon *) x));
+}
+static void *_p_FXXBMIconTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *) (FXIcon *) ((FXXBMIcon *) x));
+}
+static void *_p_FXBMPIconTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *) (FXIcon *) ((FXBMPIcon *) x));
+}
+static void *_p_FXRGBIconTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *) (FXIcon *) ((FXRGBIcon *) x));
+}
+static void *_p_FXTIFIconTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *) (FXIcon *) ((FXTIFIcon *) x));
+}
+static void *_p_FXTGAIconTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *) (FXIcon *) ((FXTGAIcon *) x));
+}
+static void *_p_FXTIFImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXTIFImage *) x));
+}
+static void *_p_FXGIFImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXGIFImage *) x));
+}
+static void *_p_FXPCXIconTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *) (FXIcon *) ((FXPCXIcon *) x));
+}
+static void *_p_FXICOImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXICOImage *) x));
+}
+static void *_p_FXXPMImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXXPMImage *) x));
+}
+static void *_p_FXXBMImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXXBMImage *) x));
+}
+static void *_p_FXPPMImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXPPMImage *) x));
+}
+static void *_p_FXPCXImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXPCXImage *) x));
+}
+static void *_p_FXBMPImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXBMPImage *) x));
+}
+static void *_p_FXPPMIconTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *) (FXIcon *) ((FXPPMIcon *) x));
+}
+static void *_p_FXXPMIconTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *) (FXIcon *) ((FXXPMIcon *) x));
+}
+static void *_p_FXICOIconTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *) (FXIcon *) ((FXICOIcon *) x));
+}
+static void *_p_FXPNGIconTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *) (FXIcon *) ((FXPNGIcon *) x));
+}
+static void *_p_FXIconTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXIcon *) x));
+}
+static void *_p_FXPNGImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXPNGImage *) x));
+}
+static void *_p_FXJPGImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXJPGImage *) x));
+}
+static void *_p_FXTGAImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXTGAImage *) x));
+}
+static swig_type_info _swigt__p_FXApp = {"_p_FXApp", "FXApp *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXBMPIcon = {"_p_FXBMPIcon", "FXBMPIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDrawable = {"_p_FXDrawable", "FXDrawable *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGradientBar = {"_p_FXGradientBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutterItem = {"_p_FXShutterItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorBar = {"_p_FXColorBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTabBar = {"_p_FXTabBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRGBImage = {"_p_FXRGBImage", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSwitcher = {"_p_FXSwitcher", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTextField = {"_p_FXTextField", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarTab = {"_p_FXToolBarTab", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDriveBox = {"_p_FXDriveBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXBMPImage = {"_p_FXBMPImage", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMatrix = {"_p_FXMatrix", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollCorner = {"_p_FXScrollCorner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXArrowButton = {"_p_FXArrowButton", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPopup = {"_p_FXPopup", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPCXImage = {"_p_FXPCXImage", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHeader = {"_p_FXHeader", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplitter = {"_p_FXSplitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FX4Splitter = {"_p_FX4Splitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSpring = {"_p_FXSpring", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPacker = {"_p_FXPacker", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTabBook = {"_p_FXTabBook", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImageFrame = {"_p_FXImageFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalSeparator = {"_p_FXVerticalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalSeparator = {"_p_FXHorizontalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSeparator = {"_p_FXSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXKnob = {"_p_FXKnob", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXProgressBar = {"_p_FXProgressBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutter = {"_p_FXShutter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTGAImage = {"_p_FXTGAImage", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolTip = {"_p_FXToolTip", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXComposite = {"_p_FXComposite", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXICOImage = {"_p_FXICOImage", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXBitmapFrame = {"_p_FXBitmapFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRealSlider = {"_p_FXRealSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSlider = {"_p_FXSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockSite = {"_p_FXDockSite", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGroupBox = {"_p_FXGroupBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorRing = {"_p_FXColorRing", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockHandler = {"_p_FXDockHandler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPPMImage = {"_p_FXPPMImage", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXXBMImage = {"_p_FXXBMImage", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXXPMImage = {"_p_FXXPMImage", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTreeListBox = {"_p_FXTreeListBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXListBox = {"_p_FXListBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCanvas = {"_p_FXCanvas", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWheel = {"_p_FXColorWheel", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDial = {"_p_FXDial", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarGrip = {"_p_FXToolBarGrip", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollBar = {"_p_FXScrollBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXComboBox = {"_p_FXComboBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFrame = {"_p_FXFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FX7Segment = {"_p_FX7Segment", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockTitle = {"_p_FXDockTitle", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXJPGImage = {"_p_FXJPGImage", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPNGImage = {"_p_FXPNGImage", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTIFImage = {"_p_FXTIFImage", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGIFImage = {"_p_FXGIFImage", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusBar = {"_p_FXStatusBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRulerView = {"_p_FXRulerView", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSpinner = {"_p_FXSpinner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRealSpinner = {"_p_FXRealSpinner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusLine = {"_p_FXStatusLine", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRootWindow = {"_p_FXRootWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTopWindow = {"_p_FXTopWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMainWindow = {"_p_FXMainWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplashWindow = {"_p_FXSplashWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXWindow = {"_p_FXWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollWindow = {"_p_FXScrollWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockBar = {"_p_FXDockBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShell = {"_p_FXShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXBitmap = {"_p_FXBitmap", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollArea = {"_p_FXScrollArea", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWell = {"_p_FXColorWell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDragCorner = {"_p_FXDragCorner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRuler = {"_p_FXRuler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalFrame = {"_p_FXVerticalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalFrame = {"_p_FXHorizontalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImageView = {"_p_FXImageView", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFontSelector = {"_p_FXFontSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorSelector = {"_p_FXColorSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileSelector = {"_p_FXFileSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDirSelector = {"_p_FXDirSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarShell = {"_p_FXToolBarShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBar = {"_p_FXToolBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDirBox = {"_p_FXDirBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGIFIcon = {"_p_FXGIFIcon", "FXGIFIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXICOIcon = {"_p_FXICOIcon", "FXICOIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXIcon = {"_p_FXIcon", "FXIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXIconSource = {"_p_FXIconSource", "FXIconSource *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXId = {"_p_FXId", "FXId *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFont = {"_p_FXFont", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVisual = {"_p_FXVisual", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCursor = {"_p_FXCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCURCursor = {"_p_FXCURCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGIFCursor = {"_p_FXGIFCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImage = {"_p_FXImage", "FXImage *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXJPGIcon = {"_p_FXJPGIcon", "FXJPGIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXObject = {"_p_FXObject", "FXObject *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDocument = {"_p_FXDocument", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRegistry = {"_p_FXRegistry", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHeaderItem = {"_p_FXHeaderItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXIconDict = {"_p_FXIconDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileDict = {"_p_FXFileDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRecentFiles = {"_p_FXRecentFiles", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTranslator = {"_p_FXTranslator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDict = {"_p_FXDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSettings = {"_p_FXSettings", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDataTarget = {"_p_FXDataTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDebugTarget = {"_p_FXDebugTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStringDict = {"_p_FXStringDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDelegator = {"_p_FXDelegator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXAccelTable = {"_p_FXAccelTable", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPCXIcon = {"_p_FXPCXIcon", "FXPCXIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXPNGIcon = {"_p_FXPNGIcon", "FXPNGIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXPPMIcon = {"_p_FXPPMIcon", "FXPPMIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRGBIcon = {"_p_FXRGBIcon", "FXRGBIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXStream = {"_p_FXStream", "FXStream *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFileStream = {"_p_FXFileStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMemoryStream = {"_p_FXMemoryStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTGAIcon = {"_p_FXTGAIcon", "FXTGAIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXTIFIcon = {"_p_FXTIFIcon", "FXTIFIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXXBMIcon = {"_p_FXXBMIcon", "FXXBMIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXXPMIcon = {"_p_FXXPMIcon", "FXXPMIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_char = {"_p_char", "char *|FXchar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "double *|FXdouble *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_float = {"_p_float", "float *|FXfloat *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "FXint *|int *|FXInputHandle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_long = {"_p_long", "long *|FXTime *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **|FXchar **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_short = {"_p_short", "short *|FXshort *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "FXuchar *|unsigned char *|FXbool *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "FXwchar *|FXDragType *|unsigned int *|FXuint *|FXColor *|FXSelector *|FXHotKey *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|FXuval *|FXPixel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|FXushort *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_FX4Splitter,
+  &_swigt__p_FX7Segment,
+  &_swigt__p_FXAccelTable,
+  &_swigt__p_FXApp,
+  &_swigt__p_FXArrowButton,
+  &_swigt__p_FXBMPIcon,
+  &_swigt__p_FXBMPImage,
+  &_swigt__p_FXBitmap,
+  &_swigt__p_FXBitmapFrame,
+  &_swigt__p_FXCURCursor,
+  &_swigt__p_FXCanvas,
+  &_swigt__p_FXColorBar,
+  &_swigt__p_FXColorRing,
+  &_swigt__p_FXColorSelector,
+  &_swigt__p_FXColorWell,
+  &_swigt__p_FXColorWheel,
+  &_swigt__p_FXComboBox,
+  &_swigt__p_FXComposite,
+  &_swigt__p_FXCursor,
+  &_swigt__p_FXDataTarget,
+  &_swigt__p_FXDebugTarget,
+  &_swigt__p_FXDelegator,
+  &_swigt__p_FXDial,
+  &_swigt__p_FXDict,
+  &_swigt__p_FXDirBox,
+  &_swigt__p_FXDirSelector,
+  &_swigt__p_FXDockBar,
+  &_swigt__p_FXDockHandler,
+  &_swigt__p_FXDockSite,
+  &_swigt__p_FXDockTitle,
+  &_swigt__p_FXDocument,
+  &_swigt__p_FXDragCorner,
+  &_swigt__p_FXDrawable,
+  &_swigt__p_FXDriveBox,
+  &_swigt__p_FXFileDict,
+  &_swigt__p_FXFileSelector,
+  &_swigt__p_FXFileStream,
+  &_swigt__p_FXFont,
+  &_swigt__p_FXFontSelector,
+  &_swigt__p_FXFrame,
+  &_swigt__p_FXGIFCursor,
+  &_swigt__p_FXGIFIcon,
+  &_swigt__p_FXGIFImage,
+  &_swigt__p_FXGradientBar,
+  &_swigt__p_FXGroupBox,
+  &_swigt__p_FXHeader,
+  &_swigt__p_FXHeaderItem,
+  &_swigt__p_FXHorizontalFrame,
+  &_swigt__p_FXHorizontalSeparator,
+  &_swigt__p_FXICOIcon,
+  &_swigt__p_FXICOImage,
+  &_swigt__p_FXIcon,
+  &_swigt__p_FXIconDict,
+  &_swigt__p_FXIconSource,
+  &_swigt__p_FXId,
+  &_swigt__p_FXImage,
+  &_swigt__p_FXImageFrame,
+  &_swigt__p_FXImageView,
+  &_swigt__p_FXJPGIcon,
+  &_swigt__p_FXJPGImage,
+  &_swigt__p_FXKnob,
+  &_swigt__p_FXListBox,
+  &_swigt__p_FXMainWindow,
+  &_swigt__p_FXMatrix,
+  &_swigt__p_FXMemoryStream,
+  &_swigt__p_FXObject,
+  &_swigt__p_FXPCXIcon,
+  &_swigt__p_FXPCXImage,
+  &_swigt__p_FXPNGIcon,
+  &_swigt__p_FXPNGImage,
+  &_swigt__p_FXPPMIcon,
+  &_swigt__p_FXPPMImage,
+  &_swigt__p_FXPacker,
+  &_swigt__p_FXPopup,
+  &_swigt__p_FXProgressBar,
+  &_swigt__p_FXRGBIcon,
+  &_swigt__p_FXRGBImage,
+  &_swigt__p_FXRealSlider,
+  &_swigt__p_FXRealSpinner,
+  &_swigt__p_FXRecentFiles,
+  &_swigt__p_FXRegistry,
+  &_swigt__p_FXRootWindow,
+  &_swigt__p_FXRuler,
+  &_swigt__p_FXRulerView,
+  &_swigt__p_FXScrollArea,
+  &_swigt__p_FXScrollBar,
+  &_swigt__p_FXScrollCorner,
+  &_swigt__p_FXScrollWindow,
+  &_swigt__p_FXSeparator,
+  &_swigt__p_FXSettings,
+  &_swigt__p_FXShell,
+  &_swigt__p_FXShutter,
+  &_swigt__p_FXShutterItem,
+  &_swigt__p_FXSlider,
+  &_swigt__p_FXSpinner,
+  &_swigt__p_FXSplashWindow,
+  &_swigt__p_FXSplitter,
+  &_swigt__p_FXSpring,
+  &_swigt__p_FXStatusBar,
+  &_swigt__p_FXStatusLine,
+  &_swigt__p_FXStream,
+  &_swigt__p_FXStringDict,
+  &_swigt__p_FXSwitcher,
+  &_swigt__p_FXTGAIcon,
+  &_swigt__p_FXTGAImage,
+  &_swigt__p_FXTIFIcon,
+  &_swigt__p_FXTIFImage,
+  &_swigt__p_FXTabBar,
+  &_swigt__p_FXTabBook,
+  &_swigt__p_FXTextField,
+  &_swigt__p_FXToolBar,
+  &_swigt__p_FXToolBarGrip,
+  &_swigt__p_FXToolBarShell,
+  &_swigt__p_FXToolBarTab,
+  &_swigt__p_FXToolTip,
+  &_swigt__p_FXTopWindow,
+  &_swigt__p_FXTranslator,
+  &_swigt__p_FXTreeListBox,
+  &_swigt__p_FXVerticalFrame,
+  &_swigt__p_FXVerticalSeparator,
+  &_swigt__p_FXVisual,
+  &_swigt__p_FXWindow,
+  &_swigt__p_FXXBMIcon,
+  &_swigt__p_FXXBMImage,
+  &_swigt__p_FXXPMIcon,
+  &_swigt__p_FXXPMImage,
+  &_swigt__p_char,
+  &_swigt__p_double,
+  &_swigt__p_float,
+  &_swigt__p_int,
+  &_swigt__p_long,
+  &_swigt__p_p_char,
+  &_swigt__p_short,
+  &_swigt__p_unsigned_char,
+  &_swigt__p_unsigned_int,
+  &_swigt__p_unsigned_long,
+  &_swigt__p_unsigned_short,
+};
+
+static swig_cast_info _swigc__p_FXApp[] = {  {&_swigt__p_FXApp, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBMPIcon[] = {  {&_swigt__p_FXBMPIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGradientBar[] = {{&_swigt__p_FXGradientBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutterItem[] = {{&_swigt__p_FXShutterItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorBar[] = {{&_swigt__p_FXColorBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabBar[] = {{&_swigt__p_FXTabBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRGBImage[] = {{&_swigt__p_FXRGBImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSwitcher[] = {{&_swigt__p_FXSwitcher, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTextField[] = {{&_swigt__p_FXTextField, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarTab[] = {{&_swigt__p_FXToolBarTab, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDriveBox[] = {{&_swigt__p_FXDriveBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBMPImage[] = {{&_swigt__p_FXBMPImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMatrix[] = {{&_swigt__p_FXMatrix, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollCorner[] = {{&_swigt__p_FXScrollCorner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXArrowButton[] = {{&_swigt__p_FXArrowButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPopup[] = {{&_swigt__p_FXPopup, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPCXImage[] = {{&_swigt__p_FXPCXImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeader[] = {{&_swigt__p_FXHeader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplitter[] = {{&_swigt__p_FXSplitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FX4Splitter[] = {{&_swigt__p_FX4Splitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpring[] = {{&_swigt__p_FXSpring, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPacker[] = {{&_swigt__p_FXPacker, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabBook[] = {{&_swigt__p_FXTabBook, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageFrame[] = {{&_swigt__p_FXImageFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalSeparator[] = {{&_swigt__p_FXVerticalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalSeparator[] = {{&_swigt__p_FXHorizontalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSeparator[] = {{&_swigt__p_FXSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXKnob[] = {{&_swigt__p_FXKnob, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXProgressBar[] = {{&_swigt__p_FXProgressBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutter[] = {{&_swigt__p_FXShutter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTGAImage[] = {{&_swigt__p_FXTGAImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolTip[] = {{&_swigt__p_FXToolTip, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComposite[] = {{&_swigt__p_FXComposite, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXICOImage[] = {{&_swigt__p_FXICOImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBitmapFrame[] = {{&_swigt__p_FXBitmapFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSlider[] = {{&_swigt__p_FXRealSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSlider[] = {{&_swigt__p_FXSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockSite[] = {{&_swigt__p_FXDockSite, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGroupBox[] = {{&_swigt__p_FXGroupBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorRing[] = {{&_swigt__p_FXColorRing, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockHandler[] = {{&_swigt__p_FXDockHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPPMImage[] = {{&_swigt__p_FXPPMImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXXBMImage[] = {{&_swigt__p_FXXBMImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXXPMImage[] = {{&_swigt__p_FXXPMImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTreeListBox[] = {{&_swigt__p_FXTreeListBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXListBox[] = {{&_swigt__p_FXListBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCanvas[] = {{&_swigt__p_FXCanvas, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWheel[] = {{&_swigt__p_FXColorWheel, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDial[] = {{&_swigt__p_FXDial, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarGrip[] = {{&_swigt__p_FXToolBarGrip, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollBar[] = {{&_swigt__p_FXScrollBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComboBox[] = {{&_swigt__p_FXComboBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFrame[] = {{&_swigt__p_FXFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FX7Segment[] = {{&_swigt__p_FX7Segment, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockTitle[] = {{&_swigt__p_FXDockTitle, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXJPGImage[] = {{&_swigt__p_FXJPGImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPNGImage[] = {{&_swigt__p_FXPNGImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTIFImage[] = {{&_swigt__p_FXTIFImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGIFImage[] = {{&_swigt__p_FXGIFImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusBar[] = {{&_swigt__p_FXStatusBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRulerView[] = {{&_swigt__p_FXRulerView, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpinner[] = {{&_swigt__p_FXSpinner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSpinner[] = {{&_swigt__p_FXRealSpinner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusLine[] = {{&_swigt__p_FXStatusLine, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRootWindow[] = {{&_swigt__p_FXRootWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTopWindow[] = {{&_swigt__p_FXTopWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMainWindow[] = {{&_swigt__p_FXMainWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplashWindow[] = {{&_swigt__p_FXSplashWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXWindow[] = {{&_swigt__p_FXWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollWindow[] = {{&_swigt__p_FXScrollWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockBar[] = {{&_swigt__p_FXDockBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShell[] = {{&_swigt__p_FXShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBitmap[] = {{&_swigt__p_FXBitmap, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollArea[] = {{&_swigt__p_FXScrollArea, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWell[] = {{&_swigt__p_FXColorWell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDragCorner[] = {{&_swigt__p_FXDragCorner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRuler[] = {{&_swigt__p_FXRuler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalFrame[] = {{&_swigt__p_FXVerticalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalFrame[] = {{&_swigt__p_FXHorizontalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageView[] = {{&_swigt__p_FXImageView, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFontSelector[] = {{&_swigt__p_FXFontSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorSelector[] = {{&_swigt__p_FXColorSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileSelector[] = {{&_swigt__p_FXFileSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirSelector[] = {{&_swigt__p_FXDirSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarShell[] = {{&_swigt__p_FXToolBarShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBar[] = {{&_swigt__p_FXToolBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirBox[] = {{&_swigt__p_FXDirBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDrawable[] = {  {&_swigt__p_FXPNGIcon, _p_FXPNGIconTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRGBImage, _p_FXRGBImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXBMPImage, _p_FXBMPImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDrawable, 0, 0, 0},  {&_swigt__p_FXJPGIcon, _p_FXJPGIconTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXGIFIcon, _p_FXGIFIconTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPCXImage, _p_FXPCXImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXBMPIcon, _p_FXBMPIconTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXIcon, _p_FXIconTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXICOIcon, _p_FXICOIconTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTGAImage, _p_FXTGAImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXICOImage, _p_FXICOImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPPMImage, _p_FXPPMImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXXBMImage, _p_FXXBMImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXXPMImage, _p_FXXPMImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTIFIcon, _p_FXTIFIconTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImage, _p_FXImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXJPGImage, _p_FXJPGImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPNGImage, _p_FXPNGImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTIFImage, _p_FXTIFImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXGIFImage, _p_FXGIFImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTGAIcon, _p_FXTGAIconTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPCXIcon, _p_FXPCXIconTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXBitmap, _p_FXBitmapTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRGBIcon, _p_FXRGBIconTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXXBMIcon, _p_FXXBMIconTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXXPMIcon, _p_FXXPMIconTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPPMIcon, _p_FXPPMIconTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXDrawable, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGIFIcon[] = {  {&_swigt__p_FXGIFIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXICOIcon[] = {  {&_swigt__p_FXICOIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIcon[] = {  {&_swigt__p_FXIcon, 0, 0, 0},  {&_swigt__p_FXICOIcon, _p_FXICOIconTo_p_FXIcon, 0, 0},  {&_swigt__p_FXJPGIcon, _p_FXJPGIconTo_p_FXIcon, 0, 0},  {&_swigt__p_FXPCXIcon, _p_FXPCXIconTo_p_FXIcon, 0, 0},  {&_swigt__p_FXTGAIcon, _p_FXTGAIconTo_p_FXIcon, 0, 0},  {&_swigt__p_FXBMPIcon, _p_FXBMPIconTo_p_FXIcon, 0, 0},  {&_swigt__p_FXPNGIcon, _p_FXPNGIconTo_p_FXIcon, 0, 0},  {&_swigt__p_FXPPMIcon, _p_FXPPMIconTo_p_FXIcon, 0, 0},  {&_swigt__p_FXTIFIcon, _p_FXTIFIconTo_p_FXIcon, 0, 0},  {&_swigt__p_FXXBMIcon, _p_FXXBMIconTo_p_FXIcon, 0, 0},  {&_swigt__p_FXXPMIcon, _p_FXXPMIconTo_p_FXIcon, 0, 0},  {&_swigt__p_FXGIFIcon, _p_FXGIFIconTo_p_FXIcon, 0, 0},  {&_swigt__p_FXRGBIcon, _p_FXRGBIconTo_p_FXIcon, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIconSource[] = {  {&_swigt__p_FXIconSource, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFont[] = {{&_swigt__p_FXFont, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVisual[] = {{&_swigt__p_FXVisual, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCursor[] = {{&_swigt__p_FXCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCURCursor[] = {{&_swigt__p_FXCURCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGIFCursor[] = {{&_swigt__p_FXGIFCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXId[] = {  {&_swigt__p_FXPNGIcon, _p_FXPNGIconTo_p_FXId, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXId, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXId, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXId, 0, 0},  {&_swigt__p_FXRGBImage, _p_FXRGBImageTo_p_FXId, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXId, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXId, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXBMPImage, _p_FXBMPImageTo_p_FXId, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXId, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXId, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXId, 0, 0},  {&_swigt__p_FXJPGIcon, _p_FXJPGIconTo_p_FXId, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXId, 0, 0},  {&_swigt__p_FXGIFIcon, _p_FXGIFIconTo_p_FXId, 0, 0},  {&_swigt__p_FXPCXImage, _p_FXPCXImageTo_p_FXId, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXId, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXId, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXId, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXId, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXId, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXId, 0, 0},  {&_swigt__p_FXBMPIcon, _p_FXBMPIconTo_p_FXId, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXId, 0, 0},  {&_swigt__p_FXIcon, _p_FXIconTo_p_FXId, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXId, 0, 0},  {&_swigt__p_FXICOIcon, _p_FXICOIconTo_p_FXId, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXId, 0, 0},  {&_swigt__p_FXTGAImage, _p_FXTGAImageTo_p_FXId, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXId, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXId, 0, 0},  {&_swigt__p_FXICOImage, _p_FXICOImageTo_p_FXId, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXId, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXId, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXId, 0, 0},  {&_swigt__p_FXPPMImage, _p_FXPPMImageTo_p_FXId, 0, 0},  {&_swigt__p_FXXBMImage, _p_FXXBMImageTo_p_FXId, 0, 0},  {&_swigt__p_FXXPMImage, _p_FXXPMImageTo_p_FXId, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXId, 0, 0},  {&_swigt__p_FXId, 0, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXId, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXId, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXId, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXTIFIcon, _p_FXTIFIconTo_p_FXId, 0, 0},  {&_swigt__p_FXImage, _p_FXImageTo_p_FXId, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXId, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXId, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXId, 0, 0},  {&_swigt__p_FXJPGImage, _p_FXJPGImageTo_p_FXId, 0, 0},  {&_swigt__p_FXPNGImage, _p_FXPNGImageTo_p_FXId, 0, 0},  {&_swigt__p_FXTIFImage, _p_FXTIFImageTo_p_FXId, 0, 0},  {&_swigt__p_FXGIFImage, _p_FXGIFImageTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXId, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXId, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXId, 0, 0},  {&_swigt__p_FXTGAIcon, _p_FXTGAIconTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXId, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXId, 0, 0},  {&_swigt__p_FXPCXIcon, _p_FXPCXIconTo_p_FXId, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXId, 0, 0},  {&_swigt__p_FXBitmap, _p_FXBitmapTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXId, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXId, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXId, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXId, 0, 0},  {&_swigt__p_FXRGBIcon, _p_FXRGBIconTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXXBMIcon, _p_FXXBMIconTo_p_FXId, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXId, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXId, 0, 0},  {&_swigt__p_FXXPMIcon, _p_FXXPMIconTo_p_FXId, 0, 0},  {&_swigt__p_FXPPMIcon, _p_FXPPMIconTo_p_FXId, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXId, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImage[] = {  {&_swigt__p_FXGIFIcon, _p_FXGIFIconTo_p_FXImage, 0, 0},  {&_swigt__p_FXXBMIcon, _p_FXXBMIconTo_p_FXImage, 0, 0},  {&_swigt__p_FXRGBImage, _p_FXRGBImageTo_p_FXImage, 0, 0},  {&_swigt__p_FXJPGIcon, _p_FXJPGIconTo_p_FXImage, 0, 0},  {&_swigt__p_FXBMPIcon, _p_FXBMPIconTo_p_FXImage, 0, 0},  {&_swigt__p_FXRGBIcon, _p_FXRGBIconTo_p_FXImage, 0, 0},  {&_swigt__p_FXTIFIcon, _p_FXTIFIconTo_p_FXImage, 0, 0},  {&_swigt__p_FXTGAIcon, _p_FXTGAIconTo_p_FXImage, 0, 0},  {&_swigt__p_FXTIFImage, _p_FXTIFImageTo_p_FXImage, 0, 0},  {&_swigt__p_FXGIFImage, _p_FXGIFImageTo_p_FXImage, 0, 0},  {&_swigt__p_FXPCXIcon, _p_FXPCXIconTo_p_FXImage, 0, 0},  {&_swigt__p_FXICOImage, _p_FXICOImageTo_p_FXImage, 0, 0},  {&_swigt__p_FXXPMImage, _p_FXXPMImageTo_p_FXImage, 0, 0},  {&_swigt__p_FXXBMImage, _p_FXXBMImageTo_p_FXImage, 0, 0},  {&_swigt__p_FXPPMImage, _p_FXPPMImageTo_p_FXImage, 0, 0},  {&_swigt__p_FXPCXImage, _p_FXPCXImageTo_p_FXImage, 0, 0},  {&_swigt__p_FXIcon, _p_FXIconTo_p_FXImage, 0, 0},  {&_swigt__p_FXPPMIcon, _p_FXPPMIconTo_p_FXImage, 0, 0},  {&_swigt__p_FXXPMIcon, _p_FXXPMIconTo_p_FXImage, 0, 0},  {&_swigt__p_FXBMPImage, _p_FXBMPImageTo_p_FXImage, 0, 0},  {&_swigt__p_FXICOIcon, _p_FXICOIconTo_p_FXImage, 0, 0},  {&_swigt__p_FXPNGIcon, _p_FXPNGIconTo_p_FXImage, 0, 0},  {&_swigt__p_FXImage, 0, 0, 0},  {&_swigt__p_FXPNGImage, _p_FXPNGImageTo_p_FXImage, 0, 0},  {&_swigt__p_FXJPGImage, _p_FXJPGImageTo_p_FXImage, 0, 0},  {&_swigt__p_FXTGAImage, _p_FXTGAImageTo_p_FXImage, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXJPGIcon[] = {  {&_swigt__p_FXJPGIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDocument[] = {{&_swigt__p_FXDocument, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegistry[] = {{&_swigt__p_FXRegistry, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeaderItem[] = {{&_swigt__p_FXHeaderItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIconDict[] = {{&_swigt__p_FXIconDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileDict[] = {{&_swigt__p_FXFileDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRecentFiles[] = {{&_swigt__p_FXRecentFiles, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTranslator[] = {{&_swigt__p_FXTranslator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDict[] = {{&_swigt__p_FXDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSettings[] = {{&_swigt__p_FXSettings, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDataTarget[] = {{&_swigt__p_FXDataTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDebugTarget[] = {{&_swigt__p_FXDebugTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStringDict[] = {{&_swigt__p_FXStringDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDelegator[] = {{&_swigt__p_FXDelegator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXAccelTable[] = {{&_swigt__p_FXAccelTable, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXObject[] = {  {&_swigt__p_FXDocument, _p_FXDocumentTo_p_FXObject, 0, 0},  {&_swigt__p_FXPNGIcon, _p_FXPNGIconTo_p_FXObject, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXRegistry, _p_FXRegistryTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeaderItem, _p_FXHeaderItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXRGBImage, _p_FXRGBImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXObject, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXObject, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXIconDict, _p_FXIconDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXBMPImage, _p_FXBMPImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileDict, _p_FXFileDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXRecentFiles, _p_FXRecentFilesTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXObject, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXObject, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXObject, 0, 0},  {&_swigt__p_FXJPGIcon, _p_FXJPGIconTo_p_FXObject, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXObject, 0, 0},  {&_swigt__p_FXGIFIcon, _p_FXGIFIconTo_p_FXObject, 0, 0},  {&_swigt__p_FXPCXImage, _p_FXPCXImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FXTranslator, _p_FXTranslatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXObject, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXObject, 0, 0},  {&_swigt__p_FXApp, _p_FXAppTo_p_FXObject, 0, 0},  {&_swigt__p_FXBMPIcon, _p_FXBMPIconTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXObject, 0, 0},  {&_swigt__p_FXIcon, _p_FXIconTo_p_FXObject, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXICOIcon, _p_FXICOIconTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXObject, 0, 0},  {&_swigt__p_FXTGAImage, _p_FXTGAImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXObject, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXObject, 0, 0},  {&_swigt__p_FXDict, _p_FXDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXICOImage, _p_FXICOImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXSettings, _p_FXSettingsTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXObject, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXObject, 0, 0},  {&_swigt__p_FXDataTarget, _p_FXDataTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDebugTarget, _p_FXDebugTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXObject, 0, 0},  {&_swigt__p_FXPPMImage, _p_FXPPMImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXXBMImage, _p_FXXBMImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXXPMImage, _p_FXXPMImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXObject, 0, 0},  {&_swigt__p_FXId, _p_FXIdTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXObject, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXObject, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXTIFIcon, _p_FXTIFIconTo_p_FXObject, 0, 0},  {&_swigt__p_FXImage, _p_FXImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXPNGImage, _p_FXPNGImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXJPGImage, _p_FXJPGImageTo_p_FXObject, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXObject, 0, 0},  {&_swigt__p_FXTIFImage, _p_FXTIFImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXGIFImage, _p_FXGIFImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXStringDict, _p_FXStringDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXDelegator, _p_FXDelegatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXAccelTable, _p_FXAccelTableTo_p_FXObject, 0, 0},  {&_swigt__p_FXObject, 0, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXIconSource, _p_FXIconSourceTo_p_FXObject, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXObject, 0, 0},  {&_swigt__p_FXTGAIcon, _p_FXTGAIconTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXObject, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXPCXIcon, _p_FXPCXIconTo_p_FXObject, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXBitmap, _p_FXBitmapTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXObject, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXObject, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXObject, 0, 0},  {&_swigt__p_FXRGBIcon, _p_FXRGBIconTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXXBMIcon, _p_FXXBMIconTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXObject, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXXPMIcon, _p_FXXPMIconTo_p_FXObject, 0, 0},  {&_swigt__p_FXPPMIcon, _p_FXPPMIconTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXObject, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPCXIcon[] = {  {&_swigt__p_FXPCXIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPNGIcon[] = {  {&_swigt__p_FXPNGIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPPMIcon[] = {  {&_swigt__p_FXPPMIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRGBIcon[] = {  {&_swigt__p_FXRGBIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileStream[] = {{&_swigt__p_FXFileStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMemoryStream[] = {{&_swigt__p_FXMemoryStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStream[] = {  {&_swigt__p_FXFileStream, _p_FXFileStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXMemoryStream, _p_FXMemoryStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTGAIcon[] = {  {&_swigt__p_FXTGAIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTIFIcon[] = {  {&_swigt__p_FXTIFIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXXBMIcon[] = {  {&_swigt__p_FXXBMIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXXPMIcon[] = {  {&_swigt__p_FXXPMIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
+
+static swig_cast_info *swig_cast_initial[] = {
+  _swigc__p_FX4Splitter,
+  _swigc__p_FX7Segment,
+  _swigc__p_FXAccelTable,
+  _swigc__p_FXApp,
+  _swigc__p_FXArrowButton,
+  _swigc__p_FXBMPIcon,
+  _swigc__p_FXBMPImage,
+  _swigc__p_FXBitmap,
+  _swigc__p_FXBitmapFrame,
+  _swigc__p_FXCURCursor,
+  _swigc__p_FXCanvas,
+  _swigc__p_FXColorBar,
+  _swigc__p_FXColorRing,
+  _swigc__p_FXColorSelector,
+  _swigc__p_FXColorWell,
+  _swigc__p_FXColorWheel,
+  _swigc__p_FXComboBox,
+  _swigc__p_FXComposite,
+  _swigc__p_FXCursor,
+  _swigc__p_FXDataTarget,
+  _swigc__p_FXDebugTarget,
+  _swigc__p_FXDelegator,
+  _swigc__p_FXDial,
+  _swigc__p_FXDict,
+  _swigc__p_FXDirBox,
+  _swigc__p_FXDirSelector,
+  _swigc__p_FXDockBar,
+  _swigc__p_FXDockHandler,
+  _swigc__p_FXDockSite,
+  _swigc__p_FXDockTitle,
+  _swigc__p_FXDocument,
+  _swigc__p_FXDragCorner,
+  _swigc__p_FXDrawable,
+  _swigc__p_FXDriveBox,
+  _swigc__p_FXFileDict,
+  _swigc__p_FXFileSelector,
+  _swigc__p_FXFileStream,
+  _swigc__p_FXFont,
+  _swigc__p_FXFontSelector,
+  _swigc__p_FXFrame,
+  _swigc__p_FXGIFCursor,
+  _swigc__p_FXGIFIcon,
+  _swigc__p_FXGIFImage,
+  _swigc__p_FXGradientBar,
+  _swigc__p_FXGroupBox,
+  _swigc__p_FXHeader,
+  _swigc__p_FXHeaderItem,
+  _swigc__p_FXHorizontalFrame,
+  _swigc__p_FXHorizontalSeparator,
+  _swigc__p_FXICOIcon,
+  _swigc__p_FXICOImage,
+  _swigc__p_FXIcon,
+  _swigc__p_FXIconDict,
+  _swigc__p_FXIconSource,
+  _swigc__p_FXId,
+  _swigc__p_FXImage,
+  _swigc__p_FXImageFrame,
+  _swigc__p_FXImageView,
+  _swigc__p_FXJPGIcon,
+  _swigc__p_FXJPGImage,
+  _swigc__p_FXKnob,
+  _swigc__p_FXListBox,
+  _swigc__p_FXMainWindow,
+  _swigc__p_FXMatrix,
+  _swigc__p_FXMemoryStream,
+  _swigc__p_FXObject,
+  _swigc__p_FXPCXIcon,
+  _swigc__p_FXPCXImage,
+  _swigc__p_FXPNGIcon,
+  _swigc__p_FXPNGImage,
+  _swigc__p_FXPPMIcon,
+  _swigc__p_FXPPMImage,
+  _swigc__p_FXPacker,
+  _swigc__p_FXPopup,
+  _swigc__p_FXProgressBar,
+  _swigc__p_FXRGBIcon,
+  _swigc__p_FXRGBImage,
+  _swigc__p_FXRealSlider,
+  _swigc__p_FXRealSpinner,
+  _swigc__p_FXRecentFiles,
+  _swigc__p_FXRegistry,
+  _swigc__p_FXRootWindow,
+  _swigc__p_FXRuler,
+  _swigc__p_FXRulerView,
+  _swigc__p_FXScrollArea,
+  _swigc__p_FXScrollBar,
+  _swigc__p_FXScrollCorner,
+  _swigc__p_FXScrollWindow,
+  _swigc__p_FXSeparator,
+  _swigc__p_FXSettings,
+  _swigc__p_FXShell,
+  _swigc__p_FXShutter,
+  _swigc__p_FXShutterItem,
+  _swigc__p_FXSlider,
+  _swigc__p_FXSpinner,
+  _swigc__p_FXSplashWindow,
+  _swigc__p_FXSplitter,
+  _swigc__p_FXSpring,
+  _swigc__p_FXStatusBar,
+  _swigc__p_FXStatusLine,
+  _swigc__p_FXStream,
+  _swigc__p_FXStringDict,
+  _swigc__p_FXSwitcher,
+  _swigc__p_FXTGAIcon,
+  _swigc__p_FXTGAImage,
+  _swigc__p_FXTIFIcon,
+  _swigc__p_FXTIFImage,
+  _swigc__p_FXTabBar,
+  _swigc__p_FXTabBook,
+  _swigc__p_FXTextField,
+  _swigc__p_FXToolBar,
+  _swigc__p_FXToolBarGrip,
+  _swigc__p_FXToolBarShell,
+  _swigc__p_FXToolBarTab,
+  _swigc__p_FXToolTip,
+  _swigc__p_FXTopWindow,
+  _swigc__p_FXTranslator,
+  _swigc__p_FXTreeListBox,
+  _swigc__p_FXVerticalFrame,
+  _swigc__p_FXVerticalSeparator,
+  _swigc__p_FXVisual,
+  _swigc__p_FXWindow,
+  _swigc__p_FXXBMIcon,
+  _swigc__p_FXXBMImage,
+  _swigc__p_FXXPMIcon,
+  _swigc__p_FXXPMImage,
+  _swigc__p_char,
+  _swigc__p_double,
+  _swigc__p_float,
+  _swigc__p_int,
+  _swigc__p_long,
+  _swigc__p_p_char,
+  _swigc__p_short,
+  _swigc__p_unsigned_char,
+  _swigc__p_unsigned_int,
+  _swigc__p_unsigned_long,
+  _swigc__p_unsigned_short,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned statically to an initial
+ * array. We just loop through that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded.
+ * There are three cases to handle:
+ *  1) If the cast->type has already been loaded AND the type we are adding
+ *     casting info to has not been loaded (it is in this module), THEN we
+ *     replace the cast->type pointer with the type pointer that has already
+ *     been loaded.
+ *  2) If BOTH types (the one we are adding casting info to, and the
+ *     cast->type) are loaded, THEN the cast info has already been loaded by
+ *     the previous module so we just ignore it.
+ *  3) Finally, if cast->type has not already been loaded, then we add that
+ *     swig_cast_info to the linked list (because the cast->type) pointer will
+ *     be correct.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* c-mode */
+#endif
+#endif
+
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+  size_t i;
+  swig_module_info *module_head, *iter;
+  int init;
+
+  /* check to see if the circular list has been setup, if not, set it up */
+  if (swig_module.next==0) {
+    /* Initialize the swig_module */
+    swig_module.type_initial = swig_type_initial;
+    swig_module.cast_initial = swig_cast_initial;
+    swig_module.next = &swig_module;
+    init = 1;
+  } else {
+    init = 0;
+  }
+
+  /* Try and load any already created modules */
+  module_head = SWIG_GetModule(clientdata);
+  if (!module_head) {
+    /* This is the first module loaded for this interpreter */
+    /* so set the swig module into the interpreter */
+    SWIG_SetModule(clientdata, &swig_module);
+  } else {
+    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+    iter=module_head;
+    do {
+      if (iter==&swig_module) {
+        /* Our module is already in the list, so there's nothing more to do. */
+        return;
+      }
+      iter=iter->next;
+    } while (iter!= module_head);
+
+    /* otherwise we must add our module into the list */
+    swig_module.next = module_head->next;
+    module_head->next = &swig_module;
+  }
+
+  /* When multiple interpreters are used, a module could have already been initialized in
+     a different interpreter, but not yet have a pointer in this interpreter.
+     In this case, we do not want to continue adding types... everything should be
+     set up already */
+  if (init == 0) return;
+
+  /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+  for (i = 0; i < swig_module.size; ++i) {
+    swig_type_info *type = 0;
+    swig_type_info *ret;
+    swig_cast_info *cast;
+
+#ifdef SWIGRUNTIME_DEBUG
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+
+    /* if there is another module already loaded */
+    if (swig_module.next != &swig_module) {
+      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
+    }
+    if (type) {
+      /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+      if (swig_module.type_initial[i]->clientdata) {
+	type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+      }
+    } else {
+      type = swig_module.type_initial[i];
+    }
+
+    /* Insert casting types */
+    cast = swig_module.cast_initial[i];
+    while (cast->type) {
+
+      /* Don't need to add information already in the list */
+      ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+      if (swig_module.next != &swig_module) {
+        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+      }
+      if (ret) {
+	if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+	  cast->type = ret;
+	  ret = 0;
+	} else {
+	  /* Check for casting already in the list */
+	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+	  if (!ocast) ret = 0;
+	}
+      }
+
+      if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+        if (type->cast) {
+          type->cast->prev = cast;
+          cast->next = type->cast;
+        }
+        type->cast = cast;
+      }
+      cast++;
+    }
+    /* Set entry in modules->types array equal to the type */
+    swig_module.types[i] = type;
+  }
+  swig_module.types[i] = 0;
+
+#ifdef SWIGRUNTIME_DEBUG
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+  for (i = 0; i < swig_module.size; ++i) {
+    int j = 0;
+    swig_cast_info *cast = swig_module.cast_initial[i];
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    while (cast->type) {
+      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+      cast++;
+      ++j;
+    }
+  printf("---- Total casts: %d\n",j);
+  }
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types.  It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+  size_t i;
+  swig_cast_info *equiv;
+  static int init_run = 0;
+
+  if (init_run) return;
+  init_run = 1;
+
+  for (i = 0; i < swig_module.size; i++) {
+    if (swig_module.types[i]->clientdata) {
+      equiv = swig_module.types[i]->cast;
+      while (equiv) {
+        if (!equiv->converter) {
+          if (equiv->type && !equiv->type->clientdata)
+            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+        }
+        equiv = equiv->next;
+      }
+    }
+  }
+}
+
+#ifdef __cplusplus
+#if 0
+{ /* c-mode */
+#endif
+}
+#endif
+
+/*
+
+*/
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void Init_icons(void) {
+  size_t i;
+  
+  SWIG_InitRuntime();
+  
+  
+  SWIG_InitializeModule(0);
+  for (i = 0; i < swig_module.size; i++) {
+    SWIG_define_class(swig_module.types[i]);
+  }
+  
+  SWIG_RubyInitializeTrackings();
+  
+  
+  
+  
+  
+  
+  SwigClassFXIcon.klass = rb_define_class_under(mFox, "FXIcon", ((swig_class *) SWIGTYPE_p_FXImage->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXIcon, (void *) &SwigClassFXIcon);
+  rb_define_alloc_func(SwigClassFXIcon.klass, _wrap_FXIcon_allocate);
+  rb_define_method(SwigClassFXIcon.klass, "initialize", VALUEFUNC(_wrap_new_FXIcon), -1);
+  rb_define_method(SwigClassFXIcon.klass, "getTransparentColor", VALUEFUNC(_wrap_FXIcon_getTransparentColor), -1);
+  rb_define_method(SwigClassFXIcon.klass, "setTransparentColor", VALUEFUNC(_wrap_FXIcon_setTransparentColor), -1);
+  rb_define_method(SwigClassFXIcon.klass, "save", VALUEFUNC(_wrap_FXIcon_save), -1);
+  rb_define_method(SwigClassFXIcon.klass, "load", VALUEFUNC(_wrap_FXIcon_load), -1);
+  rb_define_method(SwigClassFXIcon.klass, "create", VALUEFUNC(_wrap_FXIcon_create), -1);
+  rb_define_method(SwigClassFXIcon.klass, "detach", VALUEFUNC(_wrap_FXIcon_detach), -1);
+  rb_define_method(SwigClassFXIcon.klass, "destroy", VALUEFUNC(_wrap_FXIcon_destroy), -1);
+  rb_define_method(SwigClassFXIcon.klass, "resize", VALUEFUNC(_wrap_FXIcon_resize), -1);
+  rb_define_method(SwigClassFXIcon.klass, "restore", VALUEFUNC(_wrap_FXIcon_restore), -1);
+  rb_define_method(SwigClassFXIcon.klass, "render", VALUEFUNC(_wrap_FXIcon_render), -1);
+  rb_define_method(SwigClassFXIcon.klass, "release", VALUEFUNC(_wrap_FXIcon_release), -1);
+  rb_define_method(SwigClassFXIcon.klass, "scale", VALUEFUNC(_wrap_FXIcon_scale), -1);
+  rb_define_method(SwigClassFXIcon.klass, "mirror", VALUEFUNC(_wrap_FXIcon_mirror), -1);
+  rb_define_method(SwigClassFXIcon.klass, "rotate", VALUEFUNC(_wrap_FXIcon_rotate), -1);
+  rb_define_method(SwigClassFXIcon.klass, "crop", VALUEFUNC(_wrap_FXIcon_crop), -1);
+  rb_define_method(SwigClassFXIcon.klass, "fill", VALUEFUNC(_wrap_FXIcon_fill), -1);
+  rb_define_method(SwigClassFXIcon.klass, "fade", VALUEFUNC(_wrap_FXIcon_fade), -1);
+  rb_define_method(SwigClassFXIcon.klass, "xshear", VALUEFUNC(_wrap_FXIcon_xshear), -1);
+  rb_define_method(SwigClassFXIcon.klass, "yshear", VALUEFUNC(_wrap_FXIcon_yshear), -1);
+  rb_define_method(SwigClassFXIcon.klass, "hgradient", VALUEFUNC(_wrap_FXIcon_hgradient), -1);
+  rb_define_method(SwigClassFXIcon.klass, "vgradient", VALUEFUNC(_wrap_FXIcon_vgradient), -1);
+  rb_define_method(SwigClassFXIcon.klass, "gradient", VALUEFUNC(_wrap_FXIcon_gradient), -1);
+  rb_define_method(SwigClassFXIcon.klass, "blend", VALUEFUNC(_wrap_FXIcon_blend), -1);
+  rb_define_method(SwigClassFXIcon.klass, "savePixels", VALUEFUNC(_wrap_FXIcon_savePixels), -1);
+  rb_define_method(SwigClassFXIcon.klass, "loadPixels", VALUEFUNC(_wrap_FXIcon_loadPixels), -1);
+  SwigClassFXIcon.mark = (void (*)(void *)) FXRbIcon::markfunc;
+  SwigClassFXIcon.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXIcon.trackObjects = 0;
+  
+  SWIGTYPE_p_FXIcon->dcast = (swig_dycast_func) FXIcon_dynamic_cast;
+  
+  
+  SwigClassFXIconSource.klass = rb_define_class_under(mFox, "FXIconSource", ((swig_class *) SWIGTYPE_p_FXObject->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXIconSource, (void *) &SwigClassFXIconSource);
+  rb_define_alloc_func(SwigClassFXIconSource.klass, _wrap_FXIconSource_allocate);
+  rb_define_method(SwigClassFXIconSource.klass, "initialize", VALUEFUNC(_wrap_new_FXIconSource), -1);
+  rb_define_method(SwigClassFXIconSource.klass, "save", VALUEFUNC(_wrap_FXIconSource_save), -1);
+  rb_define_method(SwigClassFXIconSource.klass, "load", VALUEFUNC(_wrap_FXIconSource_load), -1);
+  rb_define_method(SwigClassFXIconSource.klass, "loadIconFile", VALUEFUNC(_wrap_FXIconSource_loadIconFile), -1);
+  rb_define_method(SwigClassFXIconSource.klass, "loadIconData", VALUEFUNC(_wrap_FXIconSource_loadIconData), -1);
+  rb_define_method(SwigClassFXIconSource.klass, "loadIconStream", VALUEFUNC(_wrap_FXIconSource_loadIconStream), -1);
+  rb_define_method(SwigClassFXIconSource.klass, "loadImageFile", VALUEFUNC(_wrap_FXIconSource_loadImageFile), -1);
+  rb_define_method(SwigClassFXIconSource.klass, "loadImageData", VALUEFUNC(_wrap_FXIconSource_loadImageData), -1);
+  rb_define_method(SwigClassFXIconSource.klass, "loadImageStream", VALUEFUNC(_wrap_FXIconSource_loadImageStream), -1);
+  rb_define_method(SwigClassFXIconSource.klass, "loadScaledIconFile", VALUEFUNC(_wrap_FXIconSource_loadScaledIconFile), -1);
+  rb_define_method(SwigClassFXIconSource.klass, "loadScaledIconData", VALUEFUNC(_wrap_FXIconSource_loadScaledIconData), -1);
+  rb_define_method(SwigClassFXIconSource.klass, "loadScaledIconStream", VALUEFUNC(_wrap_FXIconSource_loadScaledIconStream), -1);
+  rb_define_method(SwigClassFXIconSource.klass, "loadScaledImageFile", VALUEFUNC(_wrap_FXIconSource_loadScaledImageFile), -1);
+  rb_define_method(SwigClassFXIconSource.klass, "loadScaledImageData", VALUEFUNC(_wrap_FXIconSource_loadScaledImageData), -1);
+  rb_define_method(SwigClassFXIconSource.klass, "loadScaledImageStream", VALUEFUNC(_wrap_FXIconSource_loadScaledImageStream), -1);
+  SwigClassFXIconSource.mark = (void (*)(void *)) FXRbIconSource::markfunc;
+  SwigClassFXIconSource.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXIconSource.trackObjects = 0;
+  
+  SwigClassFXBMPIcon.klass = rb_define_class_under(mFox, "FXBMPIcon", ((swig_class *) SWIGTYPE_p_FXIcon->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXBMPIcon, (void *) &SwigClassFXBMPIcon);
+  rb_define_alloc_func(SwigClassFXBMPIcon.klass, _wrap_FXBMPIcon_allocate);
+  rb_define_method(SwigClassFXBMPIcon.klass, "initialize", VALUEFUNC(_wrap_new_FXBMPIcon), -1);
+  rb_define_singleton_method(SwigClassFXBMPIcon.klass, "fileExt", VALUEFUNC(_wrap_FXBMPIcon_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXBMPIcon.klass, "mimeType", VALUEFUNC(_wrap_FXBMPIcon_mimeType), -1);
+  rb_define_method(SwigClassFXBMPIcon.klass, "save", VALUEFUNC(_wrap_FXBMPIcon_save), -1);
+  rb_define_method(SwigClassFXBMPIcon.klass, "load", VALUEFUNC(_wrap_FXBMPIcon_load), -1);
+  rb_define_method(SwigClassFXBMPIcon.klass, "create", VALUEFUNC(_wrap_FXBMPIcon_create), -1);
+  rb_define_method(SwigClassFXBMPIcon.klass, "detach", VALUEFUNC(_wrap_FXBMPIcon_detach), -1);
+  rb_define_method(SwigClassFXBMPIcon.klass, "destroy", VALUEFUNC(_wrap_FXBMPIcon_destroy), -1);
+  rb_define_method(SwigClassFXBMPIcon.klass, "resize", VALUEFUNC(_wrap_FXBMPIcon_resize), -1);
+  rb_define_method(SwigClassFXBMPIcon.klass, "restore", VALUEFUNC(_wrap_FXBMPIcon_restore), -1);
+  rb_define_method(SwigClassFXBMPIcon.klass, "render", VALUEFUNC(_wrap_FXBMPIcon_render), -1);
+  rb_define_method(SwigClassFXBMPIcon.klass, "release", VALUEFUNC(_wrap_FXBMPIcon_release), -1);
+  rb_define_method(SwigClassFXBMPIcon.klass, "scale", VALUEFUNC(_wrap_FXBMPIcon_scale), -1);
+  rb_define_method(SwigClassFXBMPIcon.klass, "mirror", VALUEFUNC(_wrap_FXBMPIcon_mirror), -1);
+  rb_define_method(SwigClassFXBMPIcon.klass, "rotate", VALUEFUNC(_wrap_FXBMPIcon_rotate), -1);
+  rb_define_method(SwigClassFXBMPIcon.klass, "crop", VALUEFUNC(_wrap_FXBMPIcon_crop), -1);
+  rb_define_method(SwigClassFXBMPIcon.klass, "fill", VALUEFUNC(_wrap_FXBMPIcon_fill), -1);
+  rb_define_method(SwigClassFXBMPIcon.klass, "fade", VALUEFUNC(_wrap_FXBMPIcon_fade), -1);
+  rb_define_method(SwigClassFXBMPIcon.klass, "xshear", VALUEFUNC(_wrap_FXBMPIcon_xshear), -1);
+  rb_define_method(SwigClassFXBMPIcon.klass, "yshear", VALUEFUNC(_wrap_FXBMPIcon_yshear), -1);
+  rb_define_method(SwigClassFXBMPIcon.klass, "hgradient", VALUEFUNC(_wrap_FXBMPIcon_hgradient), -1);
+  rb_define_method(SwigClassFXBMPIcon.klass, "vgradient", VALUEFUNC(_wrap_FXBMPIcon_vgradient), -1);
+  rb_define_method(SwigClassFXBMPIcon.klass, "gradient", VALUEFUNC(_wrap_FXBMPIcon_gradient), -1);
+  rb_define_method(SwigClassFXBMPIcon.klass, "blend", VALUEFUNC(_wrap_FXBMPIcon_blend), -1);
+  rb_define_method(SwigClassFXBMPIcon.klass, "savePixels", VALUEFUNC(_wrap_FXBMPIcon_savePixels), -1);
+  rb_define_method(SwigClassFXBMPIcon.klass, "loadPixels", VALUEFUNC(_wrap_FXBMPIcon_loadPixels), -1);
+  SwigClassFXBMPIcon.mark = (void (*)(void *)) FXRbBMPIcon::markfunc;
+  SwigClassFXBMPIcon.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXBMPIcon.trackObjects = 0;
+  rb_define_module_function(mFox, "fxloadBMP", VALUEFUNC(_wrap_fxloadBMP), -1);
+  rb_define_module_function(mFox, "fxsaveBMP", VALUEFUNC(_wrap_fxsaveBMP), -1);
+  rb_define_module_function(mFox, "fxcheckBMP", VALUEFUNC(_wrap_fxcheckBMP), -1);
+  
+  SwigClassFXGIFIcon.klass = rb_define_class_under(mFox, "FXGIFIcon", ((swig_class *) SWIGTYPE_p_FXIcon->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXGIFIcon, (void *) &SwigClassFXGIFIcon);
+  rb_define_alloc_func(SwigClassFXGIFIcon.klass, _wrap_FXGIFIcon_allocate);
+  rb_define_method(SwigClassFXGIFIcon.klass, "initialize", VALUEFUNC(_wrap_new_FXGIFIcon), -1);
+  rb_define_singleton_method(SwigClassFXGIFIcon.klass, "fileExt", VALUEFUNC(_wrap_FXGIFIcon_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXGIFIcon.klass, "mimeType", VALUEFUNC(_wrap_FXGIFIcon_mimeType), -1);
+  rb_define_method(SwigClassFXGIFIcon.klass, "save", VALUEFUNC(_wrap_FXGIFIcon_save), -1);
+  rb_define_method(SwigClassFXGIFIcon.klass, "load", VALUEFUNC(_wrap_FXGIFIcon_load), -1);
+  rb_define_method(SwigClassFXGIFIcon.klass, "create", VALUEFUNC(_wrap_FXGIFIcon_create), -1);
+  rb_define_method(SwigClassFXGIFIcon.klass, "detach", VALUEFUNC(_wrap_FXGIFIcon_detach), -1);
+  rb_define_method(SwigClassFXGIFIcon.klass, "destroy", VALUEFUNC(_wrap_FXGIFIcon_destroy), -1);
+  rb_define_method(SwigClassFXGIFIcon.klass, "resize", VALUEFUNC(_wrap_FXGIFIcon_resize), -1);
+  rb_define_method(SwigClassFXGIFIcon.klass, "restore", VALUEFUNC(_wrap_FXGIFIcon_restore), -1);
+  rb_define_method(SwigClassFXGIFIcon.klass, "render", VALUEFUNC(_wrap_FXGIFIcon_render), -1);
+  rb_define_method(SwigClassFXGIFIcon.klass, "release", VALUEFUNC(_wrap_FXGIFIcon_release), -1);
+  rb_define_method(SwigClassFXGIFIcon.klass, "scale", VALUEFUNC(_wrap_FXGIFIcon_scale), -1);
+  rb_define_method(SwigClassFXGIFIcon.klass, "mirror", VALUEFUNC(_wrap_FXGIFIcon_mirror), -1);
+  rb_define_method(SwigClassFXGIFIcon.klass, "rotate", VALUEFUNC(_wrap_FXGIFIcon_rotate), -1);
+  rb_define_method(SwigClassFXGIFIcon.klass, "crop", VALUEFUNC(_wrap_FXGIFIcon_crop), -1);
+  rb_define_method(SwigClassFXGIFIcon.klass, "fill", VALUEFUNC(_wrap_FXGIFIcon_fill), -1);
+  rb_define_method(SwigClassFXGIFIcon.klass, "fade", VALUEFUNC(_wrap_FXGIFIcon_fade), -1);
+  rb_define_method(SwigClassFXGIFIcon.klass, "xshear", VALUEFUNC(_wrap_FXGIFIcon_xshear), -1);
+  rb_define_method(SwigClassFXGIFIcon.klass, "yshear", VALUEFUNC(_wrap_FXGIFIcon_yshear), -1);
+  rb_define_method(SwigClassFXGIFIcon.klass, "hgradient", VALUEFUNC(_wrap_FXGIFIcon_hgradient), -1);
+  rb_define_method(SwigClassFXGIFIcon.klass, "vgradient", VALUEFUNC(_wrap_FXGIFIcon_vgradient), -1);
+  rb_define_method(SwigClassFXGIFIcon.klass, "gradient", VALUEFUNC(_wrap_FXGIFIcon_gradient), -1);
+  rb_define_method(SwigClassFXGIFIcon.klass, "blend", VALUEFUNC(_wrap_FXGIFIcon_blend), -1);
+  rb_define_method(SwigClassFXGIFIcon.klass, "savePixels", VALUEFUNC(_wrap_FXGIFIcon_savePixels), -1);
+  rb_define_method(SwigClassFXGIFIcon.klass, "loadPixels", VALUEFUNC(_wrap_FXGIFIcon_loadPixels), -1);
+  SwigClassFXGIFIcon.mark = (void (*)(void *)) FXRbGIFIcon::markfunc;
+  SwigClassFXGIFIcon.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXGIFIcon.trackObjects = 0;
+  
+  SwigClassFXICOIcon.klass = rb_define_class_under(mFox, "FXICOIcon", ((swig_class *) SWIGTYPE_p_FXIcon->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXICOIcon, (void *) &SwigClassFXICOIcon);
+  rb_define_alloc_func(SwigClassFXICOIcon.klass, _wrap_FXICOIcon_allocate);
+  rb_define_method(SwigClassFXICOIcon.klass, "initialize", VALUEFUNC(_wrap_new_FXICOIcon), -1);
+  rb_define_singleton_method(SwigClassFXICOIcon.klass, "fileExt", VALUEFUNC(_wrap_FXICOIcon_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXICOIcon.klass, "mimeType", VALUEFUNC(_wrap_FXICOIcon_mimeType), -1);
+  rb_define_method(SwigClassFXICOIcon.klass, "save", VALUEFUNC(_wrap_FXICOIcon_save), -1);
+  rb_define_method(SwigClassFXICOIcon.klass, "load", VALUEFUNC(_wrap_FXICOIcon_load), -1);
+  rb_define_method(SwigClassFXICOIcon.klass, "create", VALUEFUNC(_wrap_FXICOIcon_create), -1);
+  rb_define_method(SwigClassFXICOIcon.klass, "detach", VALUEFUNC(_wrap_FXICOIcon_detach), -1);
+  rb_define_method(SwigClassFXICOIcon.klass, "destroy", VALUEFUNC(_wrap_FXICOIcon_destroy), -1);
+  rb_define_method(SwigClassFXICOIcon.klass, "resize", VALUEFUNC(_wrap_FXICOIcon_resize), -1);
+  rb_define_method(SwigClassFXICOIcon.klass, "restore", VALUEFUNC(_wrap_FXICOIcon_restore), -1);
+  rb_define_method(SwigClassFXICOIcon.klass, "render", VALUEFUNC(_wrap_FXICOIcon_render), -1);
+  rb_define_method(SwigClassFXICOIcon.klass, "release", VALUEFUNC(_wrap_FXICOIcon_release), -1);
+  rb_define_method(SwigClassFXICOIcon.klass, "scale", VALUEFUNC(_wrap_FXICOIcon_scale), -1);
+  rb_define_method(SwigClassFXICOIcon.klass, "mirror", VALUEFUNC(_wrap_FXICOIcon_mirror), -1);
+  rb_define_method(SwigClassFXICOIcon.klass, "rotate", VALUEFUNC(_wrap_FXICOIcon_rotate), -1);
+  rb_define_method(SwigClassFXICOIcon.klass, "crop", VALUEFUNC(_wrap_FXICOIcon_crop), -1);
+  rb_define_method(SwigClassFXICOIcon.klass, "fill", VALUEFUNC(_wrap_FXICOIcon_fill), -1);
+  rb_define_method(SwigClassFXICOIcon.klass, "fade", VALUEFUNC(_wrap_FXICOIcon_fade), -1);
+  rb_define_method(SwigClassFXICOIcon.klass, "xshear", VALUEFUNC(_wrap_FXICOIcon_xshear), -1);
+  rb_define_method(SwigClassFXICOIcon.klass, "yshear", VALUEFUNC(_wrap_FXICOIcon_yshear), -1);
+  rb_define_method(SwigClassFXICOIcon.klass, "hgradient", VALUEFUNC(_wrap_FXICOIcon_hgradient), -1);
+  rb_define_method(SwigClassFXICOIcon.klass, "vgradient", VALUEFUNC(_wrap_FXICOIcon_vgradient), -1);
+  rb_define_method(SwigClassFXICOIcon.klass, "gradient", VALUEFUNC(_wrap_FXICOIcon_gradient), -1);
+  rb_define_method(SwigClassFXICOIcon.klass, "blend", VALUEFUNC(_wrap_FXICOIcon_blend), -1);
+  rb_define_method(SwigClassFXICOIcon.klass, "savePixels", VALUEFUNC(_wrap_FXICOIcon_savePixels), -1);
+  rb_define_method(SwigClassFXICOIcon.klass, "loadPixels", VALUEFUNC(_wrap_FXICOIcon_loadPixels), -1);
+  SwigClassFXICOIcon.mark = (void (*)(void *)) FXRbICOIcon::markfunc;
+  SwigClassFXICOIcon.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXICOIcon.trackObjects = 0;
+  rb_define_module_function(mFox, "fxloadICO", VALUEFUNC(_wrap_fxloadICO), -1);
+  rb_define_module_function(mFox, "fxsaveICO", VALUEFUNC(_wrap_fxsaveICO), -1);
+  rb_define_module_function(mFox, "fxcheckICO", VALUEFUNC(_wrap_fxcheckICO), -1);
+  
+  SwigClassFXJPGIcon.klass = rb_define_class_under(mFox, "FXJPGIcon", ((swig_class *) SWIGTYPE_p_FXIcon->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXJPGIcon, (void *) &SwigClassFXJPGIcon);
+  rb_define_alloc_func(SwigClassFXJPGIcon.klass, _wrap_FXJPGIcon_allocate);
+  rb_define_method(SwigClassFXJPGIcon.klass, "initialize", VALUEFUNC(_wrap_new_FXJPGIcon), -1);
+  rb_define_singleton_method(SwigClassFXJPGIcon.klass, "fileExt", VALUEFUNC(_wrap_FXJPGIcon_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXJPGIcon.klass, "mimeType", VALUEFUNC(_wrap_FXJPGIcon_mimeType), -1);
+  rb_define_singleton_method(SwigClassFXJPGIcon.klass, "supported_Sq_", VALUEFUNC(_wrap_FXJPGIcon_supported_Sq_), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "setQuality", VALUEFUNC(_wrap_FXJPGIcon_setQuality), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "getQuality", VALUEFUNC(_wrap_FXJPGIcon_getQuality), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "save", VALUEFUNC(_wrap_FXJPGIcon_save), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "load", VALUEFUNC(_wrap_FXJPGIcon_load), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "create", VALUEFUNC(_wrap_FXJPGIcon_create), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "detach", VALUEFUNC(_wrap_FXJPGIcon_detach), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "destroy", VALUEFUNC(_wrap_FXJPGIcon_destroy), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "resize", VALUEFUNC(_wrap_FXJPGIcon_resize), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "restore", VALUEFUNC(_wrap_FXJPGIcon_restore), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "render", VALUEFUNC(_wrap_FXJPGIcon_render), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "release", VALUEFUNC(_wrap_FXJPGIcon_release), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "scale", VALUEFUNC(_wrap_FXJPGIcon_scale), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "mirror", VALUEFUNC(_wrap_FXJPGIcon_mirror), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "rotate", VALUEFUNC(_wrap_FXJPGIcon_rotate), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "crop", VALUEFUNC(_wrap_FXJPGIcon_crop), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "fill", VALUEFUNC(_wrap_FXJPGIcon_fill), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "fade", VALUEFUNC(_wrap_FXJPGIcon_fade), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "xshear", VALUEFUNC(_wrap_FXJPGIcon_xshear), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "yshear", VALUEFUNC(_wrap_FXJPGIcon_yshear), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "hgradient", VALUEFUNC(_wrap_FXJPGIcon_hgradient), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "vgradient", VALUEFUNC(_wrap_FXJPGIcon_vgradient), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "gradient", VALUEFUNC(_wrap_FXJPGIcon_gradient), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "blend", VALUEFUNC(_wrap_FXJPGIcon_blend), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "savePixels", VALUEFUNC(_wrap_FXJPGIcon_savePixels), -1);
+  rb_define_method(SwigClassFXJPGIcon.klass, "loadPixels", VALUEFUNC(_wrap_FXJPGIcon_loadPixels), -1);
+  SwigClassFXJPGIcon.mark = (void (*)(void *)) FXRbJPGIcon::markfunc;
+  SwigClassFXJPGIcon.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXJPGIcon.trackObjects = 0;
+  rb_define_module_function(mFox, "fxloadJPG", VALUEFUNC(_wrap_fxloadJPG), -1);
+  rb_define_module_function(mFox, "fxsaveJPG", VALUEFUNC(_wrap_fxsaveJPG), -1);
+  rb_define_module_function(mFox, "fxcheckJPG", VALUEFUNC(_wrap_fxcheckJPG), -1);
+  
+  SwigClassFXPCXIcon.klass = rb_define_class_under(mFox, "FXPCXIcon", ((swig_class *) SWIGTYPE_p_FXIcon->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXPCXIcon, (void *) &SwigClassFXPCXIcon);
+  rb_define_alloc_func(SwigClassFXPCXIcon.klass, _wrap_FXPCXIcon_allocate);
+  rb_define_method(SwigClassFXPCXIcon.klass, "initialize", VALUEFUNC(_wrap_new_FXPCXIcon), -1);
+  rb_define_singleton_method(SwigClassFXPCXIcon.klass, "fileExt", VALUEFUNC(_wrap_FXPCXIcon_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXPCXIcon.klass, "mimeType", VALUEFUNC(_wrap_FXPCXIcon_mimeType), -1);
+  rb_define_method(SwigClassFXPCXIcon.klass, "save", VALUEFUNC(_wrap_FXPCXIcon_save), -1);
+  rb_define_method(SwigClassFXPCXIcon.klass, "load", VALUEFUNC(_wrap_FXPCXIcon_load), -1);
+  rb_define_method(SwigClassFXPCXIcon.klass, "create", VALUEFUNC(_wrap_FXPCXIcon_create), -1);
+  rb_define_method(SwigClassFXPCXIcon.klass, "detach", VALUEFUNC(_wrap_FXPCXIcon_detach), -1);
+  rb_define_method(SwigClassFXPCXIcon.klass, "destroy", VALUEFUNC(_wrap_FXPCXIcon_destroy), -1);
+  rb_define_method(SwigClassFXPCXIcon.klass, "resize", VALUEFUNC(_wrap_FXPCXIcon_resize), -1);
+  rb_define_method(SwigClassFXPCXIcon.klass, "restore", VALUEFUNC(_wrap_FXPCXIcon_restore), -1);
+  rb_define_method(SwigClassFXPCXIcon.klass, "render", VALUEFUNC(_wrap_FXPCXIcon_render), -1);
+  rb_define_method(SwigClassFXPCXIcon.klass, "release", VALUEFUNC(_wrap_FXPCXIcon_release), -1);
+  rb_define_method(SwigClassFXPCXIcon.klass, "scale", VALUEFUNC(_wrap_FXPCXIcon_scale), -1);
+  rb_define_method(SwigClassFXPCXIcon.klass, "mirror", VALUEFUNC(_wrap_FXPCXIcon_mirror), -1);
+  rb_define_method(SwigClassFXPCXIcon.klass, "rotate", VALUEFUNC(_wrap_FXPCXIcon_rotate), -1);
+  rb_define_method(SwigClassFXPCXIcon.klass, "crop", VALUEFUNC(_wrap_FXPCXIcon_crop), -1);
+  rb_define_method(SwigClassFXPCXIcon.klass, "fill", VALUEFUNC(_wrap_FXPCXIcon_fill), -1);
+  rb_define_method(SwigClassFXPCXIcon.klass, "fade", VALUEFUNC(_wrap_FXPCXIcon_fade), -1);
+  rb_define_method(SwigClassFXPCXIcon.klass, "xshear", VALUEFUNC(_wrap_FXPCXIcon_xshear), -1);
+  rb_define_method(SwigClassFXPCXIcon.klass, "yshear", VALUEFUNC(_wrap_FXPCXIcon_yshear), -1);
+  rb_define_method(SwigClassFXPCXIcon.klass, "hgradient", VALUEFUNC(_wrap_FXPCXIcon_hgradient), -1);
+  rb_define_method(SwigClassFXPCXIcon.klass, "vgradient", VALUEFUNC(_wrap_FXPCXIcon_vgradient), -1);
+  rb_define_method(SwigClassFXPCXIcon.klass, "gradient", VALUEFUNC(_wrap_FXPCXIcon_gradient), -1);
+  rb_define_method(SwigClassFXPCXIcon.klass, "blend", VALUEFUNC(_wrap_FXPCXIcon_blend), -1);
+  rb_define_method(SwigClassFXPCXIcon.klass, "savePixels", VALUEFUNC(_wrap_FXPCXIcon_savePixels), -1);
+  rb_define_method(SwigClassFXPCXIcon.klass, "loadPixels", VALUEFUNC(_wrap_FXPCXIcon_loadPixels), -1);
+  SwigClassFXPCXIcon.mark = (void (*)(void *)) FXRbPCXIcon::markfunc;
+  SwigClassFXPCXIcon.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXPCXIcon.trackObjects = 0;
+  rb_define_module_function(mFox, "fxloadPCX", VALUEFUNC(_wrap_fxloadPCX), -1);
+  rb_define_module_function(mFox, "fxsavePCX", VALUEFUNC(_wrap_fxsavePCX), -1);
+  rb_define_module_function(mFox, "fxcheckPCX", VALUEFUNC(_wrap_fxcheckPCX), -1);
+  
+  SwigClassFXPNGIcon.klass = rb_define_class_under(mFox, "FXPNGIcon", ((swig_class *) SWIGTYPE_p_FXIcon->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXPNGIcon, (void *) &SwigClassFXPNGIcon);
+  rb_define_alloc_func(SwigClassFXPNGIcon.klass, _wrap_FXPNGIcon_allocate);
+  rb_define_method(SwigClassFXPNGIcon.klass, "initialize", VALUEFUNC(_wrap_new_FXPNGIcon), -1);
+  rb_define_singleton_method(SwigClassFXPNGIcon.klass, "fileExt", VALUEFUNC(_wrap_FXPNGIcon_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXPNGIcon.klass, "mimeType", VALUEFUNC(_wrap_FXPNGIcon_mimeType), -1);
+  rb_define_singleton_method(SwigClassFXPNGIcon.klass, "supported_Sq_", VALUEFUNC(_wrap_FXPNGIcon_supported_Sq_), -1);
+  rb_define_method(SwigClassFXPNGIcon.klass, "save", VALUEFUNC(_wrap_FXPNGIcon_save), -1);
+  rb_define_method(SwigClassFXPNGIcon.klass, "load", VALUEFUNC(_wrap_FXPNGIcon_load), -1);
+  rb_define_method(SwigClassFXPNGIcon.klass, "create", VALUEFUNC(_wrap_FXPNGIcon_create), -1);
+  rb_define_method(SwigClassFXPNGIcon.klass, "detach", VALUEFUNC(_wrap_FXPNGIcon_detach), -1);
+  rb_define_method(SwigClassFXPNGIcon.klass, "destroy", VALUEFUNC(_wrap_FXPNGIcon_destroy), -1);
+  rb_define_method(SwigClassFXPNGIcon.klass, "resize", VALUEFUNC(_wrap_FXPNGIcon_resize), -1);
+  rb_define_method(SwigClassFXPNGIcon.klass, "restore", VALUEFUNC(_wrap_FXPNGIcon_restore), -1);
+  rb_define_method(SwigClassFXPNGIcon.klass, "render", VALUEFUNC(_wrap_FXPNGIcon_render), -1);
+  rb_define_method(SwigClassFXPNGIcon.klass, "release", VALUEFUNC(_wrap_FXPNGIcon_release), -1);
+  rb_define_method(SwigClassFXPNGIcon.klass, "scale", VALUEFUNC(_wrap_FXPNGIcon_scale), -1);
+  rb_define_method(SwigClassFXPNGIcon.klass, "mirror", VALUEFUNC(_wrap_FXPNGIcon_mirror), -1);
+  rb_define_method(SwigClassFXPNGIcon.klass, "rotate", VALUEFUNC(_wrap_FXPNGIcon_rotate), -1);
+  rb_define_method(SwigClassFXPNGIcon.klass, "crop", VALUEFUNC(_wrap_FXPNGIcon_crop), -1);
+  rb_define_method(SwigClassFXPNGIcon.klass, "fill", VALUEFUNC(_wrap_FXPNGIcon_fill), -1);
+  rb_define_method(SwigClassFXPNGIcon.klass, "fade", VALUEFUNC(_wrap_FXPNGIcon_fade), -1);
+  rb_define_method(SwigClassFXPNGIcon.klass, "xshear", VALUEFUNC(_wrap_FXPNGIcon_xshear), -1);
+  rb_define_method(SwigClassFXPNGIcon.klass, "yshear", VALUEFUNC(_wrap_FXPNGIcon_yshear), -1);
+  rb_define_method(SwigClassFXPNGIcon.klass, "hgradient", VALUEFUNC(_wrap_FXPNGIcon_hgradient), -1);
+  rb_define_method(SwigClassFXPNGIcon.klass, "vgradient", VALUEFUNC(_wrap_FXPNGIcon_vgradient), -1);
+  rb_define_method(SwigClassFXPNGIcon.klass, "gradient", VALUEFUNC(_wrap_FXPNGIcon_gradient), -1);
+  rb_define_method(SwigClassFXPNGIcon.klass, "blend", VALUEFUNC(_wrap_FXPNGIcon_blend), -1);
+  rb_define_method(SwigClassFXPNGIcon.klass, "savePixels", VALUEFUNC(_wrap_FXPNGIcon_savePixels), -1);
+  rb_define_method(SwigClassFXPNGIcon.klass, "loadPixels", VALUEFUNC(_wrap_FXPNGIcon_loadPixels), -1);
+  SwigClassFXPNGIcon.mark = (void (*)(void *)) FXRbPNGIcon::markfunc;
+  SwigClassFXPNGIcon.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXPNGIcon.trackObjects = 0;
+  rb_define_module_function(mFox, "fxloadPNG", VALUEFUNC(_wrap_fxloadPNG), -1);
+  rb_define_module_function(mFox, "fxsavePNG", VALUEFUNC(_wrap_fxsavePNG), -1);
+  rb_define_module_function(mFox, "fxcheckPNG", VALUEFUNC(_wrap_fxcheckPNG), -1);
+  
+  SwigClassFXPPMIcon.klass = rb_define_class_under(mFox, "FXPPMIcon", ((swig_class *) SWIGTYPE_p_FXIcon->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXPPMIcon, (void *) &SwigClassFXPPMIcon);
+  rb_define_alloc_func(SwigClassFXPPMIcon.klass, _wrap_FXPPMIcon_allocate);
+  rb_define_method(SwigClassFXPPMIcon.klass, "initialize", VALUEFUNC(_wrap_new_FXPPMIcon), -1);
+  rb_define_singleton_method(SwigClassFXPPMIcon.klass, "fileExt", VALUEFUNC(_wrap_FXPPMIcon_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXPPMIcon.klass, "mimeType", VALUEFUNC(_wrap_FXPPMIcon_mimeType), -1);
+  rb_define_method(SwigClassFXPPMIcon.klass, "save", VALUEFUNC(_wrap_FXPPMIcon_save), -1);
+  rb_define_method(SwigClassFXPPMIcon.klass, "load", VALUEFUNC(_wrap_FXPPMIcon_load), -1);
+  rb_define_method(SwigClassFXPPMIcon.klass, "create", VALUEFUNC(_wrap_FXPPMIcon_create), -1);
+  rb_define_method(SwigClassFXPPMIcon.klass, "detach", VALUEFUNC(_wrap_FXPPMIcon_detach), -1);
+  rb_define_method(SwigClassFXPPMIcon.klass, "destroy", VALUEFUNC(_wrap_FXPPMIcon_destroy), -1);
+  rb_define_method(SwigClassFXPPMIcon.klass, "resize", VALUEFUNC(_wrap_FXPPMIcon_resize), -1);
+  rb_define_method(SwigClassFXPPMIcon.klass, "restore", VALUEFUNC(_wrap_FXPPMIcon_restore), -1);
+  rb_define_method(SwigClassFXPPMIcon.klass, "render", VALUEFUNC(_wrap_FXPPMIcon_render), -1);
+  rb_define_method(SwigClassFXPPMIcon.klass, "release", VALUEFUNC(_wrap_FXPPMIcon_release), -1);
+  rb_define_method(SwigClassFXPPMIcon.klass, "scale", VALUEFUNC(_wrap_FXPPMIcon_scale), -1);
+  rb_define_method(SwigClassFXPPMIcon.klass, "mirror", VALUEFUNC(_wrap_FXPPMIcon_mirror), -1);
+  rb_define_method(SwigClassFXPPMIcon.klass, "rotate", VALUEFUNC(_wrap_FXPPMIcon_rotate), -1);
+  rb_define_method(SwigClassFXPPMIcon.klass, "crop", VALUEFUNC(_wrap_FXPPMIcon_crop), -1);
+  rb_define_method(SwigClassFXPPMIcon.klass, "fill", VALUEFUNC(_wrap_FXPPMIcon_fill), -1);
+  rb_define_method(SwigClassFXPPMIcon.klass, "fade", VALUEFUNC(_wrap_FXPPMIcon_fade), -1);
+  rb_define_method(SwigClassFXPPMIcon.klass, "xshear", VALUEFUNC(_wrap_FXPPMIcon_xshear), -1);
+  rb_define_method(SwigClassFXPPMIcon.klass, "yshear", VALUEFUNC(_wrap_FXPPMIcon_yshear), -1);
+  rb_define_method(SwigClassFXPPMIcon.klass, "hgradient", VALUEFUNC(_wrap_FXPPMIcon_hgradient), -1);
+  rb_define_method(SwigClassFXPPMIcon.klass, "vgradient", VALUEFUNC(_wrap_FXPPMIcon_vgradient), -1);
+  rb_define_method(SwigClassFXPPMIcon.klass, "gradient", VALUEFUNC(_wrap_FXPPMIcon_gradient), -1);
+  rb_define_method(SwigClassFXPPMIcon.klass, "blend", VALUEFUNC(_wrap_FXPPMIcon_blend), -1);
+  rb_define_method(SwigClassFXPPMIcon.klass, "savePixels", VALUEFUNC(_wrap_FXPPMIcon_savePixels), -1);
+  rb_define_method(SwigClassFXPPMIcon.klass, "loadPixels", VALUEFUNC(_wrap_FXPPMIcon_loadPixels), -1);
+  SwigClassFXPPMIcon.mark = 0;
+  SwigClassFXPPMIcon.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXPPMIcon.trackObjects = 0;
+  rb_define_module_function(mFox, "fxloadPPM", VALUEFUNC(_wrap_fxloadPPM), -1);
+  rb_define_module_function(mFox, "fxsavePPM", VALUEFUNC(_wrap_fxsavePPM), -1);
+  rb_define_module_function(mFox, "fxcheckPPM", VALUEFUNC(_wrap_fxcheckPPM), -1);
+  
+  SwigClassFXRGBIcon.klass = rb_define_class_under(mFox, "FXRGBIcon", ((swig_class *) SWIGTYPE_p_FXIcon->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXRGBIcon, (void *) &SwigClassFXRGBIcon);
+  rb_define_alloc_func(SwigClassFXRGBIcon.klass, _wrap_FXRGBIcon_allocate);
+  rb_define_method(SwigClassFXRGBIcon.klass, "initialize", VALUEFUNC(_wrap_new_FXRGBIcon), -1);
+  rb_define_singleton_method(SwigClassFXRGBIcon.klass, "fileExt", VALUEFUNC(_wrap_FXRGBIcon_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXRGBIcon.klass, "mimeType", VALUEFUNC(_wrap_FXRGBIcon_mimeType), -1);
+  rb_define_method(SwigClassFXRGBIcon.klass, "save", VALUEFUNC(_wrap_FXRGBIcon_save), -1);
+  rb_define_method(SwigClassFXRGBIcon.klass, "load", VALUEFUNC(_wrap_FXRGBIcon_load), -1);
+  rb_define_method(SwigClassFXRGBIcon.klass, "create", VALUEFUNC(_wrap_FXRGBIcon_create), -1);
+  rb_define_method(SwigClassFXRGBIcon.klass, "detach", VALUEFUNC(_wrap_FXRGBIcon_detach), -1);
+  rb_define_method(SwigClassFXRGBIcon.klass, "destroy", VALUEFUNC(_wrap_FXRGBIcon_destroy), -1);
+  rb_define_method(SwigClassFXRGBIcon.klass, "resize", VALUEFUNC(_wrap_FXRGBIcon_resize), -1);
+  rb_define_method(SwigClassFXRGBIcon.klass, "restore", VALUEFUNC(_wrap_FXRGBIcon_restore), -1);
+  rb_define_method(SwigClassFXRGBIcon.klass, "render", VALUEFUNC(_wrap_FXRGBIcon_render), -1);
+  rb_define_method(SwigClassFXRGBIcon.klass, "release", VALUEFUNC(_wrap_FXRGBIcon_release), -1);
+  rb_define_method(SwigClassFXRGBIcon.klass, "scale", VALUEFUNC(_wrap_FXRGBIcon_scale), -1);
+  rb_define_method(SwigClassFXRGBIcon.klass, "mirror", VALUEFUNC(_wrap_FXRGBIcon_mirror), -1);
+  rb_define_method(SwigClassFXRGBIcon.klass, "rotate", VALUEFUNC(_wrap_FXRGBIcon_rotate), -1);
+  rb_define_method(SwigClassFXRGBIcon.klass, "crop", VALUEFUNC(_wrap_FXRGBIcon_crop), -1);
+  rb_define_method(SwigClassFXRGBIcon.klass, "fill", VALUEFUNC(_wrap_FXRGBIcon_fill), -1);
+  rb_define_method(SwigClassFXRGBIcon.klass, "fade", VALUEFUNC(_wrap_FXRGBIcon_fade), -1);
+  rb_define_method(SwigClassFXRGBIcon.klass, "xshear", VALUEFUNC(_wrap_FXRGBIcon_xshear), -1);
+  rb_define_method(SwigClassFXRGBIcon.klass, "yshear", VALUEFUNC(_wrap_FXRGBIcon_yshear), -1);
+  rb_define_method(SwigClassFXRGBIcon.klass, "hgradient", VALUEFUNC(_wrap_FXRGBIcon_hgradient), -1);
+  rb_define_method(SwigClassFXRGBIcon.klass, "vgradient", VALUEFUNC(_wrap_FXRGBIcon_vgradient), -1);
+  rb_define_method(SwigClassFXRGBIcon.klass, "gradient", VALUEFUNC(_wrap_FXRGBIcon_gradient), -1);
+  rb_define_method(SwigClassFXRGBIcon.klass, "blend", VALUEFUNC(_wrap_FXRGBIcon_blend), -1);
+  rb_define_method(SwigClassFXRGBIcon.klass, "savePixels", VALUEFUNC(_wrap_FXRGBIcon_savePixels), -1);
+  rb_define_method(SwigClassFXRGBIcon.klass, "loadPixels", VALUEFUNC(_wrap_FXRGBIcon_loadPixels), -1);
+  SwigClassFXRGBIcon.mark = (void (*)(void *)) FXRbRGBIcon::markfunc;
+  SwigClassFXRGBIcon.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXRGBIcon.trackObjects = 0;
+  rb_define_module_function(mFox, "fxloadRGB", VALUEFUNC(_wrap_fxloadRGB), -1);
+  rb_define_module_function(mFox, "fxsaveRGB", VALUEFUNC(_wrap_fxsaveRGB), -1);
+  rb_define_module_function(mFox, "fxcheckRGB", VALUEFUNC(_wrap_fxcheckRGB), -1);
+  
+  SwigClassFXTGAIcon.klass = rb_define_class_under(mFox, "FXTGAIcon", ((swig_class *) SWIGTYPE_p_FXIcon->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXTGAIcon, (void *) &SwigClassFXTGAIcon);
+  rb_define_alloc_func(SwigClassFXTGAIcon.klass, _wrap_FXTGAIcon_allocate);
+  rb_define_method(SwigClassFXTGAIcon.klass, "initialize", VALUEFUNC(_wrap_new_FXTGAIcon), -1);
+  rb_define_singleton_method(SwigClassFXTGAIcon.klass, "fileExt", VALUEFUNC(_wrap_FXTGAIcon_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXTGAIcon.klass, "mimeType", VALUEFUNC(_wrap_FXTGAIcon_mimeType), -1);
+  rb_define_method(SwigClassFXTGAIcon.klass, "save", VALUEFUNC(_wrap_FXTGAIcon_save), -1);
+  rb_define_method(SwigClassFXTGAIcon.klass, "load", VALUEFUNC(_wrap_FXTGAIcon_load), -1);
+  rb_define_method(SwigClassFXTGAIcon.klass, "create", VALUEFUNC(_wrap_FXTGAIcon_create), -1);
+  rb_define_method(SwigClassFXTGAIcon.klass, "detach", VALUEFUNC(_wrap_FXTGAIcon_detach), -1);
+  rb_define_method(SwigClassFXTGAIcon.klass, "destroy", VALUEFUNC(_wrap_FXTGAIcon_destroy), -1);
+  rb_define_method(SwigClassFXTGAIcon.klass, "resize", VALUEFUNC(_wrap_FXTGAIcon_resize), -1);
+  rb_define_method(SwigClassFXTGAIcon.klass, "restore", VALUEFUNC(_wrap_FXTGAIcon_restore), -1);
+  rb_define_method(SwigClassFXTGAIcon.klass, "render", VALUEFUNC(_wrap_FXTGAIcon_render), -1);
+  rb_define_method(SwigClassFXTGAIcon.klass, "release", VALUEFUNC(_wrap_FXTGAIcon_release), -1);
+  rb_define_method(SwigClassFXTGAIcon.klass, "scale", VALUEFUNC(_wrap_FXTGAIcon_scale), -1);
+  rb_define_method(SwigClassFXTGAIcon.klass, "mirror", VALUEFUNC(_wrap_FXTGAIcon_mirror), -1);
+  rb_define_method(SwigClassFXTGAIcon.klass, "rotate", VALUEFUNC(_wrap_FXTGAIcon_rotate), -1);
+  rb_define_method(SwigClassFXTGAIcon.klass, "crop", VALUEFUNC(_wrap_FXTGAIcon_crop), -1);
+  rb_define_method(SwigClassFXTGAIcon.klass, "fill", VALUEFUNC(_wrap_FXTGAIcon_fill), -1);
+  rb_define_method(SwigClassFXTGAIcon.klass, "fade", VALUEFUNC(_wrap_FXTGAIcon_fade), -1);
+  rb_define_method(SwigClassFXTGAIcon.klass, "xshear", VALUEFUNC(_wrap_FXTGAIcon_xshear), -1);
+  rb_define_method(SwigClassFXTGAIcon.klass, "yshear", VALUEFUNC(_wrap_FXTGAIcon_yshear), -1);
+  rb_define_method(SwigClassFXTGAIcon.klass, "hgradient", VALUEFUNC(_wrap_FXTGAIcon_hgradient), -1);
+  rb_define_method(SwigClassFXTGAIcon.klass, "vgradient", VALUEFUNC(_wrap_FXTGAIcon_vgradient), -1);
+  rb_define_method(SwigClassFXTGAIcon.klass, "gradient", VALUEFUNC(_wrap_FXTGAIcon_gradient), -1);
+  rb_define_method(SwigClassFXTGAIcon.klass, "blend", VALUEFUNC(_wrap_FXTGAIcon_blend), -1);
+  rb_define_method(SwigClassFXTGAIcon.klass, "savePixels", VALUEFUNC(_wrap_FXTGAIcon_savePixels), -1);
+  rb_define_method(SwigClassFXTGAIcon.klass, "loadPixels", VALUEFUNC(_wrap_FXTGAIcon_loadPixels), -1);
+  SwigClassFXTGAIcon.mark = (void (*)(void *)) FXRbTGAIcon::markfunc;
+  SwigClassFXTGAIcon.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXTGAIcon.trackObjects = 0;
+  rb_define_module_function(mFox, "fxloadTGA", VALUEFUNC(_wrap_fxloadTGA), -1);
+  rb_define_module_function(mFox, "fxsaveTGA", VALUEFUNC(_wrap_fxsaveTGA), -1);
+  rb_define_module_function(mFox, "fxcheckTGA", VALUEFUNC(_wrap_fxcheckTGA), -1);
+  
+  SwigClassFXTIFIcon.klass = rb_define_class_under(mFox, "FXTIFIcon", ((swig_class *) SWIGTYPE_p_FXIcon->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXTIFIcon, (void *) &SwigClassFXTIFIcon);
+  rb_define_alloc_func(SwigClassFXTIFIcon.klass, _wrap_FXTIFIcon_allocate);
+  rb_define_method(SwigClassFXTIFIcon.klass, "initialize", VALUEFUNC(_wrap_new_FXTIFIcon), -1);
+  rb_define_singleton_method(SwigClassFXTIFIcon.klass, "fileExt", VALUEFUNC(_wrap_FXTIFIcon_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXTIFIcon.klass, "mimeType", VALUEFUNC(_wrap_FXTIFIcon_mimeType), -1);
+  rb_define_singleton_method(SwigClassFXTIFIcon.klass, "supported_Sq_", VALUEFUNC(_wrap_FXTIFIcon_supported_Sq_), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "setCodec", VALUEFUNC(_wrap_FXTIFIcon_setCodec), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "getCodec", VALUEFUNC(_wrap_FXTIFIcon_getCodec), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "save", VALUEFUNC(_wrap_FXTIFIcon_save), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "load", VALUEFUNC(_wrap_FXTIFIcon_load), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "create", VALUEFUNC(_wrap_FXTIFIcon_create), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "detach", VALUEFUNC(_wrap_FXTIFIcon_detach), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "destroy", VALUEFUNC(_wrap_FXTIFIcon_destroy), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "resize", VALUEFUNC(_wrap_FXTIFIcon_resize), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "restore", VALUEFUNC(_wrap_FXTIFIcon_restore), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "render", VALUEFUNC(_wrap_FXTIFIcon_render), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "release", VALUEFUNC(_wrap_FXTIFIcon_release), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "scale", VALUEFUNC(_wrap_FXTIFIcon_scale), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "mirror", VALUEFUNC(_wrap_FXTIFIcon_mirror), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "rotate", VALUEFUNC(_wrap_FXTIFIcon_rotate), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "crop", VALUEFUNC(_wrap_FXTIFIcon_crop), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "fill", VALUEFUNC(_wrap_FXTIFIcon_fill), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "fade", VALUEFUNC(_wrap_FXTIFIcon_fade), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "xshear", VALUEFUNC(_wrap_FXTIFIcon_xshear), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "yshear", VALUEFUNC(_wrap_FXTIFIcon_yshear), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "hgradient", VALUEFUNC(_wrap_FXTIFIcon_hgradient), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "vgradient", VALUEFUNC(_wrap_FXTIFIcon_vgradient), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "gradient", VALUEFUNC(_wrap_FXTIFIcon_gradient), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "blend", VALUEFUNC(_wrap_FXTIFIcon_blend), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "savePixels", VALUEFUNC(_wrap_FXTIFIcon_savePixels), -1);
+  rb_define_method(SwigClassFXTIFIcon.klass, "loadPixels", VALUEFUNC(_wrap_FXTIFIcon_loadPixels), -1);
+  SwigClassFXTIFIcon.mark = (void (*)(void *)) FXRbTIFIcon::markfunc;
+  SwigClassFXTIFIcon.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXTIFIcon.trackObjects = 0;
+  rb_define_module_function(mFox, "fxcheckTIF", VALUEFUNC(_wrap_fxcheckTIF), -1);
+  
+  SwigClassFXXBMIcon.klass = rb_define_class_under(mFox, "FXXBMIcon", ((swig_class *) SWIGTYPE_p_FXIcon->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXXBMIcon, (void *) &SwigClassFXXBMIcon);
+  rb_define_alloc_func(SwigClassFXXBMIcon.klass, _wrap_FXXBMIcon_allocate);
+  rb_define_method(SwigClassFXXBMIcon.klass, "initialize", VALUEFUNC(_wrap_new_FXXBMIcon), -1);
+  rb_define_singleton_method(SwigClassFXXBMIcon.klass, "fileExt", VALUEFUNC(_wrap_FXXBMIcon_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXXBMIcon.klass, "mimeType", VALUEFUNC(_wrap_FXXBMIcon_mimeType), -1);
+  rb_define_method(SwigClassFXXBMIcon.klass, "save", VALUEFUNC(_wrap_FXXBMIcon_save), -1);
+  rb_define_method(SwigClassFXXBMIcon.klass, "load", VALUEFUNC(_wrap_FXXBMIcon_load), -1);
+  rb_define_method(SwigClassFXXBMIcon.klass, "create", VALUEFUNC(_wrap_FXXBMIcon_create), -1);
+  rb_define_method(SwigClassFXXBMIcon.klass, "detach", VALUEFUNC(_wrap_FXXBMIcon_detach), -1);
+  rb_define_method(SwigClassFXXBMIcon.klass, "destroy", VALUEFUNC(_wrap_FXXBMIcon_destroy), -1);
+  rb_define_method(SwigClassFXXBMIcon.klass, "resize", VALUEFUNC(_wrap_FXXBMIcon_resize), -1);
+  rb_define_method(SwigClassFXXBMIcon.klass, "restore", VALUEFUNC(_wrap_FXXBMIcon_restore), -1);
+  rb_define_method(SwigClassFXXBMIcon.klass, "render", VALUEFUNC(_wrap_FXXBMIcon_render), -1);
+  rb_define_method(SwigClassFXXBMIcon.klass, "release", VALUEFUNC(_wrap_FXXBMIcon_release), -1);
+  rb_define_method(SwigClassFXXBMIcon.klass, "scale", VALUEFUNC(_wrap_FXXBMIcon_scale), -1);
+  rb_define_method(SwigClassFXXBMIcon.klass, "mirror", VALUEFUNC(_wrap_FXXBMIcon_mirror), -1);
+  rb_define_method(SwigClassFXXBMIcon.klass, "rotate", VALUEFUNC(_wrap_FXXBMIcon_rotate), -1);
+  rb_define_method(SwigClassFXXBMIcon.klass, "crop", VALUEFUNC(_wrap_FXXBMIcon_crop), -1);
+  rb_define_method(SwigClassFXXBMIcon.klass, "fill", VALUEFUNC(_wrap_FXXBMIcon_fill), -1);
+  rb_define_method(SwigClassFXXBMIcon.klass, "fade", VALUEFUNC(_wrap_FXXBMIcon_fade), -1);
+  rb_define_method(SwigClassFXXBMIcon.klass, "xshear", VALUEFUNC(_wrap_FXXBMIcon_xshear), -1);
+  rb_define_method(SwigClassFXXBMIcon.klass, "yshear", VALUEFUNC(_wrap_FXXBMIcon_yshear), -1);
+  rb_define_method(SwigClassFXXBMIcon.klass, "hgradient", VALUEFUNC(_wrap_FXXBMIcon_hgradient), -1);
+  rb_define_method(SwigClassFXXBMIcon.klass, "vgradient", VALUEFUNC(_wrap_FXXBMIcon_vgradient), -1);
+  rb_define_method(SwigClassFXXBMIcon.klass, "gradient", VALUEFUNC(_wrap_FXXBMIcon_gradient), -1);
+  rb_define_method(SwigClassFXXBMIcon.klass, "blend", VALUEFUNC(_wrap_FXXBMIcon_blend), -1);
+  rb_define_method(SwigClassFXXBMIcon.klass, "savePixels", VALUEFUNC(_wrap_FXXBMIcon_savePixels), -1);
+  rb_define_method(SwigClassFXXBMIcon.klass, "loadPixels", VALUEFUNC(_wrap_FXXBMIcon_loadPixels), -1);
+  SwigClassFXXBMIcon.mark = 0;
+  SwigClassFXXBMIcon.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXXBMIcon.trackObjects = 0;
+  
+  SwigClassFXXPMIcon.klass = rb_define_class_under(mFox, "FXXPMIcon", ((swig_class *) SWIGTYPE_p_FXIcon->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXXPMIcon, (void *) &SwigClassFXXPMIcon);
+  rb_define_alloc_func(SwigClassFXXPMIcon.klass, _wrap_FXXPMIcon_allocate);
+  rb_define_method(SwigClassFXXPMIcon.klass, "initialize", VALUEFUNC(_wrap_new_FXXPMIcon), -1);
+  rb_define_singleton_method(SwigClassFXXPMIcon.klass, "fileExt", VALUEFUNC(_wrap_FXXPMIcon_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXXPMIcon.klass, "mimeType", VALUEFUNC(_wrap_FXXPMIcon_mimeType), -1);
+  rb_define_method(SwigClassFXXPMIcon.klass, "save", VALUEFUNC(_wrap_FXXPMIcon_save), -1);
+  rb_define_method(SwigClassFXXPMIcon.klass, "load", VALUEFUNC(_wrap_FXXPMIcon_load), -1);
+  rb_define_method(SwigClassFXXPMIcon.klass, "create", VALUEFUNC(_wrap_FXXPMIcon_create), -1);
+  rb_define_method(SwigClassFXXPMIcon.klass, "detach", VALUEFUNC(_wrap_FXXPMIcon_detach), -1);
+  rb_define_method(SwigClassFXXPMIcon.klass, "destroy", VALUEFUNC(_wrap_FXXPMIcon_destroy), -1);
+  rb_define_method(SwigClassFXXPMIcon.klass, "resize", VALUEFUNC(_wrap_FXXPMIcon_resize), -1);
+  rb_define_method(SwigClassFXXPMIcon.klass, "restore", VALUEFUNC(_wrap_FXXPMIcon_restore), -1);
+  rb_define_method(SwigClassFXXPMIcon.klass, "render", VALUEFUNC(_wrap_FXXPMIcon_render), -1);
+  rb_define_method(SwigClassFXXPMIcon.klass, "release", VALUEFUNC(_wrap_FXXPMIcon_release), -1);
+  rb_define_method(SwigClassFXXPMIcon.klass, "scale", VALUEFUNC(_wrap_FXXPMIcon_scale), -1);
+  rb_define_method(SwigClassFXXPMIcon.klass, "mirror", VALUEFUNC(_wrap_FXXPMIcon_mirror), -1);
+  rb_define_method(SwigClassFXXPMIcon.klass, "rotate", VALUEFUNC(_wrap_FXXPMIcon_rotate), -1);
+  rb_define_method(SwigClassFXXPMIcon.klass, "crop", VALUEFUNC(_wrap_FXXPMIcon_crop), -1);
+  rb_define_method(SwigClassFXXPMIcon.klass, "fill", VALUEFUNC(_wrap_FXXPMIcon_fill), -1);
+  rb_define_method(SwigClassFXXPMIcon.klass, "fade", VALUEFUNC(_wrap_FXXPMIcon_fade), -1);
+  rb_define_method(SwigClassFXXPMIcon.klass, "xshear", VALUEFUNC(_wrap_FXXPMIcon_xshear), -1);
+  rb_define_method(SwigClassFXXPMIcon.klass, "yshear", VALUEFUNC(_wrap_FXXPMIcon_yshear), -1);
+  rb_define_method(SwigClassFXXPMIcon.klass, "hgradient", VALUEFUNC(_wrap_FXXPMIcon_hgradient), -1);
+  rb_define_method(SwigClassFXXPMIcon.klass, "vgradient", VALUEFUNC(_wrap_FXXPMIcon_vgradient), -1);
+  rb_define_method(SwigClassFXXPMIcon.klass, "gradient", VALUEFUNC(_wrap_FXXPMIcon_gradient), -1);
+  rb_define_method(SwigClassFXXPMIcon.klass, "blend", VALUEFUNC(_wrap_FXXPMIcon_blend), -1);
+  rb_define_method(SwigClassFXXPMIcon.klass, "savePixels", VALUEFUNC(_wrap_FXXPMIcon_savePixels), -1);
+  rb_define_method(SwigClassFXXPMIcon.klass, "loadPixels", VALUEFUNC(_wrap_FXXPMIcon_loadPixels), -1);
+  SwigClassFXXPMIcon.mark = (void (*)(void *)) FXRbXPMIcon::markfunc;
+  SwigClassFXXPMIcon.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXXPMIcon.trackObjects = 0;
+  rb_define_module_function(mFox, "fxloadXPM", VALUEFUNC(_wrap_fxloadXPM), -1);
+  rb_define_module_function(mFox, "fxsaveXPM", VALUEFUNC(_wrap_fxsaveXPM), -1);
+  rb_define_module_function(mFox, "fxcheckXPM", VALUEFUNC(_wrap_fxcheckXPM), -1);
+}
+
diff --git a/ext/fox16_c/image_wrap.cpp b/ext/fox16_c/image_wrap.cpp
new file mode 100644
index 00000000..262e30d2
--- /dev/null
+++ b/ext/fox16_c/image_wrap.cpp
@@ -0,0 +1,15713 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 3.0.12
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+
+#ifndef SWIGRUBY
+#define SWIGRUBY
+#endif
+
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
+};
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic C API SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "4"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/*  Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN           0x1
+
+
+/*
+   Flags/methods for returning states.
+
+   The SWIG conversion methods, as ConvertPtr, return an integer
+   that tells if the conversion was successful or not. And if not,
+   an error code can be returned (see swigerrors.swg for the codes).
+
+   Use the following macros/flags to set or process the returning
+   states.
+
+   In old versions of SWIG, code such as the following was usually written:
+
+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+       // success code
+     } else {
+       //fail code
+     }
+
+   Now you can be more explicit:
+
+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+    } else {
+      // fail code
+    }
+
+   which is the same really, but now you can also do
+
+    Type *ptr;
+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+      if (SWIG_IsNewObj(res) {
+        ...
+	delete *ptr;
+      } else {
+        ...
+      }
+    } else {
+      // fail code
+    }
+
+   I.e., now SWIG_ConvertPtr can return new objects and you can
+   identify the case and take care of the deallocation. Of course that
+   also requires SWIG_ConvertPtr to return new result values, such as
+
+      int SWIG_ConvertPtr(obj, ptr,...) {
+        if (<obj is ok>) {
+          if (<need new object>) {
+            *ptr = <ptr to new allocated object>;
+            return SWIG_NEWOBJ;
+          } else {
+            *ptr = <ptr to old object>;
+            return SWIG_OLDOBJ;
+          }
+        } else {
+          return SWIG_BADOBJ;
+        }
+      }
+
+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+   SWIG errors code.
+
+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+   allows to return the 'cast rank', for example, if you have this
+
+       int food(double)
+       int fooi(int);
+
+   and you call
+
+      food(1)   // cast rank '1'  (1 -> 1.0)
+      fooi(1)   // cast rank '0'
+
+   just use the SWIG_AddCast()/SWIG_CheckState()
+*/
+
+#define SWIG_OK                    (0)
+#define SWIG_ERROR                 (-1)
+#define SWIG_IsOK(r)               (r >= 0)
+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT         (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ                (SWIG_ERROR)
+#define SWIG_OLDOBJ                (SWIG_OK)
+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+#  ifndef SWIG_TypeRank
+#    define SWIG_TypeRank             unsigned long
+#  endif
+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
+#    define SWIG_MAXCASTRANK          (2)
+#  endif
+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+#  define SWIG_AddCast(r) (r)
+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *, int *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store information on one type */
+typedef struct swig_type_info {
+  const char             *name;			/* mangled name of this type */
+  const char             *str;			/* human readable name of this type */
+  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
+  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
+  void                   *clientdata;		/* language specific type data */
+  int                    owndata;		/* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
+  swig_converter_func     converter;		/* function to cast the void pointers */
+  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
+  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
+  size_t                 size;		        /* Number of types in this module */
+  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
+  swig_type_info         **type_initial;	/* Array of initially generated type structures */
+  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
+  void                    *clientdata;		/* Language specific module data */
+} swig_module_info;
+
+/*
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+  }
+  return (int)((l1 - f1) - (l2 - f2));
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCmp(const char *nb, const char *tb) {
+  int equiv = 1;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (equiv != 0 && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
+}
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
+}
+
+/*
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+  swig_type_info *lastty = ty;
+  if (!ty || !ty->dcast) return ty;
+  while (ty && (ty->dcast)) {
+    ty = (*ty->dcast)(ptr);
+    if (ty) lastty = ty;
+  }
+  return lastty;
+}
+
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+  return ty->name;
+}
+
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (!type) return NULL;
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
+  }
+  else
+    return type->name;
+}
+
+/*
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+  swig_cast_info *cast = ti->cast;
+  /* if (ti->clientdata == clientdata) return; */
+  ti->clientdata = clientdata;
+
+  while (cast) {
+    if (!cast->converter) {
+      swig_type_info *tc = cast->type;
+      if (!tc->clientdata) {
+	SWIG_TypeClientData(tc, clientdata);
+      }
+    }
+    cast = cast->next;
+  }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientData(ti, clientdata);
+  ti->owndata = 1;
+}
+
+/*
+  Search for a swig_type_info structure only by mangled name
+  Search is a O(log #types)
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+                            swig_module_info *end,
+		            const char *name) {
+  swig_module_info *iter = start;
+  do {
+    if (iter->size) {
+      size_t l = 0;
+      size_t r = iter->size - 1;
+      do {
+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
+	size_t i = (l + r) >> 1;
+	const char *iname = iter->types[i]->name;
+	if (iname) {
+	  int compare = strcmp(name, iname);
+	  if (compare == 0) {
+	    return iter->types[i];
+	  } else if (compare < 0) {
+	    if (i) {
+	      r = i - 1;
+	    } else {
+	      break;
+	    }
+	  } else if (compare > 0) {
+	    l = i + 1;
+	  }
+	} else {
+	  break; /* should never happen */
+	}
+      } while (l <= r);
+    }
+    iter = iter->next;
+  } while (iter != end);
+  return 0;
+}
+
+/*
+  Search for a swig_type_info structure for either a mangled name or a human readable name.
+  It first searches the mangled names of the types, which is a O(log #types)
+  If a type is not found it then searches the human readable names, which is O(#types).
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+                     swig_module_info *end,
+		     const char *name) {
+  /* STEP 1: Search the name field using binary search */
+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+  if (ret) {
+    return ret;
+  } else {
+    /* STEP 2: If the type hasn't been found, do a complete search
+       of the str field (the human readable name) */
+    swig_module_info *iter = start;
+    do {
+      size_t i = 0;
+      for (; i < iter->size; ++i) {
+	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+	  return iter->types[i];
+      }
+      iter = iter->next;
+    } while (iter != end);
+  }
+
+  /* neither found a match */
+  return 0;
+}
+
+/*
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+
+/*
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = (unsigned char)((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = (unsigned char)((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (unsigned char)(d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (unsigned char)(d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/*
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/*  Errors in SWIG */
+#define  SWIG_UnknownError    	   -1
+#define  SWIG_IOError        	   -2
+#define  SWIG_RuntimeError   	   -3
+#define  SWIG_IndexError     	   -4
+#define  SWIG_TypeError      	   -5
+#define  SWIG_DivisionByZero 	   -6
+#define  SWIG_OverflowError  	   -7
+#define  SWIG_SyntaxError    	   -8
+#define  SWIG_ValueError     	   -9
+#define  SWIG_SystemError    	   -10
+#define  SWIG_AttributeError 	   -11
+#define  SWIG_MemoryError    	   -12
+#define  SWIG_NullReferenceError   -13
+
+
+
+      #include <ruby.h>
+
+      #if defined(RB_METHOD_DEFINITION_DECL)
+      # define RUBY_VALUE_METHOD_FUNC(func) (func)
+      # define RUBY_INT_METHOD_FUNC(func) (func)
+      # define RUBY_VOID_METHOD_FUNC(func) (func)
+      # define RUBY_VOIDP_METHOD_FUNC(func) (func)
+      #else
+      # define RUBY_VALUE_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
+      # define RUBY_INT_METHOD_FUNC(func) ((int (*)(ANYARGS))(func))
+      # define RUBY_VOID_METHOD_FUNC(func) ((void (*)(ANYARGS))(func))
+      # define RUBY_VOIDP_METHOD_FUNC(func) ((void *(*)(ANYARGS))(func))
+      #endif
+
+
+/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
+ * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
+ * issue for now by disabling this.
+ * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
+ */
+#ifdef rb_intern
+# undef rb_intern
+#endif
+
+/* Remove global macros defined in Ruby's win32.h */
+#ifdef write
+# undef write
+#endif
+#ifdef read
+# undef read
+#endif
+#ifdef bind
+# undef bind
+#endif
+#ifdef close
+# undef close
+#endif
+#ifdef connect
+# undef connect
+#endif
+
+
+/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
+#ifndef NUM2LL
+#define NUM2LL(x) NUM2LONG((x))
+#endif
+#ifndef LL2NUM
+#define LL2NUM(x) INT2NUM((long) (x))
+#endif
+#ifndef ULL2NUM
+#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
+#endif
+
+/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
+#ifndef NUM2ULL
+#ifdef HAVE_LONG_LONG
+#define NUM2ULL(x) rb_num2ull((x))
+#else
+#define NUM2ULL(x) NUM2ULONG(x)
+#endif
+#endif
+
+/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
+/* Define these for older versions so we can just write code the new way */
+#ifndef RSTRING_LEN
+# define RSTRING_LEN(x) RSTRING(x)->len
+#endif
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(x) RSTRING(x)->ptr
+#endif
+#ifndef RSTRING_END
+# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
+#endif
+#ifndef RARRAY_LEN
+# define RARRAY_LEN(x) RARRAY(x)->len
+#endif
+#ifndef RARRAY_PTR
+# define RARRAY_PTR(x) RARRAY(x)->ptr
+#endif
+#ifndef RFLOAT_VALUE
+# define RFLOAT_VALUE(x) RFLOAT(x)->value
+#endif
+#ifndef DOUBLE2NUM
+# define DOUBLE2NUM(x) rb_float_new(x)
+#endif
+#ifndef RHASH_TBL
+# define RHASH_TBL(x) (RHASH(x)->tbl)
+#endif
+#ifndef RHASH_ITER_LEV
+# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
+#endif
+#ifndef RHASH_IFNONE
+# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
+#endif
+#ifndef RHASH_SIZE
+# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
+#endif
+#ifndef RHASH_EMPTY_P
+# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
+#endif
+#ifndef RSTRUCT_LEN
+# define RSTRUCT_LEN(x) RSTRUCT(x)->len
+#endif
+#ifndef RSTRUCT_PTR
+# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
+#endif
+
+
+
+/*
+ * Need to be very careful about how these macros are defined, especially
+ * when compiling C++ code or C code with an ANSI C compiler.
+ *
+ * VALUEFUNC(f) is a macro used to typecast a C function that implements
+ * a Ruby method so that it can be passed as an argument to API functions
+ * like rb_define_method() and rb_define_singleton_method().
+ *
+ * VOIDFUNC(f) is a macro used to typecast a C function that implements
+ * either the "mark" or "free" stuff for a Ruby Data object, so that it
+ * can be passed as an argument to API functions like Data_Wrap_Struct()
+ * and Data_Make_Struct().
+ */
+ 
+#ifdef __cplusplus
+#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
+#    define PROTECTFUNC(f) ((VALUE (*)()) f)
+#    define VALUEFUNC(f) ((VALUE (*)()) f)
+#    define VOIDFUNC(f)  ((void (*)()) f)
+#  else
+#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
+#      define PROTECTFUNC(f) ((VALUE (*)()) f)
+#      define VALUEFUNC(f) ((VALUE (*)()) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    else /* These definitions should work for Ruby 1.7+ */
+#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
+#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    endif
+#  endif
+#else
+#  define VALUEFUNC(f) (f)
+#  define VOIDFUNC(f) (f)
+#endif
+
+/* Don't use for expressions have side effect */
+#ifndef RB_STRING_VALUE
+#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
+#endif
+#ifndef StringValue
+#define StringValue(s) RB_STRING_VALUE(s)
+#endif
+#ifndef StringValuePtr
+#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
+#endif
+#ifndef StringValueLen
+#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
+#endif
+#ifndef SafeStringValue
+#define SafeStringValue(v) do {\
+    StringValue(v);\
+    rb_check_safe_str(v);\
+} while (0)
+#endif
+
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
+#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
+#endif
+
+static VALUE _mSWIG = Qnil;
+
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+
+/* Define some additional error types */
+#define SWIG_ObjectPreviouslyDeletedError  -100
+
+
+/* Define custom exceptions for errors that do not map to existing Ruby
+   exceptions.  Note this only works for C++ since a global cannot be
+   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/
+
+SWIGINTERN VALUE 
+getNullReferenceError(void) {
+  static int init = 0;
+  static VALUE rb_eNullReferenceError ;
+  if (!init) {
+    init = 1;
+    rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
+  }
+  return rb_eNullReferenceError;
+} 
+
+SWIGINTERN VALUE 
+getObjectPreviouslyDeletedError(void) {
+  static int init = 0;
+  static VALUE rb_eObjectPreviouslyDeleted ;
+  if (!init) {
+    init = 1;
+    rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
+  }
+  return rb_eObjectPreviouslyDeleted;
+} 
+
+
+SWIGINTERN VALUE
+SWIG_Ruby_ErrorType(int SWIG_code) {
+  VALUE type;
+  switch (SWIG_code) {
+  case SWIG_MemoryError:
+    type = rb_eNoMemError;
+    break;
+  case SWIG_IOError:
+    type = rb_eIOError;
+    break;
+  case SWIG_RuntimeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_IndexError:
+    type = rb_eIndexError;
+    break;
+  case SWIG_TypeError:
+    type = rb_eTypeError;
+    break;
+  case SWIG_DivisionByZero:
+    type = rb_eZeroDivError;
+    break;
+  case SWIG_OverflowError:
+    type = rb_eRangeError;
+    break;
+  case SWIG_SyntaxError:
+    type = rb_eSyntaxError;
+    break;
+  case SWIG_ValueError:
+    type = rb_eArgError;
+    break;
+  case SWIG_SystemError:
+    type = rb_eFatal;
+    break;
+  case SWIG_AttributeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_NullReferenceError:
+    type = getNullReferenceError();
+    break;
+  case SWIG_ObjectPreviouslyDeletedError:
+    type = getObjectPreviouslyDeletedError();
+    break;
+  case SWIG_UnknownError:
+    type = rb_eRuntimeError;
+    break;
+  default:
+    type = rb_eRuntimeError;
+  }
+  return type;
+}
+
+
+/* This function is called when a user inputs a wrong argument to
+   a method.
+ */
+SWIGINTERN 
+const char* Ruby_Format_TypeError( const char* msg,
+				   const char* type, 
+				   const char* name, 
+				   const int argn,
+				   VALUE input )
+{
+  char buf[128];
+  VALUE str;
+  VALUE asStr;
+  if ( msg && *msg )
+    {
+      str = rb_str_new2(msg);
+    }
+  else
+    {
+      str = rb_str_new(NULL, 0);
+    }
+
+  str = rb_str_cat2( str, "Expected argument " );
+  sprintf( buf, "%d of type ", argn-1 );
+  str = rb_str_cat2( str, buf );
+  str = rb_str_cat2( str, type );
+  str = rb_str_cat2( str, ", but got " );
+  str = rb_str_cat2( str, rb_obj_classname(input) );
+  str = rb_str_cat2( str, " " );
+  asStr = rb_inspect(input);
+  if ( RSTRING_LEN(asStr) > 30 )
+    {
+      str = rb_str_cat( str, StringValuePtr(asStr), 30 );
+      str = rb_str_cat2( str, "..." );
+    }
+  else
+    {
+      str = rb_str_append( str, asStr );
+    }
+
+  if ( name )
+    {
+      str = rb_str_cat2( str, "\n\tin SWIG method '" );
+      str = rb_str_cat2( str, name );
+      str = rb_str_cat2( str, "'" );
+    }
+
+  return StringValuePtr( str );
+}
+
+/* This function is called when an overloaded method fails */
+SWIGINTERN 
+void Ruby_Format_OverloadedError(
+				 const int argc,
+				 const int maxargs,
+				 const char* method, 
+				 const char* prototypes 
+				 )
+{
+  const char* msg = "Wrong # of arguments";
+  if ( argc <= maxargs ) msg = "Wrong arguments";
+  rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
+	   "Possible C/C++ prototypes are:\n%s",
+	   msg, method, prototypes);
+}
+
+/* -----------------------------------------------------------------------------
+ * rubytracking.swg
+ *
+ * This file contains support for tracking mappings from 
+ * Ruby objects to C++ objects.  This functionality is needed
+ * to implement mark functions for Ruby's mark and sweep
+ * garbage collector.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(ST_DATA_T_DEFINED)
+/* Needs to be explicitly included for Ruby 1.8 and earlier */
+#include <st.h>
+#endif
+
+/* Ruby 1.8 actually assumes the first case. */
+#if SIZEOF_VOIDP == SIZEOF_LONG
+#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
+#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
+#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
+#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
+#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
+#else
+#  error sizeof(void*) is not the same as long or long long
+#endif
+
+/* Global hash table to store Trackings from C/C++
+   structs to Ruby Objects. 
+*/
+static st_table* swig_ruby_trackings = NULL;
+
+static VALUE swig_ruby_trackings_count(ID id, VALUE *var) {
+  return SWIG2NUM(swig_ruby_trackings->num_entries);
+}
+
+
+/* Setup a hash table to store Trackings */
+SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
+  /* Create a hash table to store Trackings from C++
+     objects to Ruby objects. */
+
+  /* Try to see if some other .so has already created a 
+     tracking hash table, which we keep hidden in an instance var
+     in the SWIG module.
+     This is done to allow multiple DSOs to share the same
+     tracking table.
+  */
+  VALUE trackings_value = Qnil;
+  /* change the variable name so that we can mix modules
+     compiled with older SWIG's - this used to be called "@__trackings__" */
+  ID trackings_id = rb_intern( "@__safetrackings__" );
+  VALUE verbose = rb_gv_get("VERBOSE");
+  rb_gv_set("VERBOSE", Qfalse);
+  trackings_value = rb_ivar_get( _mSWIG, trackings_id );
+  rb_gv_set("VERBOSE", verbose);
+
+  /* The trick here is that we have to store the hash table
+  pointer in a Ruby variable. We do not want Ruby's GC to
+  treat this pointer as a Ruby object, so we convert it to
+  a Ruby numeric value. */
+  if (trackings_value == Qnil) {
+    /* No, it hasn't.  Create one ourselves */
+    swig_ruby_trackings = st_init_numtable();
+    rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
+  } else {
+    swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
+  }
+
+        rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", RUBY_VALUE_METHOD_FUNC(swig_ruby_trackings_count), RUBY_VOID_METHOD_FUNC((rb_gvar_setter_t*)NULL))
+;
+}
+
+/* Add a Tracking from a C/C++ struct to a Ruby object */
+SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
+  /* Store the mapping to the global hash table. */
+  st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
+}
+
+/* Get the Ruby object that owns the specified C/C++ struct */
+SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
+  /* Now lookup the value stored in the global hash table */
+  VALUE value;
+
+  if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
+    return value;
+  } else {
+    return Qnil;
+  }
+}
+
+/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
+   is very important to remove objects once they are destroyed
+   since the same memory address may be reused later to create
+   a new object. */
+SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
+  /* Delete the object from the hash table */
+  st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
+}
+
+/* This is a helper method that unlinks a Ruby object from its
+   underlying C++ object.  This is needed if the lifetime of the
+   Ruby object is longer than the C++ object */
+SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
+  VALUE object = SWIG_RubyInstanceFor(ptr);
+
+  if (object != Qnil) {
+    if (TYPE(object) != T_DATA)
+      abort();
+    DATA_PTR(object) = 0;
+  }
+}
+
+/* This is a helper method that iterates over all the trackings
+   passing the C++ object pointer and its related Ruby object
+   to the passed callback function. */
+
+/* Proxy method to abstract the internal trackings datatype */
+      static int swig_ruby_internal_iterate_callback(st_data_t ptr, st_data_t obj, st_data_t meth) {
+        ((void(*)(void*, VALUE))meth)((void*)ptr, (VALUE)obj);
+
+  return ST_CONTINUE;
+}
+
+SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
+  st_foreach(swig_ruby_trackings, RUBY_INT_METHOD_FUNC(swig_ruby_internal_iterate_callback), (st_data_t)meth);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Ruby API portion that goes into the runtime
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGINTERN VALUE
+SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
+  if (NIL_P(target)) {
+    target = o;
+  } else {
+    if (TYPE(target) != T_ARRAY) {
+      VALUE o2 = target;
+      target = rb_ary_new();
+      rb_ary_push(target, o2);
+    }
+    rb_ary_push(target, o);
+  }
+  return target;
+}
+
+/* For ruby1.8.4 and earlier. */
+#ifndef RUBY_INIT_STACK
+   RUBY_EXTERN void Init_stack(VALUE* addr);
+#  define RUBY_INIT_STACK \
+   VALUE variable_in_this_stack_frame; \
+   Init_stack(&variable_in_this_stack_frame);
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* -----------------------------------------------------------------------------
+ * rubyrun.swg
+ *
+ * This file contains the runtime support for Ruby modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
+#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
+#define swig_owntype                                    swig_ruby_owntype
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) 		SWIG_Ruby_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
+#define SWIG_Error(code, msg)            		rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
+#define SWIG_fail                        		goto fail				 
+
+
+/* Ruby-specific SWIG API */
+
+#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
+#define SWIG_define_class(ty)                        	SWIG_Ruby_define_class(ty)
+#define SWIG_NewClassInstance(value, ty)             	SWIG_Ruby_NewClassInstance(value, ty)
+#define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
+#define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  
+
+#include "assert.h"
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  VALUE klass;
+  VALUE mImpl;
+  void  (*mark)(void *);
+  void  (*destroy)(void *);
+  int trackObjects;
+} swig_class;
+
+
+/* Global pointer used to keep some internal SWIG stuff */
+static VALUE _cSWIG_Pointer = Qnil;
+static VALUE swig_runtime_data_type_pointer = Qnil;
+
+/* Global IDs used to keep some internal SWIG stuff */
+static ID swig_arity_id = 0;
+static ID swig_call_id  = 0;
+
+/*
+  If your swig extension is to be run within an embedded ruby and has
+  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
+  This will reset ruby's stack frame on each entry point from the main 
+  program the first time a virtual director function is invoked (in a 
+  non-recursive way).
+  If this is not done, you run the risk of Ruby trashing the stack.
+*/
+
+#ifdef RUBY_EMBEDDED
+
+#  define SWIG_INIT_STACK                            \
+      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
+      ++swig_virtual_calls;
+#  define SWIG_RELEASE_STACK --swig_virtual_calls;
+#  define Ruby_DirectorTypeMismatchException(x) \
+          rb_raise( rb_eTypeError, "%s", x ); return c_result;
+
+      static unsigned int swig_virtual_calls = 0;
+
+#else  /* normal non-embedded extension */
+
+#  define SWIG_INIT_STACK
+#  define SWIG_RELEASE_STACK
+#  define Ruby_DirectorTypeMismatchException(x) \
+          throw Swig::DirectorTypeMismatchException( x );
+
+#endif  /* RUBY_EMBEDDED */
+
+
+SWIGRUNTIME VALUE 
+getExceptionClass(void) {
+  static int init = 0;
+  static VALUE rubyExceptionClass ;
+  if (!init) {
+    init = 1;
+    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
+  }
+  return rubyExceptionClass;
+} 
+
+/* This code checks to see if the Ruby object being raised as part
+   of an exception inherits from the Ruby class Exception.  If so,
+   the object is simply returned.  If not, then a new Ruby exception
+   object is created and that will be returned to Ruby.*/
+SWIGRUNTIME VALUE
+SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
+  VALUE exceptionClass = getExceptionClass();
+  if (rb_obj_is_kind_of(obj, exceptionClass)) {
+    return obj;
+  }  else {
+    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
+  }
+}
+
+/* Initialize Ruby runtime support */
+SWIGRUNTIME void
+SWIG_Ruby_InitRuntime(void)
+{
+  if (_mSWIG == Qnil) {
+    _mSWIG = rb_define_module("SWIG");
+    swig_call_id  = rb_intern("call");
+    swig_arity_id = rb_intern("arity");
+  }
+}
+
+/* Define Ruby class for C type */
+SWIGRUNTIME void
+SWIG_Ruby_define_class(swig_type_info *type)
+{
+  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+  sprintf(klass_name, "TYPE%s", type->name);
+  if (NIL_P(_cSWIG_Pointer)) {
+    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
+    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
+  }
+  rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
+  free((void *) klass_name);
+}
+
+/* Create a new pointer object */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
+{
+  int own =  flags & SWIG_POINTER_OWN; 
+  int track;
+  char *klass_name;
+  swig_class *sklass;
+  VALUE klass;
+  VALUE obj;
+  
+  if (!ptr)
+    return Qnil;
+  
+  if (type->clientdata) {
+    sklass = (swig_class *) type->clientdata;
+		
+    /* Are we tracking this class and have we already returned this Ruby object? */
+    track = sklass->trackObjects;
+    if (track) {
+      obj = SWIG_RubyInstanceFor(ptr);
+      
+      /* Check the object's type and make sure it has the correct type.
+        It might not in cases where methods do things like 
+        downcast methods. */
+      if (obj != Qnil) {
+        VALUE value = rb_iv_get(obj, "@__swigtype__");
+        const char* type_name = RSTRING_PTR(value);
+				
+        if (strcmp(type->name, type_name) == 0) {
+          return obj;
+        }
+      }
+    }
+
+    /* Create a new Ruby object */
+    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
+			   ( own ? VOIDFUNC(sklass->destroy) : 
+			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
+			     ), ptr);
+
+    /* If tracking is on for this class then track this object. */
+    if (track) {
+      SWIG_RubyAddTracking(ptr, obj);
+    }
+  } else {
+    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+    sprintf(klass_name, "TYPE%s", type->name);
+    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
+    free((void *) klass_name);
+    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
+  }
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  
+  return obj;
+}
+
+/* Create a new class instance (always owned) */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
+{
+  VALUE obj;
+  swig_class *sklass = (swig_class *) type->clientdata;
+  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  return obj;
+}
+
+/* Get type mangle from class name */
+SWIGRUNTIMEINLINE char *
+SWIG_Ruby_MangleStr(VALUE obj)
+{
+  VALUE stype = rb_iv_get(obj, "@__swigtype__");
+  return StringValuePtr(stype);
+}
+
+/* Acquire a pointer value */
+typedef struct {
+  void (*datafree)(void *);
+  int own;
+} swig_ruby_owntype;
+
+SWIGRUNTIME swig_ruby_owntype
+SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
+  swig_ruby_owntype oldown = {0, 0};
+  if (obj) {
+    oldown.datafree = RDATA(obj)->dfree;
+    RDATA(obj)->dfree = own.datafree;
+  }
+  return oldown;
+}
+
+/* Convert a pointer value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
+{
+  char *c;
+  swig_cast_info *tc;
+  void *vptr = 0;
+
+  /* Grab the pointer */
+  if (NIL_P(obj)) {
+    if (ptr)
+      *ptr = 0;
+    return SWIG_OK;
+  } else {
+    if (TYPE(obj) != T_DATA) {
+      return SWIG_ERROR;
+    }
+    Data_Get_Struct(obj, void, vptr);
+  }
+  
+  if (own) {
+    own->datafree = RDATA(obj)->dfree;
+    own->own = 0;
+  }
+    
+  /* Check to see if the input object is giving up ownership
+     of the underlying C struct or C++ object.  If so then we
+     need to reset the destructor since the Ruby object no 
+     longer owns the underlying C++ object.*/ 
+  if (flags & SWIG_POINTER_DISOWN) {
+    /* Is tracking on for this class? */
+    int track = 0;
+    if (ty && ty->clientdata) {
+      swig_class *sklass = (swig_class *) ty->clientdata;
+      track = sklass->trackObjects;
+    }
+		
+    if (track) {
+      /* We are tracking objects for this class.  Thus we change the destructor
+       * to SWIG_RubyRemoveTracking.  This allows us to
+       * remove the mapping from the C++ to Ruby object
+       * when the Ruby object is garbage collected.  If we don't
+       * do this, then it is possible we will return a reference 
+       * to a Ruby object that no longer exists thereby crashing Ruby. */
+      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
+    } else {    
+      RDATA(obj)->dfree = 0;
+    }
+  }
+
+  /* Do type-checking if type info was provided */
+  if (ty) {
+    if (ty->clientdata) {
+      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
+        if (vptr == 0) {
+          /* The object has already been deleted */
+          return SWIG_ObjectPreviouslyDeletedError;
+        }
+      }
+    }
+    if ((c = SWIG_MangleStr(obj)) == NULL) {
+      return SWIG_ERROR;
+    }
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) {
+      return SWIG_ERROR;
+    } else {
+      if (ptr) {
+        if (tc->type == ty) {
+          *ptr = vptr;
+        } else {
+          int newmemory = 0;
+          *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
+          if (newmemory == SWIG_CAST_NEW_MEMORY) {
+            assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+            if (own)
+              own->own = own->own | SWIG_CAST_NEW_MEMORY;
+          }
+        }
+      }
+    }
+  } else {
+    if (ptr)
+      *ptr = vptr;
+  }
+  
+  return SWIG_OK;
+}
+
+/* Check convert */
+SWIGRUNTIMEINLINE int
+SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
+{
+  char *c = SWIG_MangleStr(obj);
+  if (!c) return 0;
+  return SWIG_TypeCheck(c,ty) != 0;
+}
+
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r, ptr, sz);
+  strcpy(r, type->name);
+  return rb_str_new2(result);
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c;
+
+  if (TYPE(obj) != T_STRING) goto type_error;
+  c = StringValuePtr(obj);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') goto type_error;
+  c++;
+  c = SWIG_UnpackData(c, ptr, sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) goto type_error;
+  }
+  return SWIG_OK;
+
+ type_error:
+  return SWIG_ERROR;
+}
+
+SWIGRUNTIME swig_module_info *
+SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
+{
+  VALUE pointer;
+  swig_module_info *ret = 0;
+  VALUE verbose = rb_gv_get("VERBOSE");
+
+ /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
+  rb_gv_set("VERBOSE", Qfalse);
+  
+  /* first check if pointer already created */
+  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  if (pointer != Qnil) {
+    Data_Get_Struct(pointer, swig_module_info, ret);
+  }
+
+  /* reinstate warnings */
+  rb_gv_set("VERBOSE", verbose);
+  return ret;
+}
+
+SWIGRUNTIME void 
+SWIG_Ruby_SetModule(swig_module_info *pointer)
+{
+  /* register a new class */
+  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
+  /* create and store the structure pointer to a global variable */
+  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
+  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
+}
+
+/* This function can be used to check whether a proc or method or similarly
+   callable function has been passed.  Usually used in a %typecheck, like:
+
+   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
+        $result = SWIG_Ruby_isCallable( $input );
+   }
+ */
+SWIGINTERN
+int SWIG_Ruby_isCallable( VALUE proc )
+{
+  if ( rb_respond_to( proc, swig_call_id ) )
+    return 1;
+  return 0;
+}
+
+/* This function can be used to check the arity (number of arguments)
+   a proc or method can take.  Usually used in a %typecheck.
+   Valid arities will be that equal to minimal or those < 0
+   which indicate a variable number of parameters at the end.
+ */
+SWIGINTERN
+int SWIG_Ruby_arity( VALUE proc, int minimal )
+{
+  if ( rb_respond_to( proc, swig_arity_id ) )
+    {
+      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
+      int arity = NUM2INT(num);
+      if ( arity < 0 && (arity+1) < -minimal ) return 1;
+      if ( arity == minimal ) return 1;
+      return 1;
+    }
+  return 0;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
+
+
+
+  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) 
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_p_FX4Splitter swig_types[0]
+#define SWIGTYPE_p_FX7Segment swig_types[1]
+#define SWIGTYPE_p_FXAccelTable swig_types[2]
+#define SWIGTYPE_p_FXApp swig_types[3]
+#define SWIGTYPE_p_FXArrowButton swig_types[4]
+#define SWIGTYPE_p_FXBMPImage swig_types[5]
+#define SWIGTYPE_p_FXBitmap swig_types[6]
+#define SWIGTYPE_p_FXBitmapFrame swig_types[7]
+#define SWIGTYPE_p_FXCURCursor swig_types[8]
+#define SWIGTYPE_p_FXCanvas swig_types[9]
+#define SWIGTYPE_p_FXColorBar swig_types[10]
+#define SWIGTYPE_p_FXColorRing swig_types[11]
+#define SWIGTYPE_p_FXColorSelector swig_types[12]
+#define SWIGTYPE_p_FXColorWell swig_types[13]
+#define SWIGTYPE_p_FXColorWheel swig_types[14]
+#define SWIGTYPE_p_FXComboBox swig_types[15]
+#define SWIGTYPE_p_FXComposite swig_types[16]
+#define SWIGTYPE_p_FXCursor swig_types[17]
+#define SWIGTYPE_p_FXDataTarget swig_types[18]
+#define SWIGTYPE_p_FXDebugTarget swig_types[19]
+#define SWIGTYPE_p_FXDelegator swig_types[20]
+#define SWIGTYPE_p_FXDial swig_types[21]
+#define SWIGTYPE_p_FXDict swig_types[22]
+#define SWIGTYPE_p_FXDirBox swig_types[23]
+#define SWIGTYPE_p_FXDirSelector swig_types[24]
+#define SWIGTYPE_p_FXDockBar swig_types[25]
+#define SWIGTYPE_p_FXDockHandler swig_types[26]
+#define SWIGTYPE_p_FXDockSite swig_types[27]
+#define SWIGTYPE_p_FXDockTitle swig_types[28]
+#define SWIGTYPE_p_FXDocument swig_types[29]
+#define SWIGTYPE_p_FXDragCorner swig_types[30]
+#define SWIGTYPE_p_FXDrawable swig_types[31]
+#define SWIGTYPE_p_FXDriveBox swig_types[32]
+#define SWIGTYPE_p_FXFileDict swig_types[33]
+#define SWIGTYPE_p_FXFileSelector swig_types[34]
+#define SWIGTYPE_p_FXFileStream swig_types[35]
+#define SWIGTYPE_p_FXFont swig_types[36]
+#define SWIGTYPE_p_FXFontSelector swig_types[37]
+#define SWIGTYPE_p_FXFrame swig_types[38]
+#define SWIGTYPE_p_FXGIFCursor swig_types[39]
+#define SWIGTYPE_p_FXGIFImage swig_types[40]
+#define SWIGTYPE_p_FXGradientBar swig_types[41]
+#define SWIGTYPE_p_FXGroupBox swig_types[42]
+#define SWIGTYPE_p_FXHeader swig_types[43]
+#define SWIGTYPE_p_FXHeaderItem swig_types[44]
+#define SWIGTYPE_p_FXHorizontalFrame swig_types[45]
+#define SWIGTYPE_p_FXHorizontalSeparator swig_types[46]
+#define SWIGTYPE_p_FXICOImage swig_types[47]
+#define SWIGTYPE_p_FXIconDict swig_types[48]
+#define SWIGTYPE_p_FXId swig_types[49]
+#define SWIGTYPE_p_FXImage swig_types[50]
+#define SWIGTYPE_p_FXImageFrame swig_types[51]
+#define SWIGTYPE_p_FXImageView swig_types[52]
+#define SWIGTYPE_p_FXJPGImage swig_types[53]
+#define SWIGTYPE_p_FXKnob swig_types[54]
+#define SWIGTYPE_p_FXListBox swig_types[55]
+#define SWIGTYPE_p_FXMainWindow swig_types[56]
+#define SWIGTYPE_p_FXMatrix swig_types[57]
+#define SWIGTYPE_p_FXMemoryBuffer swig_types[58]
+#define SWIGTYPE_p_FXMemoryStream swig_types[59]
+#define SWIGTYPE_p_FXObject swig_types[60]
+#define SWIGTYPE_p_FXPCXImage swig_types[61]
+#define SWIGTYPE_p_FXPNGImage swig_types[62]
+#define SWIGTYPE_p_FXPPMImage swig_types[63]
+#define SWIGTYPE_p_FXPacker swig_types[64]
+#define SWIGTYPE_p_FXPopup swig_types[65]
+#define SWIGTYPE_p_FXProgressBar swig_types[66]
+#define SWIGTYPE_p_FXRGBImage swig_types[67]
+#define SWIGTYPE_p_FXRealSlider swig_types[68]
+#define SWIGTYPE_p_FXRealSpinner swig_types[69]
+#define SWIGTYPE_p_FXRecentFiles swig_types[70]
+#define SWIGTYPE_p_FXRegistry swig_types[71]
+#define SWIGTYPE_p_FXRootWindow swig_types[72]
+#define SWIGTYPE_p_FXRuler swig_types[73]
+#define SWIGTYPE_p_FXRulerView swig_types[74]
+#define SWIGTYPE_p_FXScrollArea swig_types[75]
+#define SWIGTYPE_p_FXScrollBar swig_types[76]
+#define SWIGTYPE_p_FXScrollCorner swig_types[77]
+#define SWIGTYPE_p_FXScrollWindow swig_types[78]
+#define SWIGTYPE_p_FXSeparator swig_types[79]
+#define SWIGTYPE_p_FXSettings swig_types[80]
+#define SWIGTYPE_p_FXShell swig_types[81]
+#define SWIGTYPE_p_FXShutter swig_types[82]
+#define SWIGTYPE_p_FXShutterItem swig_types[83]
+#define SWIGTYPE_p_FXSlider swig_types[84]
+#define SWIGTYPE_p_FXSpinner swig_types[85]
+#define SWIGTYPE_p_FXSplashWindow swig_types[86]
+#define SWIGTYPE_p_FXSplitter swig_types[87]
+#define SWIGTYPE_p_FXSpring swig_types[88]
+#define SWIGTYPE_p_FXStatusBar swig_types[89]
+#define SWIGTYPE_p_FXStatusLine swig_types[90]
+#define SWIGTYPE_p_FXStream swig_types[91]
+#define SWIGTYPE_p_FXStringDict swig_types[92]
+#define SWIGTYPE_p_FXSwitcher swig_types[93]
+#define SWIGTYPE_p_FXTGAImage swig_types[94]
+#define SWIGTYPE_p_FXTIFImage swig_types[95]
+#define SWIGTYPE_p_FXTabBar swig_types[96]
+#define SWIGTYPE_p_FXTabBook swig_types[97]
+#define SWIGTYPE_p_FXTextField swig_types[98]
+#define SWIGTYPE_p_FXToolBar swig_types[99]
+#define SWIGTYPE_p_FXToolBarGrip swig_types[100]
+#define SWIGTYPE_p_FXToolBarShell swig_types[101]
+#define SWIGTYPE_p_FXToolBarTab swig_types[102]
+#define SWIGTYPE_p_FXToolTip swig_types[103]
+#define SWIGTYPE_p_FXTopWindow swig_types[104]
+#define SWIGTYPE_p_FXTranslator swig_types[105]
+#define SWIGTYPE_p_FXTreeListBox swig_types[106]
+#define SWIGTYPE_p_FXVerticalFrame swig_types[107]
+#define SWIGTYPE_p_FXVerticalSeparator swig_types[108]
+#define SWIGTYPE_p_FXVisual swig_types[109]
+#define SWIGTYPE_p_FXWindow swig_types[110]
+#define SWIGTYPE_p_FXXBMImage swig_types[111]
+#define SWIGTYPE_p_FXXPMImage swig_types[112]
+#define SWIGTYPE_p_char swig_types[113]
+#define SWIGTYPE_p_double swig_types[114]
+#define SWIGTYPE_p_float swig_types[115]
+#define SWIGTYPE_p_int swig_types[116]
+#define SWIGTYPE_p_long swig_types[117]
+#define SWIGTYPE_p_p_char swig_types[118]
+#define SWIGTYPE_p_short swig_types[119]
+#define SWIGTYPE_p_unsigned_char swig_types[120]
+#define SWIGTYPE_p_unsigned_int swig_types[121]
+#define SWIGTYPE_p_unsigned_long swig_types[122]
+#define SWIGTYPE_p_unsigned_short swig_types[123]
+static swig_type_info *swig_types[125];
+static swig_module_info swig_module = {swig_types, 124, 0, 0, 0, 0};
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
+
+/* -------- TYPES TABLE (END) -------- */
+
+#define SWIG_init    Init_image
+#define SWIG_name    "Image"
+
+
+
+#define SWIG_RUBY_THREAD_BEGIN_BLOCK
+#define SWIG_RUBY_THREAD_END_BLOCK
+
+
+#define SWIGVERSION 0x030012 
+#define SWIG_VERSION SWIGVERSION
+
+
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
+
+
+#include <stdexcept>
+
+
+#include "FXRbCommon.h"
+
+
+inline FXColor to_FXColor(VALUE obj){
+  if(TYPE(obj)==T_STRING){
+    return fxcolorfromname(StringValuePtr(obj));
+    }
+  else if(TYPE(obj)==T_SYMBOL){
+    return fxcolorfromname(rb_id2name(SYM2ID(obj)));
+    }
+  else{
+    return NUM2ULONG(obj);
+    }
+  }
+
+
+inline FXString to_FXString(VALUE obj){
+  if(!NIL_P(obj)){
+    Check_Type(obj,T_STRING);
+    return FXString(StringValuePtr(obj));
+    }
+  else{
+    return FXString::null;
+    }
+  }
+
+
+inline FXbool to_FXbool(VALUE obj){
+  if (obj == Qtrue || obj == Qfalse){
+    return (obj == Qtrue) ? TRUE : FALSE;
+    }
+  else{
+    return static_cast<FXbool>(NUM2UINT(obj));
+    }
+  }
+
+
+static swig_type_info* FXEventTypeInfo=0;
+
+inline void* to_FXEvent(VALUE obj){
+  void* ptr;
+  if(!FXEventTypeInfo){
+    FXEventTypeInfo=SWIG_TypeQuery("FXEvent *");
+    FXASSERT(FXEventTypeInfo!=0);
+    }
+  SWIG_ConvertPtr(obj,&ptr,FXEventTypeInfo,1);
+  return ptr;
+  }
+
+
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
+
+
+  #define SWIG_From_long   LONG2NUM 
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_int  (int value)
+{    
+  return SWIG_From_long  (value);
+}
+
+SWIGINTERN FXBitmap *new_FXBitmap(FXApp *a,void const *pix=0,FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbBitmap(a,pix,opts,w,h);
+      }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_long  (unsigned long value)
+{
+  return ULONG2NUM(value); 
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_int  (unsigned int value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_bool  (bool value)
+{
+  return value ? Qtrue : Qfalse;
+}
+
+SWIGINTERN VALUE FXMemoryBuffer_getData(FXMemoryBuffer const *self){
+      FXColor* data = self->getData();
+      if (data) {
+        FXuint size = self->getSize();
+        VALUE ary = rb_ary_new2(size);
+        for (FXuint i = 0; i < size; i++)
+          rb_ary_store(ary, i, UINT2NUM(data[i]));
+        return ary;
+        }
+      else {
+        return Qnil;
+        }
+      }
+SWIGINTERN FXColor FXMemoryBuffer___getitem__(FXMemoryBuffer const *self,FXuint i){
+      return self->getData()[i];
+      }
+SWIGINTERN FXColor FXMemoryBuffer___setitem__(FXMemoryBuffer *self,FXuint i,FXColor value){
+      self->getData()[i] = value;
+      return value;
+      }
+SWIGINTERN FXImage *new_FXImage(FXApp *a,VALUE string_or_ary=Qnil,FXuint opts=0,FXint w=1,FXint h=1){
+      FXColor* pix=0;
+      if(!NIL_P(string_or_ary)){
+        FXint len=FXRbNumberOfFXColors(string_or_ary);
+        if(w*h != len){
+          rb_raise( rb_eArgError, "Array size does not match image size" );
+        }
+        pix=FXRbConvertToFXColors(string_or_ary, &opts);
+      }
+      return new FXRbImage(a,pix,opts,w,h);
+    }
+SWIGINTERN FXMemoryBuffer *FXImage_getData(FXImage const *self){
+      if(self->getData()){
+        return new FXMemoryBuffer(self->getData(),self->getWidth()*self->getHeight());
+      }
+      else{
+        return 0;
+      }
+    }
+SWIGINTERN VALUE FXImage_getDataPtr(FXImage const *self){
+      return ULL2NUM((uintptr_t)self->getData());
+    }
+SWIGINTERN void FXImage_setPixels(FXImage *self,VALUE string_or_ary,FXuint opts=0,VALUE w=Qnil,VALUE h=Qnil){
+      FXint len=FXRbNumberOfFXColors(string_or_ary);
+      if( ( (NIL_P(w) || NIL_P(h)) && self->getWidth()*self->getHeight() != len) ||
+          (!(NIL_P(w) || NIL_P(h)) && NUM2INT(w)*NUM2INT(h) != len)){
+        rb_raise( rb_eArgError, "Array size does not match image size" );
+      }
+
+      FXColor* pix=FXRbConvertToFXColors(string_or_ary, &opts);
+      if( NIL_P(w) || NIL_P(h) ){
+        self->setData(pix,opts);
+      }else{
+        self->setData(pix,opts,NUM2UINT(w),NUM2UINT(h));
+      }
+    }
+SWIGINTERN VALUE FXImage_pixels(FXImage *self){
+      FXColor* data = self->getData();
+      if (data) {
+        FXuint size = self->getWidth()*self->getHeight();
+        VALUE ary = rb_ary_new2(size);
+        for (FXuint i = 0; i < size; i++)
+          rb_ary_store(ary, i, UINT2NUM(data[i]));
+        return ary;
+      } else {
+        return Qnil;
+      }
+    }
+SWIGINTERN VALUE FXImage_pixel_string__SWIG_0(FXImage *self){
+      FXColor* data = self->getData();
+      if (data) {
+        return rb_str_new((char*)data, self->getWidth()*self->getHeight()*sizeof(FXColor));
+      } else {
+        return Qnil;
+      }
+    }
+SWIGINTERN VALUE FXImage_pixel_string__SWIG_1(FXImage *self,FXlong offset,FXlong size){
+      FXColor* data = self->getData();
+      if (data) {
+        FXlong maxsize = self->getWidth()*self->getHeight()*sizeof(FXColor);
+        if( offset > maxsize || offset < 0 ){
+          return Qnil;
+        }
+        if( offset+size > maxsize ){
+          size = maxsize-offset;
+        }else if( size < 0 ){
+          return Qnil;
+        }
+
+        return rb_str_new((char*)data + offset, size);
+      } else {
+        return Qnil;
+      }
+    }
+
+SWIGINTERN VALUE
+SWIG_ruby_failed(VALUE, VALUE)
+{
+  return Qnil;
+} 
+
+
+/*@SWIG:/usr/share/swig3.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE pargs){VALUE *args=(VALUE *)pargs;
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  long *res = (long *)(args[1]);
+  *res = type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj);
+  return obj;
+}
+/*@SWIG@*/
+
+SWIGINTERN int
+SWIG_AsVal_long (VALUE obj, long* val)
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
+    long v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_VALUE_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_VALUE_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_int (VALUE obj, int *val)
+{
+  long v;
+  int res = SWIG_AsVal_long (obj, &v);
+  if (SWIG_IsOK(res)) {
+    if ((v < INT_MIN || v > INT_MAX)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = static_cast< int >(v);
+    }
+  }  
+  return res;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_bool (VALUE obj, bool *val)
+{
+  if (obj == Qtrue) {
+    if (val) *val = true;
+    return SWIG_OK;
+  } else if (obj == Qfalse) {
+    if (val) *val = false;
+    return SWIG_OK;
+  } else {
+    int res = 0;
+    if (SWIG_AsVal_int (obj, &res) == SWIG_OK) {    
+      if (val) *val = res ? true : false;
+      return SWIG_OK;
+    }
+  }  
+  return SWIG_TypeError;
+}
+
+
+static swig_type_info *FXImage_dynamic_cast(void **ptr) {
+    FXImage **ppImage = reinterpret_cast<FXImage **>(ptr);
+    FXBMPImage *pBMPImage=dynamic_cast<FXBMPImage*>(*ppImage);
+    if(pBMPImage){
+      *ptr=reinterpret_cast<void*>(pBMPImage);
+      return SWIG_TypeQuery("FXBMPImage *");
+      }
+    FXGIFImage *pGIFImage=dynamic_cast<FXGIFImage*>(*ppImage);
+    if(pGIFImage){
+      *ptr=reinterpret_cast<void*>(pGIFImage);
+      return SWIG_TypeQuery("FXGIFImage *");
+      }
+    FXICOImage *pICOImage=dynamic_cast<FXICOImage*>(*ppImage);
+    if(pICOImage){
+      *ptr=reinterpret_cast<void*>(pICOImage);
+      return SWIG_TypeQuery("FXICOImage *");
+      }
+    FXIcon *pIcon=dynamic_cast<FXIcon*>(*ppImage);
+    if(pIcon){
+      *ptr=reinterpret_cast<void*>(pIcon);
+      return SWIG_TypeQuery("FXIcon *");
+      }
+    FXJPGImage *pJPGImage=dynamic_cast<FXJPGImage*>(*ppImage);
+    if(pJPGImage){
+      *ptr=reinterpret_cast<void*>(pJPGImage);
+      return SWIG_TypeQuery("FXJPGImage *");
+      }
+    FXPCXImage *pPCXImage=dynamic_cast<FXPCXImage*>(*ppImage);
+    if(pPCXImage){
+      *ptr=reinterpret_cast<void*>(pPCXImage);
+      return SWIG_TypeQuery("FXPCXImage *");
+      }
+    FXPNGImage *pPNGImage=dynamic_cast<FXPNGImage*>(*ppImage);
+    if(pPNGImage){
+      *ptr=reinterpret_cast<void*>(pPNGImage);
+      return SWIG_TypeQuery("FXPNGImage *");
+      }
+    FXPPMImage *pPPMImage=dynamic_cast<FXPPMImage*>(*ppImage);
+    if(pPPMImage){
+      *ptr=reinterpret_cast<void*>(pPPMImage);
+      return SWIG_TypeQuery("FXPPMImage *");
+      }
+    FXRGBImage *pRGBImage=dynamic_cast<FXRGBImage*>(*ppImage);
+    if(pRGBImage){
+      *ptr=reinterpret_cast<void*>(pRGBImage);
+      return SWIG_TypeQuery("FXRGBImage *");
+      }
+    FXTGAImage *pTGAImage=dynamic_cast<FXTGAImage*>(*ppImage);
+    if(pTGAImage){
+      *ptr=reinterpret_cast<void*>(pTGAImage);
+      return SWIG_TypeQuery("FXTGAImage *");
+      }
+    FXTIFImage *pTIFImage=dynamic_cast<FXTIFImage*>(*ppImage);
+    if(pTIFImage){
+      *ptr=reinterpret_cast<void*>(pTIFImage);
+      return SWIG_TypeQuery("FXTIFImage *");
+      }
+    FXXBMImage *pXBMImage=dynamic_cast<FXXBMImage*>(*ppImage);
+    if(pXBMImage){
+      *ptr=reinterpret_cast<void*>(pXBMImage);
+      return SWIG_TypeQuery("FXXBMImage *");
+      }
+    FXXPMImage *pXPMImage=dynamic_cast<FXXPMImage*>(*ppImage);
+    if(pXPMImage){
+      *ptr=reinterpret_cast<void*>(pXPMImage);
+      return SWIG_TypeQuery("FXXPMImage *");
+      }
+    return 0;
+}
+
+SWIGINTERN VALUE FXBMPImage_fileExt(){
+      return to_ruby(FXBMPImage::fileExt);
+      }
+SWIGINTERN VALUE FXBMPImage_mimeType(){
+      return to_ruby(FXBMPImage::mimeType);
+      }
+SWIGINTERN FXBMPImage *new_FXBMPImage(FXApp *a,void const *pix=0,FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbBMPImage(a,pix,opts,w,h);
+      }
+SWIGINTERN VALUE FXGIFImage_fileExt(){
+      return to_ruby(FXGIFImage::fileExt);
+      }
+SWIGINTERN VALUE FXGIFImage_mimeType(){
+      return to_ruby(FXGIFImage::mimeType);
+      }
+SWIGINTERN FXGIFImage *new_FXGIFImage(FXApp *a,void const *pix=0,FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbGIFImage(a,pix,opts,w,h);
+      }
+SWIGINTERN VALUE FXICOImage_fileExt(){
+      return to_ruby(FXICOImage::fileExt);
+      }
+SWIGINTERN VALUE FXICOImage_mimeType(){
+      return to_ruby(FXICOImage::mimeType);
+      }
+SWIGINTERN FXICOImage *new_FXICOImage(FXApp *a,void const *pix=0,FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbICOImage(a,pix,opts,w,h);
+      }
+SWIGINTERN VALUE FXJPGImage_fileExt(){
+      return to_ruby(FXJPGImage::fileExt);
+      }
+SWIGINTERN VALUE FXJPGImage_mimeType(){
+      return to_ruby(FXJPGImage::mimeType);
+      }
+SWIGINTERN bool FXJPGImage_isSupported(){ return FXJPGImage::supported; }
+SWIGINTERN FXJPGImage *new_FXJPGImage(FXApp *a,void const *pix=0,FXuint opts=0,FXint w=1,FXint h=1,FXint q=75){
+      return new FXRbJPGImage(a,pix,opts,w,h,q);
+      }
+SWIGINTERN VALUE FXPCXImage_fileExt(){
+      return to_ruby(FXPCXImage::fileExt);
+      }
+SWIGINTERN VALUE FXPCXImage_mimeType(){
+      return to_ruby(FXPCXImage::mimeType);
+      }
+SWIGINTERN FXPCXImage *new_FXPCXImage(FXApp *a,void const *pix=0,FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbPCXImage(a,pix,opts,w,h);
+      }
+SWIGINTERN VALUE FXPNGImage_fileExt(){
+      return to_ruby(FXPNGImage::fileExt);
+      }
+SWIGINTERN VALUE FXPNGImage_mimeType(){
+      return to_ruby(FXPNGImage::mimeType);
+      }
+SWIGINTERN bool FXPNGImage_isSupported(){ return FXPNGImage::supported; }
+SWIGINTERN FXPNGImage *new_FXPNGImage(FXApp *a,void const *pix=0,FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbPNGImage(a,pix,opts,w,h);
+      }
+SWIGINTERN VALUE FXPPMImage_fileExt(){
+      return to_ruby(FXPPMImage::fileExt);
+      }
+SWIGINTERN VALUE FXPPMImage_mimeType(){
+      return to_ruby(FXPPMImage::mimeType);
+      }
+SWIGINTERN FXPPMImage *new_FXPPMImage(FXApp *a,void const *pix=0,FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbPPMImage(a,pix,opts,w,h);
+      }
+SWIGINTERN VALUE FXRGBImage_fileExt(){
+      return to_ruby(FXRGBImage::fileExt);
+      }
+SWIGINTERN VALUE FXRGBImage_mimeType(){
+      return to_ruby(FXRGBImage::mimeType);
+      }
+SWIGINTERN FXRGBImage *new_FXRGBImage(FXApp *a,void const *pix=0,FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbRGBImage(a,pix,opts,w,h);
+      }
+SWIGINTERN VALUE FXTGAImage_fileExt(){
+      return to_ruby(FXTGAImage::fileExt);
+      }
+SWIGINTERN VALUE FXTGAImage_mimeType(){
+      return to_ruby(FXTGAImage::mimeType);
+      }
+SWIGINTERN FXTGAImage *new_FXTGAImage(FXApp *a,void const *pix=0,FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbTGAImage(a,pix,opts,w,h);
+      }
+SWIGINTERN VALUE FXTIFImage_fileExt(){
+      return to_ruby(FXTIFImage::fileExt);
+      }
+SWIGINTERN VALUE FXTIFImage_mimeType(){
+      return to_ruby(FXTIFImage::mimeType);
+      }
+SWIGINTERN bool FXTIFImage_isSupported(){ return FXTIFImage::supported; }
+SWIGINTERN FXTIFImage *new_FXTIFImage(FXApp *a,void const *pix=0,FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbTIFImage(a,pix,opts,w,h);
+      }
+
+  /// Load a tiff from a stream
+  VALUE fxloadTIF(FXStream& store){
+    FXColor* data;
+    FXint width;
+    FXint height;
+    FXushort codec;
+    if(fxloadTIF(store,data,width,height,codec)){
+      VALUE ary=rb_ary_new();
+      rb_ary_push(ary,FXRbMakeColorArray(data,width,height));
+      FXFREE(&data);
+      rb_ary_push(ary,to_ruby(width));
+      rb_ary_push(ary,to_ruby(height));
+      rb_ary_push(ary,to_ruby(codec));
+      return ary;
+      }
+    else{
+      return Qnil;
+      }
+    }
+
+SWIGINTERN VALUE FXXBMImage_fileExt(){
+      return to_ruby(FXXBMImage::fileExt);
+      }
+SWIGINTERN VALUE FXXBMImage_mimeType(){
+      return to_ruby(FXXBMImage::mimeType);
+      }
+SWIGINTERN FXXBMImage *new_FXXBMImage(FXApp *a,FXuchar const *pixels=0,FXuchar const *mask=0,FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbXBMImage(a,pixels,mask,opts,w,h);
+      }
+
+  /**
+   * Load an XBM (X Bitmap) from pixel array and mask array.
+   * Upon successful return, the pixel array and size are returned.
+   * If an error occurred, the pixel array is set to NULL.
+   */
+  VALUE fxloadXBM(const FXuchar *pix,const FXuchar *msk,FXint width,FXint height){
+    FXColor* data;
+    if(fxloadXBM(data,pix,msk,width,height)){
+      VALUE obj=FXRbMakeColorArray(data,width,height);
+      FXFREE(&data);
+      return obj;
+      }
+    else{
+      return Qnil;
+      }
+    }
+
+
+  /**
+   * Load an XBM (X Bitmap) file from a stream.
+   * Upon successful return, the pixel array and size, and hot-spot are returned.
+   * If an error occurred, the pixel array is set to NULL.
+   */
+  VALUE fxloadXBM(FXStream& store){
+    FXColor* data;
+    FXint width,height,hotx,hoty;
+    if(fxloadXBM(store,data,width,height,hotx,hoty)){
+      VALUE ary=rb_ary_new();
+      rb_ary_push(ary,FXRbMakeColorArray(data,width,height));
+      FXFREE(&data);
+      rb_ary_push(ary,to_ruby(width));
+      rb_ary_push(ary,to_ruby(height));
+      rb_ary_push(ary,to_ruby(hotx));
+      rb_ary_push(ary,to_ruby(hoty));
+      return ary;
+      }
+    else{
+      return Qnil;
+      }
+    }
+
+SWIGINTERN VALUE FXXPMImage_fileExt(){
+      return to_ruby(FXXPMImage::fileExt);
+      }
+SWIGINTERN VALUE FXXPMImage_mimeType(){
+      return to_ruby(FXXPMImage::mimeType);
+      }
+SWIGINTERN FXXPMImage *new_FXXPMImage(FXApp *a,FXchar const **pix=0,FXuint opts=0,FXint w=1,FXint h=1){
+      return new FXRbXPMImage(a,pix,opts,w,h);
+      }
+static swig_class SwigClassFXBitmap;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXBitmap_allocate(VALUE self)
+#else
+_wrap_FXBitmap_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXBitmap);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXBitmap(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXuint arg3 = (FXuint) 0 ;
+  FXint arg4 = (FXint) 1 ;
+  FXint arg5 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXBitmap *result = 0 ;
+  
+  if ((argc < 1) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXBitmap", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      if (argv[1] != Qnil) {
+        Check_Type(argv[1], T_STRING);
+        arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
+      } else {
+        arg2 = NULL;
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXBitmap *)new_FXBitmap(arg1,(void const *)arg2,arg3,arg4,arg5);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmap_getData(int argc, VALUE *argv, VALUE self) {
+  FXBitmap *arg1 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap const *","getData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmap * >(argp1);
+  result = (FXuchar *)((FXBitmap const *)arg1)->getData();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmap_getOptions(int argc, VALUE *argv, VALUE self) {
+  FXBitmap *arg1 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap const *","getOptions", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmap * >(argp1);
+  result = (FXuint)((FXBitmap const *)arg1)->getOptions();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmap_setOptions(int argc, VALUE *argv, VALUE self) {
+  FXBitmap *arg1 = (FXBitmap *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","setOptions", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmap * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setOptions(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmap_getPixel(int argc, VALUE *argv, VALUE self) {
+  FXBitmap *arg1 = (FXBitmap *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap const *","getPixel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmap * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXbool)((FXBitmap const *)arg1)->getPixel(arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmap_setPixel(int argc, VALUE *argv, VALUE self) {
+  FXBitmap *arg1 = (FXBitmap *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXbool arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","setPixel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmap * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = to_FXbool(argv[2]);
+  (arg1)->setPixel(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmap_save(int argc, VALUE *argv, VALUE self) {
+  FXBitmap *arg1 = (FXBitmap *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmap * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXBitmap_save((FXBitmap const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmap_load(int argc, VALUE *argv, VALUE self) {
+  FXBitmap *arg1 = (FXBitmap *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmap * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXBitmap_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmap_create(int argc, VALUE *argv, VALUE self) {
+  FXBitmap *arg1 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmap * >(argp1);
+  FXBitmap_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmap_detach(int argc, VALUE *argv, VALUE self) {
+  FXBitmap *arg1 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmap * >(argp1);
+  FXBitmap_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmap_destroy(int argc, VALUE *argv, VALUE self) {
+  FXBitmap *arg1 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmap * >(argp1);
+  FXBitmap_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmap_resize(int argc, VALUE *argv, VALUE self) {
+  FXBitmap *arg1 = (FXBitmap *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmap * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXBitmap_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmap_restore(int argc, VALUE *argv, VALUE self) {
+  FXBitmap *arg1 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmap * >(argp1);
+  FXBitmap_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmap_render(int argc, VALUE *argv, VALUE self) {
+  FXBitmap *arg1 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmap * >(argp1);
+  FXBitmap_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmap_release(int argc, VALUE *argv, VALUE self) {
+  FXBitmap *arg1 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmap * >(argp1);
+  FXBitmap_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmap_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXBitmap *arg1 = (FXBitmap *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmap * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXBitmap_savePixels((FXBitmap const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmap_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXBitmap *arg1 = (FXBitmap *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmap * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXBitmap_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmap_scale(int argc, VALUE *argv, VALUE self) {
+  FXBitmap *arg1 = (FXBitmap *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmap * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXBitmap_scale(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmap_mirror(int argc, VALUE *argv, VALUE self) {
+  FXBitmap *arg1 = (FXBitmap *) 0 ;
+  FXbool arg2 ;
+  FXbool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmap * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  arg3 = to_FXbool(argv[1]);
+  FXBitmap_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmap_rotate(int argc, VALUE *argv, VALUE self) {
+  FXBitmap *arg1 = (FXBitmap *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmap * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXBitmap_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmap_crop(int argc, VALUE *argv, VALUE self) {
+  FXBitmap *arg1 = (FXBitmap *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXbool arg6 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmap * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXbool(argv[4]);
+  }
+  FXBitmap_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmap_fill(int argc, VALUE *argv, VALUE self) {
+  FXBitmap *arg1 = (FXBitmap *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmap * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXBitmap_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmap_setData__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXBitmap *arg1 = (FXBitmap *) 0 ;
+  FXuchar *arg2 = (FXuchar *) 0 ;
+  FXuint arg3 = (FXuint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","setData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmap * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXuchar *","setData", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXuchar * >(argp2);
+  if (argc > 1) {
+    arg3 = NUM2UINT(argv[1]);
+  }
+  FXBitmap_setData(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBitmap_setData__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXBitmap *arg1 = (FXBitmap *) 0 ;
+  FXuchar *arg2 = (FXuchar *) 0 ;
+  FXuint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBitmap *","setData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBitmap * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXuchar *","setData", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXuchar * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXBitmap_setData(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXBitmap_setData(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 2) && (argc <= 3)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXBitmap, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_FXBitmap_setData__SWIG_0(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          return _wrap_FXBitmap_setData__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXBitmap, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXBitmap_setData__SWIG_1(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "setData", 
+    "    void setData(FXuchar *pix, FXuint opts)\n"
+    "    void setData(FXuchar *pix, FXuint opts, FXint w, FXint h)\n");
+  
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMemoryBuffer;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMemoryBuffer_allocate(VALUE self)
+#else
+_wrap_FXMemoryBuffer_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMemoryBuffer);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMemoryBuffer(int argc, VALUE *argv, VALUE self) {
+  FXColor *arg1 = (FXColor *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMemoryBuffer *result = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_unsigned_int, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColor *","FXMemoryBuffer", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXColor * >(argp1);
+  arg2 = NUM2INT(argv[1]);
+  result = (FXMemoryBuffer *)new FXMemoryBuffer(arg1,arg2);
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMemoryBuffer_getSize(int argc, VALUE *argv, VALUE self) {
+  FXMemoryBuffer *arg1 = (FXMemoryBuffer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMemoryBuffer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMemoryBuffer const *","getSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMemoryBuffer * >(argp1);
+  result = (FXuint)((FXMemoryBuffer const *)arg1)->getSize();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMemoryBuffer_getData(int argc, VALUE *argv, VALUE self) {
+  FXMemoryBuffer *arg1 = (FXMemoryBuffer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMemoryBuffer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMemoryBuffer const *","getData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMemoryBuffer * >(argp1);
+  result = (VALUE)FXMemoryBuffer_getData((FXMemoryBuffer const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Image::FXMemoryBuffer.[]
+
+  call-seq:
+    [](i) -> FXColor
+
+Element accessor/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXMemoryBuffer___getitem__(int argc, VALUE *argv, VALUE self) {
+  FXMemoryBuffer *arg1 = (FXMemoryBuffer *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMemoryBuffer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMemoryBuffer const *","__getitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMemoryBuffer * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  result = (FXColor)FXMemoryBuffer___getitem__((FXMemoryBuffer const *)arg1,arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/*
+  Document-method: Image::FXMemoryBuffer.[]=
+
+  call-seq:
+    []=(i, value) -> FXColor
+
+Element setter/slicing.
+*/
+SWIGINTERN VALUE
+_wrap_FXMemoryBuffer___setitem__(int argc, VALUE *argv, VALUE self) {
+  FXMemoryBuffer *arg1 = (FXMemoryBuffer *) 0 ;
+  FXuint arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMemoryBuffer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMemoryBuffer *","__setitem__", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMemoryBuffer * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  result = (FXColor)FXMemoryBuffer___setitem__(arg1,arg2,arg3);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN void
+free_FXMemoryBuffer(void *self) {
+    FXMemoryBuffer *arg1 = (FXMemoryBuffer *)self;
+    delete arg1;
+}
+
+static swig_class SwigClassFXImage;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXImage_allocate(VALUE self)
+#else
+_wrap_FXImage_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXImage);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXImage(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  VALUE arg2 = (VALUE) Qnil ;
+  FXuint arg3 = (FXuint) 0 ;
+  FXint arg4 = (FXint) 1 ;
+  FXint arg5 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXImage *result = 0 ;
+  
+  if ((argc < 1) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXImage", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    arg2 = argv[1];
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXImage *)new_FXImage(arg1,arg2,arg3,arg4,arg5);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_getData(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMemoryBuffer *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage const *","getData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  result = (FXMemoryBuffer *)FXImage_getData((FXImage const *)arg1);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXMemoryBuffer, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_getDataPtr(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage const *","getDataPtr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  result = (VALUE)FXImage_getDataPtr((FXImage const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_getOptions(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage const *","getOptions", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  result = (FXuint)((FXImage const *)arg1)->getOptions();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_setOptions(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","setOptions", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setOptions(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_setPixels(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  FXuint arg3 = (FXuint) 0 ;
+  VALUE arg4 = (VALUE) Qnil ;
+  VALUE arg5 = (VALUE) Qnil ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","setPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  arg2 = argv[0];
+  if (argc > 1) {
+    arg3 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = argv[2];
+  }
+  if (argc > 3) {
+    arg5 = argv[3];
+  }
+  FXImage_setPixels(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_pixels(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","pixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  result = (VALUE)FXImage_pixels(arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_pixel_string__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","pixel_string", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  result = (VALUE)FXImage_pixel_string__SWIG_0(arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_pixel_string__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  FXlong arg2 ;
+  FXlong arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","pixel_string", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  arg2 = static_cast<FXlong>(NUM2LONG(argv[0]));
+  arg3 = static_cast<FXlong>(NUM2LONG(argv[1]));
+  result = (VALUE)FXImage_pixel_string__SWIG_1(arg1,arg2,arg3);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXImage_pixel_string(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 4) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXImage, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXImage_pixel_string__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXImage, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          return _wrap_FXImage_pixel_string__SWIG_1(nargs, args, self);
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "pixel_string", 
+    "    VALUE pixel_string()\n"
+    "    VALUE pixel_string(FXlong offset, FXlong size)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_getPixel(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage const *","getPixel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXColor)((FXImage const *)arg1)->getPixel(arg2,arg3);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_setPixel(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXColor arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","setPixel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  (arg1)->setPixel(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_hasAlphaq___(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage const *","hasAlpha", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  result = (bool)((FXImage const *)arg1)->hasAlpha();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_save(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXImage_save((FXImage const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_load(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXImage_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_create(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  FXImage_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_detach(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  FXImage_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_destroy(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  FXImage_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_resize(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXImage_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_restore(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  FXImage_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_render(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  FXImage_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_release(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  FXImage_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_scale(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXImage_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_mirror(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXImage_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_rotate(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXImage_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_crop(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXImage_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_fill(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXImage_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_fade(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXImage_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_xshear(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXImage_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_yshear(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXImage_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXImage_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXImage_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_gradient(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXImage_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_blend(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXImage_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXImage_savePixels((FXImage const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImage_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXImage *arg1 = (FXImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImage *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXImage_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXBMPImage;
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXBMPImage_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXBMPImage_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXBMPImage_allocate(VALUE self)
+#else
+_wrap_FXBMPImage_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXBMPImage);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXBMPImage(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXuint arg3 = (FXuint) 0 ;
+  FXint arg4 = (FXint) 1 ;
+  FXint arg5 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXBMPImage *result = 0 ;
+  
+  if ((argc < 1) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXBMPImage", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      if (argv[1] != Qnil) {
+        Check_Type(argv[1], T_STRING);
+        arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
+      } else {
+        arg2 = NULL;
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXBMPImage *)new_FXBMPImage(arg1,(void const *)arg2,arg3,arg4,arg5);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_save(int argc, VALUE *argv, VALUE self) {
+  FXBMPImage *arg1 = (FXBMPImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPImage const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXBMPImage_save((FXBMPImage const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_load(int argc, VALUE *argv, VALUE self) {
+  FXBMPImage *arg1 = (FXBMPImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPImage *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXBMPImage_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_create(int argc, VALUE *argv, VALUE self) {
+  FXBMPImage *arg1 = (FXBMPImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPImage *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPImage * >(argp1);
+  FXBMPImage_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_detach(int argc, VALUE *argv, VALUE self) {
+  FXBMPImage *arg1 = (FXBMPImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPImage *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPImage * >(argp1);
+  FXBMPImage_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_destroy(int argc, VALUE *argv, VALUE self) {
+  FXBMPImage *arg1 = (FXBMPImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPImage *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPImage * >(argp1);
+  FXBMPImage_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_resize(int argc, VALUE *argv, VALUE self) {
+  FXBMPImage *arg1 = (FXBMPImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPImage *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXBMPImage_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_restore(int argc, VALUE *argv, VALUE self) {
+  FXBMPImage *arg1 = (FXBMPImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPImage *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPImage * >(argp1);
+  FXBMPImage_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_render(int argc, VALUE *argv, VALUE self) {
+  FXBMPImage *arg1 = (FXBMPImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPImage *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPImage * >(argp1);
+  FXBMPImage_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_release(int argc, VALUE *argv, VALUE self) {
+  FXBMPImage *arg1 = (FXBMPImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPImage *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPImage * >(argp1);
+  FXBMPImage_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_scale(int argc, VALUE *argv, VALUE self) {
+  FXBMPImage *arg1 = (FXBMPImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPImage *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXBMPImage_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_mirror(int argc, VALUE *argv, VALUE self) {
+  FXBMPImage *arg1 = (FXBMPImage *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPImage *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPImage * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXBMPImage_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_rotate(int argc, VALUE *argv, VALUE self) {
+  FXBMPImage *arg1 = (FXBMPImage *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPImage *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXBMPImage_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_crop(int argc, VALUE *argv, VALUE self) {
+  FXBMPImage *arg1 = (FXBMPImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPImage *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXBMPImage_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_fill(int argc, VALUE *argv, VALUE self) {
+  FXBMPImage *arg1 = (FXBMPImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPImage *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXBMPImage_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_fade(int argc, VALUE *argv, VALUE self) {
+  FXBMPImage *arg1 = (FXBMPImage *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPImage *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXBMPImage_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_xshear(int argc, VALUE *argv, VALUE self) {
+  FXBMPImage *arg1 = (FXBMPImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPImage *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXBMPImage_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_yshear(int argc, VALUE *argv, VALUE self) {
+  FXBMPImage *arg1 = (FXBMPImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPImage *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXBMPImage_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXBMPImage *arg1 = (FXBMPImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPImage *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXBMPImage_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXBMPImage *arg1 = (FXBMPImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPImage *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXBMPImage_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_gradient(int argc, VALUE *argv, VALUE self) {
+  FXBMPImage *arg1 = (FXBMPImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPImage *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXBMPImage_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_blend(int argc, VALUE *argv, VALUE self) {
+  FXBMPImage *arg1 = (FXBMPImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPImage *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXBMPImage_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXBMPImage *arg1 = (FXBMPImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPImage const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXBMPImage_savePixels((FXBMPImage const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXBMPImage_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXBMPImage *arg1 = (FXBMPImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXBMPImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXBMPImage *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXBMPImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXBMPImage_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXGIFImage;
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXGIFImage_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXGIFImage_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXGIFImage_allocate(VALUE self)
+#else
+_wrap_FXGIFImage_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXGIFImage);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXGIFImage(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXuint arg3 = (FXuint) 0 ;
+  FXint arg4 = (FXint) 1 ;
+  FXint arg5 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXGIFImage *result = 0 ;
+  
+  if ((argc < 1) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXGIFImage", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      if (argv[1] != Qnil) {
+        Check_Type(argv[1], T_STRING);
+        arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
+      } else {
+        arg2 = NULL;
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXGIFImage *)new_FXGIFImage(arg1,(void const *)arg2,arg3,arg4,arg5);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_save(int argc, VALUE *argv, VALUE self) {
+  FXGIFImage *arg1 = (FXGIFImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFImage const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXGIFImage_save((FXGIFImage const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_load(int argc, VALUE *argv, VALUE self) {
+  FXGIFImage *arg1 = (FXGIFImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFImage *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXGIFImage_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_create(int argc, VALUE *argv, VALUE self) {
+  FXGIFImage *arg1 = (FXGIFImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFImage *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFImage * >(argp1);
+  FXGIFImage_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_detach(int argc, VALUE *argv, VALUE self) {
+  FXGIFImage *arg1 = (FXGIFImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFImage *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFImage * >(argp1);
+  FXGIFImage_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_destroy(int argc, VALUE *argv, VALUE self) {
+  FXGIFImage *arg1 = (FXGIFImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFImage *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFImage * >(argp1);
+  FXGIFImage_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_resize(int argc, VALUE *argv, VALUE self) {
+  FXGIFImage *arg1 = (FXGIFImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFImage *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXGIFImage_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_restore(int argc, VALUE *argv, VALUE self) {
+  FXGIFImage *arg1 = (FXGIFImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFImage *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFImage * >(argp1);
+  FXGIFImage_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_render(int argc, VALUE *argv, VALUE self) {
+  FXGIFImage *arg1 = (FXGIFImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFImage *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFImage * >(argp1);
+  FXGIFImage_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_release(int argc, VALUE *argv, VALUE self) {
+  FXGIFImage *arg1 = (FXGIFImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFImage *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFImage * >(argp1);
+  FXGIFImage_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_scale(int argc, VALUE *argv, VALUE self) {
+  FXGIFImage *arg1 = (FXGIFImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFImage *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXGIFImage_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_mirror(int argc, VALUE *argv, VALUE self) {
+  FXGIFImage *arg1 = (FXGIFImage *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFImage *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFImage * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXGIFImage_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_rotate(int argc, VALUE *argv, VALUE self) {
+  FXGIFImage *arg1 = (FXGIFImage *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFImage *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXGIFImage_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_crop(int argc, VALUE *argv, VALUE self) {
+  FXGIFImage *arg1 = (FXGIFImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFImage *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXGIFImage_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_fill(int argc, VALUE *argv, VALUE self) {
+  FXGIFImage *arg1 = (FXGIFImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFImage *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXGIFImage_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_fade(int argc, VALUE *argv, VALUE self) {
+  FXGIFImage *arg1 = (FXGIFImage *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFImage *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXGIFImage_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_xshear(int argc, VALUE *argv, VALUE self) {
+  FXGIFImage *arg1 = (FXGIFImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFImage *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXGIFImage_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_yshear(int argc, VALUE *argv, VALUE self) {
+  FXGIFImage *arg1 = (FXGIFImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFImage *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXGIFImage_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXGIFImage *arg1 = (FXGIFImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFImage *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXGIFImage_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXGIFImage *arg1 = (FXGIFImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFImage *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXGIFImage_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_gradient(int argc, VALUE *argv, VALUE self) {
+  FXGIFImage *arg1 = (FXGIFImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFImage *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXGIFImage_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_blend(int argc, VALUE *argv, VALUE self) {
+  FXGIFImage *arg1 = (FXGIFImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFImage *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXGIFImage_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXGIFImage *arg1 = (FXGIFImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFImage const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXGIFImage_savePixels((FXGIFImage const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGIFImage_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXGIFImage *arg1 = (FXGIFImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGIFImage *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGIFImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXGIFImage_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXICOImage;
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXICOImage_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXICOImage_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXICOImage_allocate(VALUE self)
+#else
+_wrap_FXICOImage_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXICOImage);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXICOImage(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXuint arg3 = (FXuint) 0 ;
+  FXint arg4 = (FXint) 1 ;
+  FXint arg5 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXICOImage *result = 0 ;
+  
+  if ((argc < 1) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXICOImage", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      if (argv[1] != Qnil) {
+        Check_Type(argv[1], T_STRING);
+        arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
+      } else {
+        arg2 = NULL;
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXICOImage *)new_FXICOImage(arg1,(void const *)arg2,arg3,arg4,arg5);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_save(int argc, VALUE *argv, VALUE self) {
+  FXICOImage *arg1 = (FXICOImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOImage const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXICOImage_save((FXICOImage const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_load(int argc, VALUE *argv, VALUE self) {
+  FXICOImage *arg1 = (FXICOImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOImage *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXICOImage_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_create(int argc, VALUE *argv, VALUE self) {
+  FXICOImage *arg1 = (FXICOImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOImage *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOImage * >(argp1);
+  FXICOImage_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_detach(int argc, VALUE *argv, VALUE self) {
+  FXICOImage *arg1 = (FXICOImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOImage *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOImage * >(argp1);
+  FXICOImage_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_destroy(int argc, VALUE *argv, VALUE self) {
+  FXICOImage *arg1 = (FXICOImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOImage *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOImage * >(argp1);
+  FXICOImage_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_resize(int argc, VALUE *argv, VALUE self) {
+  FXICOImage *arg1 = (FXICOImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOImage *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXICOImage_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_restore(int argc, VALUE *argv, VALUE self) {
+  FXICOImage *arg1 = (FXICOImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOImage *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOImage * >(argp1);
+  FXICOImage_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_render(int argc, VALUE *argv, VALUE self) {
+  FXICOImage *arg1 = (FXICOImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOImage *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOImage * >(argp1);
+  FXICOImage_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_release(int argc, VALUE *argv, VALUE self) {
+  FXICOImage *arg1 = (FXICOImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOImage *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOImage * >(argp1);
+  FXICOImage_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_scale(int argc, VALUE *argv, VALUE self) {
+  FXICOImage *arg1 = (FXICOImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOImage *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXICOImage_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_mirror(int argc, VALUE *argv, VALUE self) {
+  FXICOImage *arg1 = (FXICOImage *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOImage *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOImage * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXICOImage_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_rotate(int argc, VALUE *argv, VALUE self) {
+  FXICOImage *arg1 = (FXICOImage *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOImage *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXICOImage_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_crop(int argc, VALUE *argv, VALUE self) {
+  FXICOImage *arg1 = (FXICOImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOImage *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXICOImage_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_fill(int argc, VALUE *argv, VALUE self) {
+  FXICOImage *arg1 = (FXICOImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOImage *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXICOImage_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_fade(int argc, VALUE *argv, VALUE self) {
+  FXICOImage *arg1 = (FXICOImage *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOImage *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXICOImage_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_xshear(int argc, VALUE *argv, VALUE self) {
+  FXICOImage *arg1 = (FXICOImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOImage *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXICOImage_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_yshear(int argc, VALUE *argv, VALUE self) {
+  FXICOImage *arg1 = (FXICOImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOImage *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXICOImage_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXICOImage *arg1 = (FXICOImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOImage *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXICOImage_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXICOImage *arg1 = (FXICOImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOImage *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXICOImage_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_gradient(int argc, VALUE *argv, VALUE self) {
+  FXICOImage *arg1 = (FXICOImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOImage *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXICOImage_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_blend(int argc, VALUE *argv, VALUE self) {
+  FXICOImage *arg1 = (FXICOImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOImage *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXICOImage_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXICOImage *arg1 = (FXICOImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOImage const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXICOImage_savePixels((FXICOImage const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXICOImage_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXICOImage *arg1 = (FXICOImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXICOImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXICOImage *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXICOImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXICOImage_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXJPGImage;
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXJPGImage_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXJPGImage_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_supported_Sq_(int argc, VALUE *argv, VALUE self) {
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (bool)FXJPGImage_isSupported();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXJPGImage_allocate(VALUE self)
+#else
+_wrap_FXJPGImage_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXJPGImage);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXJPGImage(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXuint arg3 = (FXuint) 0 ;
+  FXint arg4 = (FXint) 1 ;
+  FXint arg5 = (FXint) 1 ;
+  FXint arg6 = (FXint) 75 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXJPGImage *result = 0 ;
+  
+  if ((argc < 1) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXJPGImage", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      if (argv[1] != Qnil) {
+        Check_Type(argv[1], T_STRING);
+        arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
+      } else {
+        arg2 = NULL;
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXJPGImage *)new_FXJPGImage(arg1,(void const *)arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_setQuality(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage *","setQuality", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setQuality(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_getQuality(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage const *","getQuality", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  result = (FXint)((FXJPGImage const *)arg1)->getQuality();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_save(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXJPGImage_save((FXJPGImage const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_load(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXJPGImage_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_create(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  FXJPGImage_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_detach(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  FXJPGImage_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_destroy(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  FXJPGImage_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_resize(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXJPGImage_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_restore(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  FXJPGImage_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_render(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  FXJPGImage_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_release(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  FXJPGImage_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_scale(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXJPGImage_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_mirror(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXJPGImage_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_rotate(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXJPGImage_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_crop(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXJPGImage_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_fill(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXJPGImage_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_fade(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXJPGImage_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_xshear(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXJPGImage_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_yshear(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXJPGImage_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXJPGImage_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXJPGImage_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_gradient(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXJPGImage_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_blend(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXJPGImage_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXJPGImage_savePixels((FXJPGImage const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXJPGImage_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXJPGImage *arg1 = (FXJPGImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXJPGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXJPGImage *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXJPGImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXJPGImage_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXPCXImage;
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXPCXImage_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXPCXImage_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXPCXImage_allocate(VALUE self)
+#else
+_wrap_FXPCXImage_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXPCXImage);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXPCXImage(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXuint arg3 = (FXuint) 0 ;
+  FXint arg4 = (FXint) 1 ;
+  FXint arg5 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPCXImage *result = 0 ;
+  
+  if ((argc < 1) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXPCXImage", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      if (argv[1] != Qnil) {
+        Check_Type(argv[1], T_STRING);
+        arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
+      } else {
+        arg2 = NULL;
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXPCXImage *)new_FXPCXImage(arg1,(void const *)arg2,arg3,arg4,arg5);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_save(int argc, VALUE *argv, VALUE self) {
+  FXPCXImage *arg1 = (FXPCXImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXImage const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXPCXImage_save((FXPCXImage const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_load(int argc, VALUE *argv, VALUE self) {
+  FXPCXImage *arg1 = (FXPCXImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXImage *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXPCXImage_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_create(int argc, VALUE *argv, VALUE self) {
+  FXPCXImage *arg1 = (FXPCXImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXImage *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXImage * >(argp1);
+  FXPCXImage_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_detach(int argc, VALUE *argv, VALUE self) {
+  FXPCXImage *arg1 = (FXPCXImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXImage *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXImage * >(argp1);
+  FXPCXImage_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_destroy(int argc, VALUE *argv, VALUE self) {
+  FXPCXImage *arg1 = (FXPCXImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXImage *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXImage * >(argp1);
+  FXPCXImage_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_resize(int argc, VALUE *argv, VALUE self) {
+  FXPCXImage *arg1 = (FXPCXImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXImage *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXPCXImage_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_restore(int argc, VALUE *argv, VALUE self) {
+  FXPCXImage *arg1 = (FXPCXImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXImage *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXImage * >(argp1);
+  FXPCXImage_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_render(int argc, VALUE *argv, VALUE self) {
+  FXPCXImage *arg1 = (FXPCXImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXImage *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXImage * >(argp1);
+  FXPCXImage_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_release(int argc, VALUE *argv, VALUE self) {
+  FXPCXImage *arg1 = (FXPCXImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXImage *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXImage * >(argp1);
+  FXPCXImage_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_scale(int argc, VALUE *argv, VALUE self) {
+  FXPCXImage *arg1 = (FXPCXImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXImage *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXPCXImage_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_mirror(int argc, VALUE *argv, VALUE self) {
+  FXPCXImage *arg1 = (FXPCXImage *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXImage *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXImage * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXPCXImage_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_rotate(int argc, VALUE *argv, VALUE self) {
+  FXPCXImage *arg1 = (FXPCXImage *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXImage *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXPCXImage_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_crop(int argc, VALUE *argv, VALUE self) {
+  FXPCXImage *arg1 = (FXPCXImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXImage *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXPCXImage_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_fill(int argc, VALUE *argv, VALUE self) {
+  FXPCXImage *arg1 = (FXPCXImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXImage *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXPCXImage_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_fade(int argc, VALUE *argv, VALUE self) {
+  FXPCXImage *arg1 = (FXPCXImage *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXImage *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXPCXImage_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_xshear(int argc, VALUE *argv, VALUE self) {
+  FXPCXImage *arg1 = (FXPCXImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXImage *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXPCXImage_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_yshear(int argc, VALUE *argv, VALUE self) {
+  FXPCXImage *arg1 = (FXPCXImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXImage *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXPCXImage_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXPCXImage *arg1 = (FXPCXImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXImage *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXPCXImage_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXPCXImage *arg1 = (FXPCXImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXImage *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXPCXImage_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_gradient(int argc, VALUE *argv, VALUE self) {
+  FXPCXImage *arg1 = (FXPCXImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXImage *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXPCXImage_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_blend(int argc, VALUE *argv, VALUE self) {
+  FXPCXImage *arg1 = (FXPCXImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXImage *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXPCXImage_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXPCXImage *arg1 = (FXPCXImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXImage const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXPCXImage_savePixels((FXPCXImage const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPCXImage_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXPCXImage *arg1 = (FXPCXImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPCXImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPCXImage *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPCXImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXPCXImage_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXPNGImage;
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXPNGImage_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXPNGImage_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_supported_Sq_(int argc, VALUE *argv, VALUE self) {
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (bool)FXPNGImage_isSupported();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXPNGImage_allocate(VALUE self)
+#else
+_wrap_FXPNGImage_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXPNGImage);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXPNGImage(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXuint arg3 = (FXuint) 0 ;
+  FXint arg4 = (FXint) 1 ;
+  FXint arg5 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPNGImage *result = 0 ;
+  
+  if ((argc < 1) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXPNGImage", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      if (argv[1] != Qnil) {
+        Check_Type(argv[1], T_STRING);
+        arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
+      } else {
+        arg2 = NULL;
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXPNGImage *)new_FXPNGImage(arg1,(void const *)arg2,arg3,arg4,arg5);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_save(int argc, VALUE *argv, VALUE self) {
+  FXPNGImage *arg1 = (FXPNGImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGImage const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXPNGImage_save((FXPNGImage const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_load(int argc, VALUE *argv, VALUE self) {
+  FXPNGImage *arg1 = (FXPNGImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGImage *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXPNGImage_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_create(int argc, VALUE *argv, VALUE self) {
+  FXPNGImage *arg1 = (FXPNGImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGImage *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGImage * >(argp1);
+  FXPNGImage_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_detach(int argc, VALUE *argv, VALUE self) {
+  FXPNGImage *arg1 = (FXPNGImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGImage *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGImage * >(argp1);
+  FXPNGImage_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_destroy(int argc, VALUE *argv, VALUE self) {
+  FXPNGImage *arg1 = (FXPNGImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGImage *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGImage * >(argp1);
+  FXPNGImage_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_resize(int argc, VALUE *argv, VALUE self) {
+  FXPNGImage *arg1 = (FXPNGImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGImage *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXPNGImage_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_restore(int argc, VALUE *argv, VALUE self) {
+  FXPNGImage *arg1 = (FXPNGImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGImage *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGImage * >(argp1);
+  FXPNGImage_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_render(int argc, VALUE *argv, VALUE self) {
+  FXPNGImage *arg1 = (FXPNGImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGImage *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGImage * >(argp1);
+  FXPNGImage_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_release(int argc, VALUE *argv, VALUE self) {
+  FXPNGImage *arg1 = (FXPNGImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGImage *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGImage * >(argp1);
+  FXPNGImage_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_scale(int argc, VALUE *argv, VALUE self) {
+  FXPNGImage *arg1 = (FXPNGImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGImage *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXPNGImage_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_mirror(int argc, VALUE *argv, VALUE self) {
+  FXPNGImage *arg1 = (FXPNGImage *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGImage *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGImage * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXPNGImage_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_rotate(int argc, VALUE *argv, VALUE self) {
+  FXPNGImage *arg1 = (FXPNGImage *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGImage *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXPNGImage_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_crop(int argc, VALUE *argv, VALUE self) {
+  FXPNGImage *arg1 = (FXPNGImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGImage *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXPNGImage_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_fill(int argc, VALUE *argv, VALUE self) {
+  FXPNGImage *arg1 = (FXPNGImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGImage *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXPNGImage_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_fade(int argc, VALUE *argv, VALUE self) {
+  FXPNGImage *arg1 = (FXPNGImage *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGImage *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXPNGImage_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_xshear(int argc, VALUE *argv, VALUE self) {
+  FXPNGImage *arg1 = (FXPNGImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGImage *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXPNGImage_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_yshear(int argc, VALUE *argv, VALUE self) {
+  FXPNGImage *arg1 = (FXPNGImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGImage *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXPNGImage_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXPNGImage *arg1 = (FXPNGImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGImage *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXPNGImage_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXPNGImage *arg1 = (FXPNGImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGImage *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXPNGImage_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_gradient(int argc, VALUE *argv, VALUE self) {
+  FXPNGImage *arg1 = (FXPNGImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGImage *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXPNGImage_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_blend(int argc, VALUE *argv, VALUE self) {
+  FXPNGImage *arg1 = (FXPNGImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGImage *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXPNGImage_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXPNGImage *arg1 = (FXPNGImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGImage const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXPNGImage_savePixels((FXPNGImage const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPNGImage_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXPNGImage *arg1 = (FXPNGImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPNGImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPNGImage *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPNGImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXPNGImage_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXPPMImage;
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXPPMImage_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXPPMImage_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXPPMImage_allocate(VALUE self)
+#else
+_wrap_FXPPMImage_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXPPMImage);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXPPMImage(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXuint arg3 = (FXuint) 0 ;
+  FXint arg4 = (FXint) 1 ;
+  FXint arg5 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPPMImage *result = 0 ;
+  
+  if ((argc < 1) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXPPMImage", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      if (argv[1] != Qnil) {
+        Check_Type(argv[1], T_STRING);
+        arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
+      } else {
+        arg2 = NULL;
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXPPMImage *)new_FXPPMImage(arg1,(void const *)arg2,arg3,arg4,arg5);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_save(int argc, VALUE *argv, VALUE self) {
+  FXPPMImage *arg1 = (FXPPMImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMImage const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXPPMImage_save((FXPPMImage const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_load(int argc, VALUE *argv, VALUE self) {
+  FXPPMImage *arg1 = (FXPPMImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMImage *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXPPMImage_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_create(int argc, VALUE *argv, VALUE self) {
+  FXPPMImage *arg1 = (FXPPMImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMImage *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMImage * >(argp1);
+  FXPPMImage_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_detach(int argc, VALUE *argv, VALUE self) {
+  FXPPMImage *arg1 = (FXPPMImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMImage *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMImage * >(argp1);
+  FXPPMImage_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_destroy(int argc, VALUE *argv, VALUE self) {
+  FXPPMImage *arg1 = (FXPPMImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMImage *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMImage * >(argp1);
+  FXPPMImage_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_resize(int argc, VALUE *argv, VALUE self) {
+  FXPPMImage *arg1 = (FXPPMImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMImage *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXPPMImage_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_restore(int argc, VALUE *argv, VALUE self) {
+  FXPPMImage *arg1 = (FXPPMImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMImage *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMImage * >(argp1);
+  FXPPMImage_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_render(int argc, VALUE *argv, VALUE self) {
+  FXPPMImage *arg1 = (FXPPMImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMImage *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMImage * >(argp1);
+  FXPPMImage_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_release(int argc, VALUE *argv, VALUE self) {
+  FXPPMImage *arg1 = (FXPPMImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMImage *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMImage * >(argp1);
+  FXPPMImage_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_scale(int argc, VALUE *argv, VALUE self) {
+  FXPPMImage *arg1 = (FXPPMImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMImage *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXPPMImage_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_mirror(int argc, VALUE *argv, VALUE self) {
+  FXPPMImage *arg1 = (FXPPMImage *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMImage *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMImage * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXPPMImage_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_rotate(int argc, VALUE *argv, VALUE self) {
+  FXPPMImage *arg1 = (FXPPMImage *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMImage *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXPPMImage_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_crop(int argc, VALUE *argv, VALUE self) {
+  FXPPMImage *arg1 = (FXPPMImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMImage *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXPPMImage_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_fill(int argc, VALUE *argv, VALUE self) {
+  FXPPMImage *arg1 = (FXPPMImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMImage *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXPPMImage_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_fade(int argc, VALUE *argv, VALUE self) {
+  FXPPMImage *arg1 = (FXPPMImage *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMImage *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXPPMImage_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_xshear(int argc, VALUE *argv, VALUE self) {
+  FXPPMImage *arg1 = (FXPPMImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMImage *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXPPMImage_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_yshear(int argc, VALUE *argv, VALUE self) {
+  FXPPMImage *arg1 = (FXPPMImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMImage *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXPPMImage_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXPPMImage *arg1 = (FXPPMImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMImage *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXPPMImage_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXPPMImage *arg1 = (FXPPMImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMImage *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXPPMImage_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_gradient(int argc, VALUE *argv, VALUE self) {
+  FXPPMImage *arg1 = (FXPPMImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMImage *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXPPMImage_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_blend(int argc, VALUE *argv, VALUE self) {
+  FXPPMImage *arg1 = (FXPPMImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMImage *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXPPMImage_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXPPMImage *arg1 = (FXPPMImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMImage const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXPPMImage_savePixels((FXPPMImage const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPPMImage_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXPPMImage *arg1 = (FXPPMImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPPMImage *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPPMImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXPPMImage_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXRGBImage;
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXRGBImage_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXRGBImage_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXRGBImage_allocate(VALUE self)
+#else
+_wrap_FXRGBImage_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXRGBImage);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRGBImage(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXuint arg3 = (FXuint) 0 ;
+  FXint arg4 = (FXint) 1 ;
+  FXint arg5 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXRGBImage *result = 0 ;
+  
+  if ((argc < 1) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXRGBImage", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      if (argv[1] != Qnil) {
+        Check_Type(argv[1], T_STRING);
+        arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
+      } else {
+        arg2 = NULL;
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXRGBImage *)new_FXRGBImage(arg1,(void const *)arg2,arg3,arg4,arg5);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_save(int argc, VALUE *argv, VALUE self) {
+  FXRGBImage *arg1 = (FXRGBImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBImage const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXRGBImage_save((FXRGBImage const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_load(int argc, VALUE *argv, VALUE self) {
+  FXRGBImage *arg1 = (FXRGBImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBImage *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXRGBImage_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_create(int argc, VALUE *argv, VALUE self) {
+  FXRGBImage *arg1 = (FXRGBImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBImage *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBImage * >(argp1);
+  FXRGBImage_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_detach(int argc, VALUE *argv, VALUE self) {
+  FXRGBImage *arg1 = (FXRGBImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBImage *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBImage * >(argp1);
+  FXRGBImage_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_destroy(int argc, VALUE *argv, VALUE self) {
+  FXRGBImage *arg1 = (FXRGBImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBImage *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBImage * >(argp1);
+  FXRGBImage_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_resize(int argc, VALUE *argv, VALUE self) {
+  FXRGBImage *arg1 = (FXRGBImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBImage *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXRGBImage_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_restore(int argc, VALUE *argv, VALUE self) {
+  FXRGBImage *arg1 = (FXRGBImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBImage *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBImage * >(argp1);
+  FXRGBImage_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_render(int argc, VALUE *argv, VALUE self) {
+  FXRGBImage *arg1 = (FXRGBImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBImage *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBImage * >(argp1);
+  FXRGBImage_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_release(int argc, VALUE *argv, VALUE self) {
+  FXRGBImage *arg1 = (FXRGBImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBImage *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBImage * >(argp1);
+  FXRGBImage_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_scale(int argc, VALUE *argv, VALUE self) {
+  FXRGBImage *arg1 = (FXRGBImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBImage *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXRGBImage_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_mirror(int argc, VALUE *argv, VALUE self) {
+  FXRGBImage *arg1 = (FXRGBImage *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBImage *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBImage * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXRGBImage_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_rotate(int argc, VALUE *argv, VALUE self) {
+  FXRGBImage *arg1 = (FXRGBImage *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBImage *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXRGBImage_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_crop(int argc, VALUE *argv, VALUE self) {
+  FXRGBImage *arg1 = (FXRGBImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBImage *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXRGBImage_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_fill(int argc, VALUE *argv, VALUE self) {
+  FXRGBImage *arg1 = (FXRGBImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBImage *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXRGBImage_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_fade(int argc, VALUE *argv, VALUE self) {
+  FXRGBImage *arg1 = (FXRGBImage *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBImage *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXRGBImage_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_xshear(int argc, VALUE *argv, VALUE self) {
+  FXRGBImage *arg1 = (FXRGBImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBImage *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXRGBImage_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_yshear(int argc, VALUE *argv, VALUE self) {
+  FXRGBImage *arg1 = (FXRGBImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBImage *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXRGBImage_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXRGBImage *arg1 = (FXRGBImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBImage *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXRGBImage_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXRGBImage *arg1 = (FXRGBImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBImage *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXRGBImage_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_gradient(int argc, VALUE *argv, VALUE self) {
+  FXRGBImage *arg1 = (FXRGBImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBImage *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXRGBImage_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_blend(int argc, VALUE *argv, VALUE self) {
+  FXRGBImage *arg1 = (FXRGBImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBImage *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXRGBImage_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXRGBImage *arg1 = (FXRGBImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBImage const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXRGBImage_savePixels((FXRGBImage const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRGBImage_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXRGBImage *arg1 = (FXRGBImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRGBImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRGBImage *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRGBImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXRGBImage_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXTGAImage;
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXTGAImage_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXTGAImage_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXTGAImage_allocate(VALUE self)
+#else
+_wrap_FXTGAImage_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXTGAImage);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXTGAImage(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXuint arg3 = (FXuint) 0 ;
+  FXint arg4 = (FXint) 1 ;
+  FXint arg5 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTGAImage *result = 0 ;
+  
+  if ((argc < 1) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXTGAImage", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      if (argv[1] != Qnil) {
+        Check_Type(argv[1], T_STRING);
+        arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
+      } else {
+        arg2 = NULL;
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXTGAImage *)new_FXTGAImage(arg1,(void const *)arg2,arg3,arg4,arg5);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_save(int argc, VALUE *argv, VALUE self) {
+  FXTGAImage *arg1 = (FXTGAImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAImage const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTGAImage_save((FXTGAImage const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_load(int argc, VALUE *argv, VALUE self) {
+  FXTGAImage *arg1 = (FXTGAImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAImage *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTGAImage_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_create(int argc, VALUE *argv, VALUE self) {
+  FXTGAImage *arg1 = (FXTGAImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAImage *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAImage * >(argp1);
+  FXTGAImage_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_detach(int argc, VALUE *argv, VALUE self) {
+  FXTGAImage *arg1 = (FXTGAImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAImage *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAImage * >(argp1);
+  FXTGAImage_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_destroy(int argc, VALUE *argv, VALUE self) {
+  FXTGAImage *arg1 = (FXTGAImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAImage *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAImage * >(argp1);
+  FXTGAImage_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_resize(int argc, VALUE *argv, VALUE self) {
+  FXTGAImage *arg1 = (FXTGAImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAImage *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXTGAImage_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_restore(int argc, VALUE *argv, VALUE self) {
+  FXTGAImage *arg1 = (FXTGAImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAImage *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAImage * >(argp1);
+  FXTGAImage_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_render(int argc, VALUE *argv, VALUE self) {
+  FXTGAImage *arg1 = (FXTGAImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAImage *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAImage * >(argp1);
+  FXTGAImage_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_release(int argc, VALUE *argv, VALUE self) {
+  FXTGAImage *arg1 = (FXTGAImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAImage *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAImage * >(argp1);
+  FXTGAImage_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_scale(int argc, VALUE *argv, VALUE self) {
+  FXTGAImage *arg1 = (FXTGAImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAImage *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXTGAImage_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_mirror(int argc, VALUE *argv, VALUE self) {
+  FXTGAImage *arg1 = (FXTGAImage *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAImage *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAImage * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXTGAImage_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_rotate(int argc, VALUE *argv, VALUE self) {
+  FXTGAImage *arg1 = (FXTGAImage *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAImage *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXTGAImage_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_crop(int argc, VALUE *argv, VALUE self) {
+  FXTGAImage *arg1 = (FXTGAImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAImage *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXTGAImage_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_fill(int argc, VALUE *argv, VALUE self) {
+  FXTGAImage *arg1 = (FXTGAImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAImage *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXTGAImage_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_fade(int argc, VALUE *argv, VALUE self) {
+  FXTGAImage *arg1 = (FXTGAImage *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAImage *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXTGAImage_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_xshear(int argc, VALUE *argv, VALUE self) {
+  FXTGAImage *arg1 = (FXTGAImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAImage *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXTGAImage_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_yshear(int argc, VALUE *argv, VALUE self) {
+  FXTGAImage *arg1 = (FXTGAImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAImage *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXTGAImage_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXTGAImage *arg1 = (FXTGAImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAImage *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXTGAImage_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXTGAImage *arg1 = (FXTGAImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAImage *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXTGAImage_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_gradient(int argc, VALUE *argv, VALUE self) {
+  FXTGAImage *arg1 = (FXTGAImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAImage *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXTGAImage_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_blend(int argc, VALUE *argv, VALUE self) {
+  FXTGAImage *arg1 = (FXTGAImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAImage *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXTGAImage_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXTGAImage *arg1 = (FXTGAImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAImage const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXTGAImage_savePixels((FXTGAImage const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTGAImage_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXTGAImage *arg1 = (FXTGAImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTGAImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTGAImage *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTGAImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXTGAImage_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXTIFImage;
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXTIFImage_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXTIFImage_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_supported_Sq_(int argc, VALUE *argv, VALUE self) {
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (bool)FXTIFImage_isSupported();
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXTIFImage_allocate(VALUE self)
+#else
+_wrap_FXTIFImage_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXTIFImage);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXTIFImage(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXuint arg3 = (FXuint) 0 ;
+  FXint arg4 = (FXint) 1 ;
+  FXint arg5 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTIFImage *result = 0 ;
+  
+  if ((argc < 1) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXTIFImage", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      if (argv[1] != Qnil) {
+        Check_Type(argv[1], T_STRING);
+        arg2 = reinterpret_cast<void *>(RSTRING_PTR(argv[1]));
+      } else {
+        arg2 = NULL;
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXTIFImage *)new_FXTIFImage(arg1,(void const *)arg2,arg3,arg4,arg5);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_setCodec(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage *","setCodec", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setCodec(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_getCodec(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage const *","getCodec", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  result = (FXuint)((FXTIFImage const *)arg1)->getCodec();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_save(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTIFImage_save((FXTIFImage const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_load(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTIFImage_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_create(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  FXTIFImage_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_detach(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  FXTIFImage_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_destroy(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  FXTIFImage_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_resize(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXTIFImage_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_restore(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  FXTIFImage_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_render(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  FXTIFImage_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_release(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  FXTIFImage_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_scale(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXTIFImage_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_mirror(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXTIFImage_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_rotate(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXTIFImage_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_crop(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXTIFImage_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_fill(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXTIFImage_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_fade(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXTIFImage_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_xshear(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXTIFImage_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_yshear(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXTIFImage_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXTIFImage_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXTIFImage_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_gradient(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXTIFImage_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_blend(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXTIFImage_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXTIFImage_savePixels((FXTIFImage const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTIFImage_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXTIFImage *arg1 = (FXTIFImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTIFImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTIFImage *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTIFImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXTIFImage_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxloadTIF(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxloadTIF", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxloadTIF", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (VALUE)fxloadTIF(*arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxsaveTIF(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  FXColor *arg2 = (FXColor *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXushort arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 5) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxsaveTIF", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxsaveTIF", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  {
+    arg2=NULL;
+    if(argv[1]!=Qnil){
+      Check_Type(argv[1],T_ARRAY);
+      if(FXMALLOC(&arg2,FXColor,RARRAY_LEN(argv[1]))){
+        for(long i=0; i<RARRAY_LEN(argv[1]); i++){
+          arg2[i]=static_cast<FXColor>(NUM2UINT(rb_ary_entry(argv[1],i)));
+        }
+      }
+    }
+  }
+  arg3 = NUM2INT(argv[2]);
+  arg4 = NUM2INT(argv[3]);
+  arg5 = NUM2UINT(argv[4]);
+  result = (bool)fxsaveTIF(*arg1,(unsigned int const *)arg2,arg3,arg4,arg5);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  FXFREE(&arg2);
+  return vresult;
+fail:
+  FXFREE(&arg2);
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXXBMImage;
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXXBMImage_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXXBMImage_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXXBMImage_allocate(VALUE self)
+#else
+_wrap_FXXBMImage_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXXBMImage);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXXBMImage(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuchar *arg2 = (FXuchar *) 0 ;
+  FXuchar *arg3 = (FXuchar *) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 1 ;
+  FXint arg6 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXXBMImage *result = 0 ;
+  
+  if ((argc < 1) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXXBMImage", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXuchar const *","FXXBMImage", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXuchar * >(argp2);
+  }
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXuchar const *","FXXBMImage", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXuchar * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXXBMImage *)new_FXXBMImage(arg1,(unsigned char const *)arg2,(unsigned char const *)arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_save(int argc, VALUE *argv, VALUE self) {
+  FXXBMImage *arg1 = (FXXBMImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMImage const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXXBMImage_save((FXXBMImage const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_load(int argc, VALUE *argv, VALUE self) {
+  FXXBMImage *arg1 = (FXXBMImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMImage *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXXBMImage_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_create(int argc, VALUE *argv, VALUE self) {
+  FXXBMImage *arg1 = (FXXBMImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMImage *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMImage * >(argp1);
+  FXXBMImage_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_detach(int argc, VALUE *argv, VALUE self) {
+  FXXBMImage *arg1 = (FXXBMImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMImage *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMImage * >(argp1);
+  FXXBMImage_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_destroy(int argc, VALUE *argv, VALUE self) {
+  FXXBMImage *arg1 = (FXXBMImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMImage *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMImage * >(argp1);
+  FXXBMImage_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_resize(int argc, VALUE *argv, VALUE self) {
+  FXXBMImage *arg1 = (FXXBMImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMImage *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXXBMImage_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_restore(int argc, VALUE *argv, VALUE self) {
+  FXXBMImage *arg1 = (FXXBMImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMImage *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMImage * >(argp1);
+  FXXBMImage_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_render(int argc, VALUE *argv, VALUE self) {
+  FXXBMImage *arg1 = (FXXBMImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMImage *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMImage * >(argp1);
+  FXXBMImage_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_release(int argc, VALUE *argv, VALUE self) {
+  FXXBMImage *arg1 = (FXXBMImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMImage *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMImage * >(argp1);
+  FXXBMImage_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_scale(int argc, VALUE *argv, VALUE self) {
+  FXXBMImage *arg1 = (FXXBMImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMImage *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXXBMImage_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_mirror(int argc, VALUE *argv, VALUE self) {
+  FXXBMImage *arg1 = (FXXBMImage *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMImage *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMImage * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXXBMImage_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_rotate(int argc, VALUE *argv, VALUE self) {
+  FXXBMImage *arg1 = (FXXBMImage *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMImage *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXXBMImage_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_crop(int argc, VALUE *argv, VALUE self) {
+  FXXBMImage *arg1 = (FXXBMImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMImage *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXXBMImage_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_fill(int argc, VALUE *argv, VALUE self) {
+  FXXBMImage *arg1 = (FXXBMImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMImage *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXXBMImage_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_fade(int argc, VALUE *argv, VALUE self) {
+  FXXBMImage *arg1 = (FXXBMImage *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMImage *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXXBMImage_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_xshear(int argc, VALUE *argv, VALUE self) {
+  FXXBMImage *arg1 = (FXXBMImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMImage *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXXBMImage_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_yshear(int argc, VALUE *argv, VALUE self) {
+  FXXBMImage *arg1 = (FXXBMImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMImage *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXXBMImage_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXXBMImage *arg1 = (FXXBMImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMImage *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXXBMImage_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXXBMImage *arg1 = (FXXBMImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMImage *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXXBMImage_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_gradient(int argc, VALUE *argv, VALUE self) {
+  FXXBMImage *arg1 = (FXXBMImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMImage *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXXBMImage_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_blend(int argc, VALUE *argv, VALUE self) {
+  FXXBMImage *arg1 = (FXXBMImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMImage *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXXBMImage_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXXBMImage *arg1 = (FXXBMImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMImage const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXXBMImage_savePixels((FXXBMImage const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXBMImage_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXXBMImage *arg1 = (FXXBMImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXBMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXBMImage *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXBMImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXXBMImage_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxloadXBM__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXuchar *arg1 = (FXuchar *) 0 ;
+  FXuchar *arg2 = (FXuchar *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXuchar const *","fxloadXBM", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXuchar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXuchar const *","fxloadXBM", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXuchar * >(argp2);
+  arg3 = NUM2INT(argv[2]);
+  arg4 = NUM2INT(argv[3]);
+  result = (VALUE)fxloadXBM((unsigned char const *)arg1,(unsigned char const *)arg2,arg3,arg4);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxloadXBM__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxloadXBM", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxloadXBM", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (VALUE)fxloadXBM(*arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_fxloadXBM(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[4];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 4) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXStream, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_fxloadXBM__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_char, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_fxloadXBM__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 4, "fxloadXBM", 
+    "    VALUE fxloadXBM(FXuchar const *pix, FXuchar const *msk, FXint width, FXint height)\n"
+    "    VALUE fxloadXBM(FXStream &store)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxsaveXBM(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  FXColor *arg2 = (FXColor *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 = (FXint) -1 ;
+  FXint arg6 = (FXint) -1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxsaveXBM", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxsaveXBM", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  {
+    arg2=NULL;
+    if(argv[1]!=Qnil){
+      Check_Type(argv[1],T_ARRAY);
+      if(FXMALLOC(&arg2,FXColor,RARRAY_LEN(argv[1]))){
+        for(long i=0; i<RARRAY_LEN(argv[1]); i++){
+          arg2[i]=static_cast<FXColor>(NUM2UINT(rb_ary_entry(argv[1],i)));
+        }
+      }
+    }
+  }
+  arg3 = NUM2INT(argv[2]);
+  arg4 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  result = (bool)fxsaveXBM(*arg1,(unsigned int const *)arg2,arg3,arg4,arg5,arg6);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  FXFREE(&arg2);
+  return vresult;
+fail:
+  FXFREE(&arg2);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxsavePS(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  FXColor *arg2 = (FXColor *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 = (FXint) 612 ;
+  FXint arg6 = (FXint) 792 ;
+  FXint arg7 = (FXint) 35 ;
+  FXbool arg8 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxsavePS", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxsavePS", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  {
+    arg2=NULL;
+    if(argv[1]!=Qnil){
+      Check_Type(argv[1],T_ARRAY);
+      if(FXMALLOC(&arg2,FXColor,RARRAY_LEN(argv[1]))){
+        for(long i=0; i<RARRAY_LEN(argv[1]); i++){
+          arg2[i]=static_cast<FXColor>(NUM2UINT(rb_ary_entry(argv[1],i)));
+        }
+      }
+    }
+  }
+  arg3 = NUM2INT(argv[2]);
+  arg4 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = to_FXbool(argv[7]);
+  }
+  result = (bool)fxsavePS(*arg1,(unsigned int const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  FXFREE(&arg2);
+  return vresult;
+fail:
+  FXFREE(&arg2);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_fxcheckXBM(int argc, VALUE *argv, VALUE self) {
+  FXStream *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStream &","fxcheckXBM", 1, argv[0] )); 
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","fxcheckXBM", 1, argv[0])); 
+  }
+  arg1 = reinterpret_cast< FXStream * >(argp1);
+  result = (bool)fxcheckXBM(*arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXXPMImage;
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_fileExt(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXXPMImage_fileExt();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_mimeType(int argc, VALUE *argv, VALUE self) {
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (VALUE)FXXPMImage_mimeType();
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXXPMImage_allocate(VALUE self)
+#else
+_wrap_FXXPMImage_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXXPMImage);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXXPMImage(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXchar **arg2 = (FXchar **) 0 ;
+  FXuint arg3 = (FXuint) 0 ;
+  FXint arg4 = (FXint) 1 ;
+  FXint arg5 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXXPMImage *result = 0 ;
+  
+  if ((argc < 1) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXXPMImage", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    {
+      arg2 = NULL;
+      if (argv[1] != Qnil) {
+        Check_Type(argv[1], T_ARRAY);
+        if (FXMALLOC(&arg2, FXchar *, RARRAY_LEN(argv[1]))) {
+          for (long i = 0; i < RARRAY_LEN(argv[1]); i++) {
+            VALUE e = rb_ary_entry(argv[1], i);
+            arg2[i] = (FXchar *) StringValuePtr(e);
+          }
+        }
+      }
+    }
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXXPMImage *)new_FXXPMImage(arg1,(char const **)arg2,arg3,arg4,arg5);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  FXFREE(&arg2);
+  return self;
+fail:
+  FXFREE(&arg2);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_save(int argc, VALUE *argv, VALUE self) {
+  FXXPMImage *arg1 = (FXXPMImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMImage const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXXPMImage_save((FXXPMImage const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_load(int argc, VALUE *argv, VALUE self) {
+  FXXPMImage *arg1 = (FXXPMImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMImage *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXXPMImage_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_create(int argc, VALUE *argv, VALUE self) {
+  FXXPMImage *arg1 = (FXXPMImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMImage *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMImage * >(argp1);
+  FXXPMImage_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_detach(int argc, VALUE *argv, VALUE self) {
+  FXXPMImage *arg1 = (FXXPMImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMImage *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMImage * >(argp1);
+  FXXPMImage_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_destroy(int argc, VALUE *argv, VALUE self) {
+  FXXPMImage *arg1 = (FXXPMImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMImage *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMImage * >(argp1);
+  FXXPMImage_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_resize(int argc, VALUE *argv, VALUE self) {
+  FXXPMImage *arg1 = (FXXPMImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMImage *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXXPMImage_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_restore(int argc, VALUE *argv, VALUE self) {
+  FXXPMImage *arg1 = (FXXPMImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMImage *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMImage * >(argp1);
+  FXXPMImage_restore(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_render(int argc, VALUE *argv, VALUE self) {
+  FXXPMImage *arg1 = (FXXPMImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMImage *","render", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMImage * >(argp1);
+  FXXPMImage_render(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_release(int argc, VALUE *argv, VALUE self) {
+  FXXPMImage *arg1 = (FXXPMImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMImage *","release", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMImage * >(argp1);
+  FXXPMImage_release(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_scale(int argc, VALUE *argv, VALUE self) {
+  FXXPMImage *arg1 = (FXXPMImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMImage *","scale", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  FXXPMImage_scale(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_mirror(int argc, VALUE *argv, VALUE self) {
+  FXXPMImage *arg1 = (FXXPMImage *) 0 ;
+  bool arg2 ;
+  bool arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool val2 ;
+  int ecode2 = 0 ;
+  bool val3 ;
+  int ecode3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMImage *","mirror", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMImage * >(argp1);
+  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mirror", 2, argv[0] ));
+  } 
+  arg2 = static_cast< bool >(val2);
+  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","mirror", 3, argv[1] ));
+  } 
+  arg3 = static_cast< bool >(val3);
+  FXXPMImage_mirror(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_rotate(int argc, VALUE *argv, VALUE self) {
+  FXXPMImage *arg1 = (FXXPMImage *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMImage *","rotate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXXPMImage_rotate(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_crop(int argc, VALUE *argv, VALUE self) {
+  FXXPMImage *arg1 = (FXXPMImage *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXColor arg6 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMImage *","crop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXColor(argv[4]);
+  }
+  FXXPMImage_crop(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_fill(int argc, VALUE *argv, VALUE self) {
+  FXXPMImage *arg1 = (FXXPMImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMImage *","fill", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXXPMImage_fill(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_fade(int argc, VALUE *argv, VALUE self) {
+  FXXPMImage *arg1 = (FXXPMImage *) 0 ;
+  FXColor arg2 ;
+  FXint arg3 = (FXint) 255 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMImage *","fade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXXPMImage_fade(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_xshear(int argc, VALUE *argv, VALUE self) {
+  FXXPMImage *arg1 = (FXXPMImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMImage *","xshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXXPMImage_xshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_yshear(int argc, VALUE *argv, VALUE self) {
+  FXXPMImage *arg1 = (FXXPMImage *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMImage *","yshear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMImage * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  FXXPMImage_yshear(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_hgradient(int argc, VALUE *argv, VALUE self) {
+  FXXPMImage *arg1 = (FXXPMImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMImage *","hgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXXPMImage_hgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_vgradient(int argc, VALUE *argv, VALUE self) {
+  FXXPMImage *arg1 = (FXXPMImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMImage *","vgradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  FXXPMImage_vgradient(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_gradient(int argc, VALUE *argv, VALUE self) {
+  FXXPMImage *arg1 = (FXXPMImage *) 0 ;
+  FXColor arg2 ;
+  FXColor arg3 ;
+  FXColor arg4 ;
+  FXColor arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMImage *","gradient", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  arg5 = to_FXColor(argv[3]);
+  FXXPMImage_gradient(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_blend(int argc, VALUE *argv, VALUE self) {
+  FXXPMImage *arg1 = (FXXPMImage *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMImage *","blend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMImage * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXXPMImage_blend(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_savePixels(int argc, VALUE *argv, VALUE self) {
+  FXXPMImage *arg1 = (FXXPMImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMImage const *","savePixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","savePixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","savePixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXXPMImage_savePixels((FXXPMImage const *)arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXXPMImage_loadPixels(int argc, VALUE *argv, VALUE self) {
+  FXXPMImage *arg1 = (FXXPMImage *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXXPMImage, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXXPMImage *","loadPixels", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXXPMImage * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","loadPixels", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","loadPixels", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  result = (bool)FXXPMImage_loadPixels(arg1,*arg2);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_FXGradientBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShutterItemTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXRGBImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXRGBImage *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXBMPImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXBMPImage *) x));
+}
+static void *_p_FXMatrixTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXDrawableTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXDrawable *) x));
+}
+static void *_p_FXPCXImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXPCXImage *) x));
+}
+static void *_p_FXHeaderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXSplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSpringTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXProgressBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXTGAImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXTGAImage *) x));
+}
+static void *_p_FXToolTipTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXICOImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXICOImage *) x));
+}
+static void *_p_FXRealSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXDockSiteTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXPPMImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXPPMImage *) x));
+}
+static void *_p_FXXBMImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXXBMImage *) x));
+}
+static void *_p_FXXPMImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXXPMImage *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXCanvasTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXColorWheelTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXVisualTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXVisual *) x));
+}
+static void *_p_FXScrollBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXFontTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXFont *) x));
+}
+static void *_p_FXComboBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *) ((FXImage *) x));
+}
+static void *_p_FXFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXJPGImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXJPGImage *) x));
+}
+static void *_p_FXPNGImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXPNGImage *) x));
+}
+static void *_p_FXGIFImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXGIFImage *) x));
+}
+static void *_p_FXTIFImageTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXImage *) ((FXTIFImage *) x));
+}
+static void *_p_FXStatusBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXCursor *) x));
+}
+static void *_p_FXKnobTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRulerViewTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXStatusLineTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXMainWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXDockBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXBitmapTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *) ((FXBitmap *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXToolBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDirBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXDocumentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDocument *) x));
+}
+static void *_p_FXGradientBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXRegistryTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *)(FXSettings *) ((FXRegistry *) x));
+}
+static void *_p_FXHeaderItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXHeaderItem *) x));
+}
+static void *_p_FXShutterItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXRGBImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXRGBImage *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXIconDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXIconDict *) x));
+}
+static void *_p_FXBMPImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXBMPImage *) x));
+}
+static void *_p_FXMatrixTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXFileDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXFileDict *) x));
+}
+static void *_p_FXRecentFilesTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXRecentFiles *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXDrawableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXDrawable *) x));
+}
+static void *_p_FXPCXImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXPCXImage *) x));
+}
+static void *_p_FXAppTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXApp *) x));
+}
+static void *_p_FXHeaderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXTranslatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXTranslator *) x));
+}
+static void *_p_FX4SplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FXSpringTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXIdTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXId *) x));
+}
+static void *_p_FXProgressBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXTGAImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXTGAImage *) x));
+}
+static void *_p_FXToolTipTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXICOImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXICOImage *) x));
+}
+static void *_p_FXRealSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXSettingsTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXSettings *) x));
+}
+static void *_p_FXDockSiteTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDebugTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDebugTarget *) x));
+}
+static void *_p_FXDataTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDataTarget *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXPPMImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXPPMImage *) x));
+}
+static void *_p_FXXBMImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXXBMImage *) x));
+}
+static void *_p_FXXPMImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXXPMImage *) x));
+}
+static void *_p_FXCanvasTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXListBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXColorWheelTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXVisualTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXVisual *) x));
+}
+static void *_p_FXScrollBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXFontTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXFont *) x));
+}
+static void *_p_FXComboBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *) ((FXImage *) x));
+}
+static void *_p_FXFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXJPGImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXJPGImage *) x));
+}
+static void *_p_FXPNGImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXPNGImage *) x));
+}
+static void *_p_FXGIFImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXGIFImage *) x));
+}
+static void *_p_FXTIFImageTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXImage *) ((FXTIFImage *) x));
+}
+static void *_p_FXStringDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXStringDict *) x));
+}
+static void *_p_FXStatusBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXDelegatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDelegator *) x));
+}
+static void *_p_FXAccelTableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXAccelTable *) x));
+}
+static void *_p_FXCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXKnobTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRulerViewTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXStatusLineTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXDockBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDict *) x));
+}
+static void *_p_FXShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXBitmapTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *) ((FXBitmap *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXToolBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDirBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXGradientBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShutterItemTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXRGBImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXRGBImage *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXBMPImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXBMPImage *) x));
+}
+static void *_p_FXMatrixTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXPCXImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXPCXImage *) x));
+}
+static void *_p_FXHeaderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXSplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSpringTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXProgressBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXTGAImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXTGAImage *) x));
+}
+static void *_p_FXToolTipTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXICOImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXICOImage *) x));
+}
+static void *_p_FXRealSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXDockSiteTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXPPMImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXPPMImage *) x));
+}
+static void *_p_FXXBMImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXXBMImage *) x));
+}
+static void *_p_FXXPMImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXXPMImage *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXCanvasTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXColorWheelTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXScrollBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXComboBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *)  ((FXImage *) x));
+}
+static void *_p_FXFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXJPGImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXJPGImage *) x));
+}
+static void *_p_FXPNGImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXPNGImage *) x));
+}
+static void *_p_FXGIFImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXGIFImage *) x));
+}
+static void *_p_FXTIFImageTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXImage *) ((FXTIFImage *) x));
+}
+static void *_p_FXStatusBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXKnobTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXRulerViewTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXStatusLineTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *)  ((FXWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXDockBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXBitmapTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *)  ((FXBitmap *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXToolBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXDirBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXFileStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXFileStream *) x));
+}
+static void *_p_FXMemoryStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXMemoryStream *) x));
+}
+static void *_p_FXBMPImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXBMPImage *) x));
+}
+static void *_p_FXPPMImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXPPMImage *) x));
+}
+static void *_p_FXRGBImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXRGBImage *) x));
+}
+static void *_p_FXXBMImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXXBMImage *) x));
+}
+static void *_p_FXXPMImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXXPMImage *) x));
+}
+static void *_p_FXGIFImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXGIFImage *) x));
+}
+static void *_p_FXTIFImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXTIFImage *) x));
+}
+static void *_p_FXJPGImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXJPGImage *) x));
+}
+static void *_p_FXPCXImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXPCXImage *) x));
+}
+static void *_p_FXPNGImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXPNGImage *) x));
+}
+static void *_p_FXICOImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXICOImage *) x));
+}
+static void *_p_FXTGAImageTo_p_FXImage(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXImage *)  ((FXTGAImage *) x));
+}
+static swig_type_info _swigt__p_FXApp = {"_p_FXApp", "FXApp *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXBMPImage = {"_p_FXBMPImage", "FXBMPImage *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXBitmap = {"_p_FXBitmap", "FXBitmap *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDrawable = {"_p_FXDrawable", "FXDrawable *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGradientBar = {"_p_FXGradientBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutterItem = {"_p_FXShutterItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorBar = {"_p_FXColorBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTabBar = {"_p_FXTabBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSwitcher = {"_p_FXSwitcher", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTextField = {"_p_FXTextField", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarTab = {"_p_FXToolBarTab", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDriveBox = {"_p_FXDriveBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMatrix = {"_p_FXMatrix", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollCorner = {"_p_FXScrollCorner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXArrowButton = {"_p_FXArrowButton", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPopup = {"_p_FXPopup", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHeader = {"_p_FXHeader", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplitter = {"_p_FXSplitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FX4Splitter = {"_p_FX4Splitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSpring = {"_p_FXSpring", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPacker = {"_p_FXPacker", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTabBook = {"_p_FXTabBook", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImageFrame = {"_p_FXImageFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalSeparator = {"_p_FXVerticalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalSeparator = {"_p_FXHorizontalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSeparator = {"_p_FXSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXKnob = {"_p_FXKnob", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXProgressBar = {"_p_FXProgressBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutter = {"_p_FXShutter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolTip = {"_p_FXToolTip", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXComposite = {"_p_FXComposite", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXBitmapFrame = {"_p_FXBitmapFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRealSlider = {"_p_FXRealSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSlider = {"_p_FXSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockSite = {"_p_FXDockSite", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGroupBox = {"_p_FXGroupBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorRing = {"_p_FXColorRing", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockHandler = {"_p_FXDockHandler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTreeListBox = {"_p_FXTreeListBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXListBox = {"_p_FXListBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCanvas = {"_p_FXCanvas", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWheel = {"_p_FXColorWheel", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDial = {"_p_FXDial", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarGrip = {"_p_FXToolBarGrip", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollBar = {"_p_FXScrollBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXComboBox = {"_p_FXComboBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFrame = {"_p_FXFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FX7Segment = {"_p_FX7Segment", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockTitle = {"_p_FXDockTitle", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusBar = {"_p_FXStatusBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRulerView = {"_p_FXRulerView", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRealSpinner = {"_p_FXRealSpinner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSpinner = {"_p_FXSpinner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusLine = {"_p_FXStatusLine", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplashWindow = {"_p_FXSplashWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMainWindow = {"_p_FXMainWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTopWindow = {"_p_FXTopWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRootWindow = {"_p_FXRootWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXWindow = {"_p_FXWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollWindow = {"_p_FXScrollWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockBar = {"_p_FXDockBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShell = {"_p_FXShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollArea = {"_p_FXScrollArea", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWell = {"_p_FXColorWell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDragCorner = {"_p_FXDragCorner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRuler = {"_p_FXRuler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalFrame = {"_p_FXVerticalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalFrame = {"_p_FXHorizontalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImageView = {"_p_FXImageView", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFontSelector = {"_p_FXFontSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorSelector = {"_p_FXColorSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileSelector = {"_p_FXFileSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDirSelector = {"_p_FXDirSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarShell = {"_p_FXToolBarShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBar = {"_p_FXToolBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDirBox = {"_p_FXDirBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGIFImage = {"_p_FXGIFImage", "FXGIFImage *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXICOImage = {"_p_FXICOImage", "FXICOImage *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXId = {"_p_FXId", "FXId *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFont = {"_p_FXFont", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVisual = {"_p_FXVisual", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCursor = {"_p_FXCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCURCursor = {"_p_FXCURCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGIFCursor = {"_p_FXGIFCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImage = {"_p_FXImage", "FXImage *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXJPGImage = {"_p_FXJPGImage", "FXJPGImage *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMemoryBuffer = {"_p_FXMemoryBuffer", "FXMemoryBuffer *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXObject = {"_p_FXObject", "FXObject *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDocument = {"_p_FXDocument", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRegistry = {"_p_FXRegistry", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHeaderItem = {"_p_FXHeaderItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXIconDict = {"_p_FXIconDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileDict = {"_p_FXFileDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRecentFiles = {"_p_FXRecentFiles", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTranslator = {"_p_FXTranslator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDict = {"_p_FXDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSettings = {"_p_FXSettings", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDataTarget = {"_p_FXDataTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDebugTarget = {"_p_FXDebugTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStringDict = {"_p_FXStringDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDelegator = {"_p_FXDelegator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXAccelTable = {"_p_FXAccelTable", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPCXImage = {"_p_FXPCXImage", "FXPCXImage *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXPNGImage = {"_p_FXPNGImage", "FXPNGImage *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXPPMImage = {"_p_FXPPMImage", "FXPPMImage *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRGBImage = {"_p_FXRGBImage", "FXRGBImage *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXStream = {"_p_FXStream", "FXStream *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFileStream = {"_p_FXFileStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMemoryStream = {"_p_FXMemoryStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTGAImage = {"_p_FXTGAImage", "FXTGAImage *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXTIFImage = {"_p_FXTIFImage", "FXTIFImage *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXXBMImage = {"_p_FXXBMImage", "FXXBMImage *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXXPMImage = {"_p_FXXPMImage", "FXXPMImage *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_char = {"_p_char", "char *|FXchar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "double *|FXdouble *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_float = {"_p_float", "float *|FXfloat *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "FXint *|int *|FXInputHandle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_long = {"_p_long", "long *|FXTime *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **|FXchar **", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_short = {"_p_short", "short *|FXshort *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "FXuchar *|unsigned char *|FXbool *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "FXwchar *|FXDragType *|unsigned int *|FXuint *|FXColor *|FXSelector *|FXHotKey *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|FXuval *|FXPixel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|FXushort *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_FX4Splitter,
+  &_swigt__p_FX7Segment,
+  &_swigt__p_FXAccelTable,
+  &_swigt__p_FXApp,
+  &_swigt__p_FXArrowButton,
+  &_swigt__p_FXBMPImage,
+  &_swigt__p_FXBitmap,
+  &_swigt__p_FXBitmapFrame,
+  &_swigt__p_FXCURCursor,
+  &_swigt__p_FXCanvas,
+  &_swigt__p_FXColorBar,
+  &_swigt__p_FXColorRing,
+  &_swigt__p_FXColorSelector,
+  &_swigt__p_FXColorWell,
+  &_swigt__p_FXColorWheel,
+  &_swigt__p_FXComboBox,
+  &_swigt__p_FXComposite,
+  &_swigt__p_FXCursor,
+  &_swigt__p_FXDataTarget,
+  &_swigt__p_FXDebugTarget,
+  &_swigt__p_FXDelegator,
+  &_swigt__p_FXDial,
+  &_swigt__p_FXDict,
+  &_swigt__p_FXDirBox,
+  &_swigt__p_FXDirSelector,
+  &_swigt__p_FXDockBar,
+  &_swigt__p_FXDockHandler,
+  &_swigt__p_FXDockSite,
+  &_swigt__p_FXDockTitle,
+  &_swigt__p_FXDocument,
+  &_swigt__p_FXDragCorner,
+  &_swigt__p_FXDrawable,
+  &_swigt__p_FXDriveBox,
+  &_swigt__p_FXFileDict,
+  &_swigt__p_FXFileSelector,
+  &_swigt__p_FXFileStream,
+  &_swigt__p_FXFont,
+  &_swigt__p_FXFontSelector,
+  &_swigt__p_FXFrame,
+  &_swigt__p_FXGIFCursor,
+  &_swigt__p_FXGIFImage,
+  &_swigt__p_FXGradientBar,
+  &_swigt__p_FXGroupBox,
+  &_swigt__p_FXHeader,
+  &_swigt__p_FXHeaderItem,
+  &_swigt__p_FXHorizontalFrame,
+  &_swigt__p_FXHorizontalSeparator,
+  &_swigt__p_FXICOImage,
+  &_swigt__p_FXIconDict,
+  &_swigt__p_FXId,
+  &_swigt__p_FXImage,
+  &_swigt__p_FXImageFrame,
+  &_swigt__p_FXImageView,
+  &_swigt__p_FXJPGImage,
+  &_swigt__p_FXKnob,
+  &_swigt__p_FXListBox,
+  &_swigt__p_FXMainWindow,
+  &_swigt__p_FXMatrix,
+  &_swigt__p_FXMemoryBuffer,
+  &_swigt__p_FXMemoryStream,
+  &_swigt__p_FXObject,
+  &_swigt__p_FXPCXImage,
+  &_swigt__p_FXPNGImage,
+  &_swigt__p_FXPPMImage,
+  &_swigt__p_FXPacker,
+  &_swigt__p_FXPopup,
+  &_swigt__p_FXProgressBar,
+  &_swigt__p_FXRGBImage,
+  &_swigt__p_FXRealSlider,
+  &_swigt__p_FXRealSpinner,
+  &_swigt__p_FXRecentFiles,
+  &_swigt__p_FXRegistry,
+  &_swigt__p_FXRootWindow,
+  &_swigt__p_FXRuler,
+  &_swigt__p_FXRulerView,
+  &_swigt__p_FXScrollArea,
+  &_swigt__p_FXScrollBar,
+  &_swigt__p_FXScrollCorner,
+  &_swigt__p_FXScrollWindow,
+  &_swigt__p_FXSeparator,
+  &_swigt__p_FXSettings,
+  &_swigt__p_FXShell,
+  &_swigt__p_FXShutter,
+  &_swigt__p_FXShutterItem,
+  &_swigt__p_FXSlider,
+  &_swigt__p_FXSpinner,
+  &_swigt__p_FXSplashWindow,
+  &_swigt__p_FXSplitter,
+  &_swigt__p_FXSpring,
+  &_swigt__p_FXStatusBar,
+  &_swigt__p_FXStatusLine,
+  &_swigt__p_FXStream,
+  &_swigt__p_FXStringDict,
+  &_swigt__p_FXSwitcher,
+  &_swigt__p_FXTGAImage,
+  &_swigt__p_FXTIFImage,
+  &_swigt__p_FXTabBar,
+  &_swigt__p_FXTabBook,
+  &_swigt__p_FXTextField,
+  &_swigt__p_FXToolBar,
+  &_swigt__p_FXToolBarGrip,
+  &_swigt__p_FXToolBarShell,
+  &_swigt__p_FXToolBarTab,
+  &_swigt__p_FXToolTip,
+  &_swigt__p_FXTopWindow,
+  &_swigt__p_FXTranslator,
+  &_swigt__p_FXTreeListBox,
+  &_swigt__p_FXVerticalFrame,
+  &_swigt__p_FXVerticalSeparator,
+  &_swigt__p_FXVisual,
+  &_swigt__p_FXWindow,
+  &_swigt__p_FXXBMImage,
+  &_swigt__p_FXXPMImage,
+  &_swigt__p_char,
+  &_swigt__p_double,
+  &_swigt__p_float,
+  &_swigt__p_int,
+  &_swigt__p_long,
+  &_swigt__p_p_char,
+  &_swigt__p_short,
+  &_swigt__p_unsigned_char,
+  &_swigt__p_unsigned_int,
+  &_swigt__p_unsigned_long,
+  &_swigt__p_unsigned_short,
+};
+
+static swig_cast_info _swigc__p_FXApp[] = {  {&_swigt__p_FXApp, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBMPImage[] = {  {&_swigt__p_FXBMPImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBitmap[] = {  {&_swigt__p_FXBitmap, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGradientBar[] = {{&_swigt__p_FXGradientBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutterItem[] = {{&_swigt__p_FXShutterItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorBar[] = {{&_swigt__p_FXColorBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabBar[] = {{&_swigt__p_FXTabBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSwitcher[] = {{&_swigt__p_FXSwitcher, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTextField[] = {{&_swigt__p_FXTextField, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarTab[] = {{&_swigt__p_FXToolBarTab, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDriveBox[] = {{&_swigt__p_FXDriveBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMatrix[] = {{&_swigt__p_FXMatrix, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollCorner[] = {{&_swigt__p_FXScrollCorner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXArrowButton[] = {{&_swigt__p_FXArrowButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPopup[] = {{&_swigt__p_FXPopup, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeader[] = {{&_swigt__p_FXHeader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplitter[] = {{&_swigt__p_FXSplitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FX4Splitter[] = {{&_swigt__p_FX4Splitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpring[] = {{&_swigt__p_FXSpring, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPacker[] = {{&_swigt__p_FXPacker, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabBook[] = {{&_swigt__p_FXTabBook, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageFrame[] = {{&_swigt__p_FXImageFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalSeparator[] = {{&_swigt__p_FXVerticalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalSeparator[] = {{&_swigt__p_FXHorizontalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSeparator[] = {{&_swigt__p_FXSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXKnob[] = {{&_swigt__p_FXKnob, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXProgressBar[] = {{&_swigt__p_FXProgressBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutter[] = {{&_swigt__p_FXShutter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolTip[] = {{&_swigt__p_FXToolTip, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComposite[] = {{&_swigt__p_FXComposite, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBitmapFrame[] = {{&_swigt__p_FXBitmapFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSlider[] = {{&_swigt__p_FXRealSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSlider[] = {{&_swigt__p_FXSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockSite[] = {{&_swigt__p_FXDockSite, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGroupBox[] = {{&_swigt__p_FXGroupBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorRing[] = {{&_swigt__p_FXColorRing, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockHandler[] = {{&_swigt__p_FXDockHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTreeListBox[] = {{&_swigt__p_FXTreeListBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXListBox[] = {{&_swigt__p_FXListBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCanvas[] = {{&_swigt__p_FXCanvas, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWheel[] = {{&_swigt__p_FXColorWheel, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDial[] = {{&_swigt__p_FXDial, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarGrip[] = {{&_swigt__p_FXToolBarGrip, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollBar[] = {{&_swigt__p_FXScrollBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComboBox[] = {{&_swigt__p_FXComboBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFrame[] = {{&_swigt__p_FXFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FX7Segment[] = {{&_swigt__p_FX7Segment, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockTitle[] = {{&_swigt__p_FXDockTitle, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusBar[] = {{&_swigt__p_FXStatusBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRulerView[] = {{&_swigt__p_FXRulerView, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSpinner[] = {{&_swigt__p_FXRealSpinner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpinner[] = {{&_swigt__p_FXSpinner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusLine[] = {{&_swigt__p_FXStatusLine, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplashWindow[] = {{&_swigt__p_FXSplashWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMainWindow[] = {{&_swigt__p_FXMainWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTopWindow[] = {{&_swigt__p_FXTopWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRootWindow[] = {{&_swigt__p_FXRootWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXWindow[] = {{&_swigt__p_FXWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollWindow[] = {{&_swigt__p_FXScrollWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockBar[] = {{&_swigt__p_FXDockBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShell[] = {{&_swigt__p_FXShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollArea[] = {{&_swigt__p_FXScrollArea, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWell[] = {{&_swigt__p_FXColorWell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDragCorner[] = {{&_swigt__p_FXDragCorner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRuler[] = {{&_swigt__p_FXRuler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalFrame[] = {{&_swigt__p_FXVerticalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalFrame[] = {{&_swigt__p_FXHorizontalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageView[] = {{&_swigt__p_FXImageView, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFontSelector[] = {{&_swigt__p_FXFontSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorSelector[] = {{&_swigt__p_FXColorSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileSelector[] = {{&_swigt__p_FXFileSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirSelector[] = {{&_swigt__p_FXDirSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarShell[] = {{&_swigt__p_FXToolBarShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBar[] = {{&_swigt__p_FXToolBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirBox[] = {{&_swigt__p_FXDirBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDrawable[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRGBImage, _p_FXRGBImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXBMPImage, _p_FXBMPImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDrawable, 0, 0, 0},  {&_swigt__p_FXPCXImage, _p_FXPCXImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTGAImage, _p_FXTGAImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXICOImage, _p_FXICOImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPPMImage, _p_FXPPMImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXXBMImage, _p_FXXBMImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXXPMImage, _p_FXXPMImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImage, _p_FXImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPNGImage, _p_FXPNGImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXJPGImage, _p_FXJPGImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTIFImage, _p_FXTIFImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXGIFImage, _p_FXGIFImageTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXBitmap, _p_FXBitmapTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXDrawable, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGIFImage[] = {  {&_swigt__p_FXGIFImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXICOImage[] = {  {&_swigt__p_FXICOImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFont[] = {{&_swigt__p_FXFont, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVisual[] = {{&_swigt__p_FXVisual, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCursor[] = {{&_swigt__p_FXCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCURCursor[] = {{&_swigt__p_FXCURCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGIFCursor[] = {{&_swigt__p_FXGIFCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXId[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXId, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXId, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXId, 0, 0},  {&_swigt__p_FXRGBImage, _p_FXRGBImageTo_p_FXId, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXId, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXId, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXBMPImage, _p_FXBMPImageTo_p_FXId, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXId, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXId, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXId, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXId, 0, 0},  {&_swigt__p_FXPCXImage, _p_FXPCXImageTo_p_FXId, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXId, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXId, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXId, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXId, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXId, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXId, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXId, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXId, 0, 0},  {&_swigt__p_FXTGAImage, _p_FXTGAImageTo_p_FXId, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXId, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXId, 0, 0},  {&_swigt__p_FXICOImage, _p_FXICOImageTo_p_FXId, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXId, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXId, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXId, 0, 0},  {&_swigt__p_FXPPMImage, _p_FXPPMImageTo_p_FXId, 0, 0},  {&_swigt__p_FXXBMImage, _p_FXXBMImageTo_p_FXId, 0, 0},  {&_swigt__p_FXXPMImage, _p_FXXPMImageTo_p_FXId, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXId, 0, 0},  {&_swigt__p_FXId, 0, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXId, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXId, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXId, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXImage, _p_FXImageTo_p_FXId, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXId, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXId, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXId, 0, 0},  {&_swigt__p_FXPNGImage, _p_FXPNGImageTo_p_FXId, 0, 0},  {&_swigt__p_FXJPGImage, _p_FXJPGImageTo_p_FXId, 0, 0},  {&_swigt__p_FXTIFImage, _p_FXTIFImageTo_p_FXId, 0, 0},  {&_swigt__p_FXGIFImage, _p_FXGIFImageTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXId, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXId, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXId, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXId, 0, 0},  {&_swigt__p_FXBitmap, _p_FXBitmapTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXId, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXId, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXId, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXId, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXId, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXId, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImage[] = {  {&_swigt__p_FXBMPImage, _p_FXBMPImageTo_p_FXImage, 0, 0},  {&_swigt__p_FXPPMImage, _p_FXPPMImageTo_p_FXImage, 0, 0},  {&_swigt__p_FXRGBImage, _p_FXRGBImageTo_p_FXImage, 0, 0},  {&_swigt__p_FXXBMImage, _p_FXXBMImageTo_p_FXImage, 0, 0},  {&_swigt__p_FXXPMImage, _p_FXXPMImageTo_p_FXImage, 0, 0},  {&_swigt__p_FXImage, 0, 0, 0},  {&_swigt__p_FXGIFImage, _p_FXGIFImageTo_p_FXImage, 0, 0},  {&_swigt__p_FXTIFImage, _p_FXTIFImageTo_p_FXImage, 0, 0},  {&_swigt__p_FXJPGImage, _p_FXJPGImageTo_p_FXImage, 0, 0},  {&_swigt__p_FXPCXImage, _p_FXPCXImageTo_p_FXImage, 0, 0},  {&_swigt__p_FXPNGImage, _p_FXPNGImageTo_p_FXImage, 0, 0},  {&_swigt__p_FXICOImage, _p_FXICOImageTo_p_FXImage, 0, 0},  {&_swigt__p_FXTGAImage, _p_FXTGAImageTo_p_FXImage, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXJPGImage[] = {  {&_swigt__p_FXJPGImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMemoryBuffer[] = {  {&_swigt__p_FXMemoryBuffer, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDocument[] = {{&_swigt__p_FXDocument, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegistry[] = {{&_swigt__p_FXRegistry, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeaderItem[] = {{&_swigt__p_FXHeaderItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIconDict[] = {{&_swigt__p_FXIconDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileDict[] = {{&_swigt__p_FXFileDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRecentFiles[] = {{&_swigt__p_FXRecentFiles, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTranslator[] = {{&_swigt__p_FXTranslator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDict[] = {{&_swigt__p_FXDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSettings[] = {{&_swigt__p_FXSettings, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDataTarget[] = {{&_swigt__p_FXDataTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDebugTarget[] = {{&_swigt__p_FXDebugTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStringDict[] = {{&_swigt__p_FXStringDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDelegator[] = {{&_swigt__p_FXDelegator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXAccelTable[] = {{&_swigt__p_FXAccelTable, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXObject[] = {  {&_swigt__p_FXDocument, _p_FXDocumentTo_p_FXObject, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXRegistry, _p_FXRegistryTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeaderItem, _p_FXHeaderItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXRGBImage, _p_FXRGBImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXObject, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXObject, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXIconDict, _p_FXIconDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXBMPImage, _p_FXBMPImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileDict, _p_FXFileDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXRecentFiles, _p_FXRecentFilesTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXObject, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXObject, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXObject, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXObject, 0, 0},  {&_swigt__p_FXPCXImage, _p_FXPCXImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FXTranslator, _p_FXTranslatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXObject, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXObject, 0, 0},  {&_swigt__p_FXApp, _p_FXAppTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXObject, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXObject, 0, 0},  {&_swigt__p_FXTGAImage, _p_FXTGAImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXObject, 0, 0},  {&_swigt__p_FXDict, _p_FXDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXICOImage, _p_FXICOImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXSettings, _p_FXSettingsTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXObject, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXObject, 0, 0},  {&_swigt__p_FXDataTarget, _p_FXDataTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDebugTarget, _p_FXDebugTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXObject, 0, 0},  {&_swigt__p_FXPPMImage, _p_FXPPMImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXXBMImage, _p_FXXBMImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXXPMImage, _p_FXXPMImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXObject, 0, 0},  {&_swigt__p_FXId, _p_FXIdTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXObject, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXObject, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXImage, _p_FXImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXObject, 0, 0},  {&_swigt__p_FXPNGImage, _p_FXPNGImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXJPGImage, _p_FXJPGImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXTIFImage, _p_FXTIFImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXGIFImage, _p_FXGIFImageTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXStringDict, _p_FXStringDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXDelegator, _p_FXDelegatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXAccelTable, _p_FXAccelTableTo_p_FXObject, 0, 0},  {&_swigt__p_FXObject, 0, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXObject, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXBitmap, _p_FXBitmapTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXObject, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXObject, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXObject, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXObject, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPCXImage[] = {  {&_swigt__p_FXPCXImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPNGImage[] = {  {&_swigt__p_FXPNGImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPPMImage[] = {  {&_swigt__p_FXPPMImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRGBImage[] = {  {&_swigt__p_FXRGBImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileStream[] = {{&_swigt__p_FXFileStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMemoryStream[] = {{&_swigt__p_FXMemoryStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStream[] = {  {&_swigt__p_FXFileStream, _p_FXFileStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXMemoryStream, _p_FXMemoryStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTGAImage[] = {  {&_swigt__p_FXTGAImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTIFImage[] = {  {&_swigt__p_FXTIFImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXXBMImage[] = {  {&_swigt__p_FXXBMImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXXPMImage[] = {  {&_swigt__p_FXXPMImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
+
+static swig_cast_info *swig_cast_initial[] = {
+  _swigc__p_FX4Splitter,
+  _swigc__p_FX7Segment,
+  _swigc__p_FXAccelTable,
+  _swigc__p_FXApp,
+  _swigc__p_FXArrowButton,
+  _swigc__p_FXBMPImage,
+  _swigc__p_FXBitmap,
+  _swigc__p_FXBitmapFrame,
+  _swigc__p_FXCURCursor,
+  _swigc__p_FXCanvas,
+  _swigc__p_FXColorBar,
+  _swigc__p_FXColorRing,
+  _swigc__p_FXColorSelector,
+  _swigc__p_FXColorWell,
+  _swigc__p_FXColorWheel,
+  _swigc__p_FXComboBox,
+  _swigc__p_FXComposite,
+  _swigc__p_FXCursor,
+  _swigc__p_FXDataTarget,
+  _swigc__p_FXDebugTarget,
+  _swigc__p_FXDelegator,
+  _swigc__p_FXDial,
+  _swigc__p_FXDict,
+  _swigc__p_FXDirBox,
+  _swigc__p_FXDirSelector,
+  _swigc__p_FXDockBar,
+  _swigc__p_FXDockHandler,
+  _swigc__p_FXDockSite,
+  _swigc__p_FXDockTitle,
+  _swigc__p_FXDocument,
+  _swigc__p_FXDragCorner,
+  _swigc__p_FXDrawable,
+  _swigc__p_FXDriveBox,
+  _swigc__p_FXFileDict,
+  _swigc__p_FXFileSelector,
+  _swigc__p_FXFileStream,
+  _swigc__p_FXFont,
+  _swigc__p_FXFontSelector,
+  _swigc__p_FXFrame,
+  _swigc__p_FXGIFCursor,
+  _swigc__p_FXGIFImage,
+  _swigc__p_FXGradientBar,
+  _swigc__p_FXGroupBox,
+  _swigc__p_FXHeader,
+  _swigc__p_FXHeaderItem,
+  _swigc__p_FXHorizontalFrame,
+  _swigc__p_FXHorizontalSeparator,
+  _swigc__p_FXICOImage,
+  _swigc__p_FXIconDict,
+  _swigc__p_FXId,
+  _swigc__p_FXImage,
+  _swigc__p_FXImageFrame,
+  _swigc__p_FXImageView,
+  _swigc__p_FXJPGImage,
+  _swigc__p_FXKnob,
+  _swigc__p_FXListBox,
+  _swigc__p_FXMainWindow,
+  _swigc__p_FXMatrix,
+  _swigc__p_FXMemoryBuffer,
+  _swigc__p_FXMemoryStream,
+  _swigc__p_FXObject,
+  _swigc__p_FXPCXImage,
+  _swigc__p_FXPNGImage,
+  _swigc__p_FXPPMImage,
+  _swigc__p_FXPacker,
+  _swigc__p_FXPopup,
+  _swigc__p_FXProgressBar,
+  _swigc__p_FXRGBImage,
+  _swigc__p_FXRealSlider,
+  _swigc__p_FXRealSpinner,
+  _swigc__p_FXRecentFiles,
+  _swigc__p_FXRegistry,
+  _swigc__p_FXRootWindow,
+  _swigc__p_FXRuler,
+  _swigc__p_FXRulerView,
+  _swigc__p_FXScrollArea,
+  _swigc__p_FXScrollBar,
+  _swigc__p_FXScrollCorner,
+  _swigc__p_FXScrollWindow,
+  _swigc__p_FXSeparator,
+  _swigc__p_FXSettings,
+  _swigc__p_FXShell,
+  _swigc__p_FXShutter,
+  _swigc__p_FXShutterItem,
+  _swigc__p_FXSlider,
+  _swigc__p_FXSpinner,
+  _swigc__p_FXSplashWindow,
+  _swigc__p_FXSplitter,
+  _swigc__p_FXSpring,
+  _swigc__p_FXStatusBar,
+  _swigc__p_FXStatusLine,
+  _swigc__p_FXStream,
+  _swigc__p_FXStringDict,
+  _swigc__p_FXSwitcher,
+  _swigc__p_FXTGAImage,
+  _swigc__p_FXTIFImage,
+  _swigc__p_FXTabBar,
+  _swigc__p_FXTabBook,
+  _swigc__p_FXTextField,
+  _swigc__p_FXToolBar,
+  _swigc__p_FXToolBarGrip,
+  _swigc__p_FXToolBarShell,
+  _swigc__p_FXToolBarTab,
+  _swigc__p_FXToolTip,
+  _swigc__p_FXTopWindow,
+  _swigc__p_FXTranslator,
+  _swigc__p_FXTreeListBox,
+  _swigc__p_FXVerticalFrame,
+  _swigc__p_FXVerticalSeparator,
+  _swigc__p_FXVisual,
+  _swigc__p_FXWindow,
+  _swigc__p_FXXBMImage,
+  _swigc__p_FXXPMImage,
+  _swigc__p_char,
+  _swigc__p_double,
+  _swigc__p_float,
+  _swigc__p_int,
+  _swigc__p_long,
+  _swigc__p_p_char,
+  _swigc__p_short,
+  _swigc__p_unsigned_char,
+  _swigc__p_unsigned_int,
+  _swigc__p_unsigned_long,
+  _swigc__p_unsigned_short,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned statically to an initial
+ * array. We just loop through that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded.
+ * There are three cases to handle:
+ *  1) If the cast->type has already been loaded AND the type we are adding
+ *     casting info to has not been loaded (it is in this module), THEN we
+ *     replace the cast->type pointer with the type pointer that has already
+ *     been loaded.
+ *  2) If BOTH types (the one we are adding casting info to, and the
+ *     cast->type) are loaded, THEN the cast info has already been loaded by
+ *     the previous module so we just ignore it.
+ *  3) Finally, if cast->type has not already been loaded, then we add that
+ *     swig_cast_info to the linked list (because the cast->type) pointer will
+ *     be correct.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* c-mode */
+#endif
+#endif
+
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+  size_t i;
+  swig_module_info *module_head, *iter;
+  int init;
+
+  /* check to see if the circular list has been setup, if not, set it up */
+  if (swig_module.next==0) {
+    /* Initialize the swig_module */
+    swig_module.type_initial = swig_type_initial;
+    swig_module.cast_initial = swig_cast_initial;
+    swig_module.next = &swig_module;
+    init = 1;
+  } else {
+    init = 0;
+  }
+
+  /* Try and load any already created modules */
+  module_head = SWIG_GetModule(clientdata);
+  if (!module_head) {
+    /* This is the first module loaded for this interpreter */
+    /* so set the swig module into the interpreter */
+    SWIG_SetModule(clientdata, &swig_module);
+  } else {
+    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+    iter=module_head;
+    do {
+      if (iter==&swig_module) {
+        /* Our module is already in the list, so there's nothing more to do. */
+        return;
+      }
+      iter=iter->next;
+    } while (iter!= module_head);
+
+    /* otherwise we must add our module into the list */
+    swig_module.next = module_head->next;
+    module_head->next = &swig_module;
+  }
+
+  /* When multiple interpreters are used, a module could have already been initialized in
+     a different interpreter, but not yet have a pointer in this interpreter.
+     In this case, we do not want to continue adding types... everything should be
+     set up already */
+  if (init == 0) return;
+
+  /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+  for (i = 0; i < swig_module.size; ++i) {
+    swig_type_info *type = 0;
+    swig_type_info *ret;
+    swig_cast_info *cast;
+
+#ifdef SWIGRUNTIME_DEBUG
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+
+    /* if there is another module already loaded */
+    if (swig_module.next != &swig_module) {
+      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
+    }
+    if (type) {
+      /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+      if (swig_module.type_initial[i]->clientdata) {
+	type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+      }
+    } else {
+      type = swig_module.type_initial[i];
+    }
+
+    /* Insert casting types */
+    cast = swig_module.cast_initial[i];
+    while (cast->type) {
+
+      /* Don't need to add information already in the list */
+      ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+      if (swig_module.next != &swig_module) {
+        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+      }
+      if (ret) {
+	if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+	  cast->type = ret;
+	  ret = 0;
+	} else {
+	  /* Check for casting already in the list */
+	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+	  if (!ocast) ret = 0;
+	}
+      }
+
+      if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+        if (type->cast) {
+          type->cast->prev = cast;
+          cast->next = type->cast;
+        }
+        type->cast = cast;
+      }
+      cast++;
+    }
+    /* Set entry in modules->types array equal to the type */
+    swig_module.types[i] = type;
+  }
+  swig_module.types[i] = 0;
+
+#ifdef SWIGRUNTIME_DEBUG
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+  for (i = 0; i < swig_module.size; ++i) {
+    int j = 0;
+    swig_cast_info *cast = swig_module.cast_initial[i];
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    while (cast->type) {
+      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+      cast++;
+      ++j;
+    }
+  printf("---- Total casts: %d\n",j);
+  }
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types.  It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+  size_t i;
+  swig_cast_info *equiv;
+  static int init_run = 0;
+
+  if (init_run) return;
+  init_run = 1;
+
+  for (i = 0; i < swig_module.size; i++) {
+    if (swig_module.types[i]->clientdata) {
+      equiv = swig_module.types[i]->cast;
+      while (equiv) {
+        if (!equiv->converter) {
+          if (equiv->type && !equiv->type->clientdata)
+            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+        }
+        equiv = equiv->next;
+      }
+    }
+  }
+}
+
+#ifdef __cplusplus
+#if 0
+{ /* c-mode */
+#endif
+}
+#endif
+
+/*
+
+*/
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void Init_image(void) {
+  size_t i;
+  
+  SWIG_InitRuntime();
+  
+  
+  SWIG_InitializeModule(0);
+  for (i = 0; i < swig_module.size; i++) {
+    SWIG_define_class(swig_module.types[i]);
+  }
+  
+  SWIG_RubyInitializeTrackings();
+  
+  
+  
+  
+  rb_define_const(mFox, "BITMAP_KEEP", SWIG_From_int(static_cast< int >(BITMAP_KEEP)));
+  rb_define_const(mFox, "BITMAP_OWNED", SWIG_From_int(static_cast< int >(BITMAP_OWNED)));
+  rb_define_const(mFox, "BITMAP_SHMI", SWIG_From_int(static_cast< int >(BITMAP_SHMI)));
+  rb_define_const(mFox, "BITMAP_SHMP", SWIG_From_int(static_cast< int >(BITMAP_SHMP)));
+  
+  SwigClassFXBitmap.klass = rb_define_class_under(mFox, "FXBitmap", ((swig_class *) SWIGTYPE_p_FXDrawable->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXBitmap, (void *) &SwigClassFXBitmap);
+  rb_define_alloc_func(SwigClassFXBitmap.klass, _wrap_FXBitmap_allocate);
+  rb_define_method(SwigClassFXBitmap.klass, "initialize", VALUEFUNC(_wrap_new_FXBitmap), -1);
+  rb_define_method(SwigClassFXBitmap.klass, "getData", VALUEFUNC(_wrap_FXBitmap_getData), -1);
+  rb_define_method(SwigClassFXBitmap.klass, "getOptions", VALUEFUNC(_wrap_FXBitmap_getOptions), -1);
+  rb_define_method(SwigClassFXBitmap.klass, "setOptions", VALUEFUNC(_wrap_FXBitmap_setOptions), -1);
+  rb_define_method(SwigClassFXBitmap.klass, "getPixel", VALUEFUNC(_wrap_FXBitmap_getPixel), -1);
+  rb_define_method(SwigClassFXBitmap.klass, "setPixel", VALUEFUNC(_wrap_FXBitmap_setPixel), -1);
+  rb_define_method(SwigClassFXBitmap.klass, "save", VALUEFUNC(_wrap_FXBitmap_save), -1);
+  rb_define_method(SwigClassFXBitmap.klass, "load", VALUEFUNC(_wrap_FXBitmap_load), -1);
+  rb_define_method(SwigClassFXBitmap.klass, "create", VALUEFUNC(_wrap_FXBitmap_create), -1);
+  rb_define_method(SwigClassFXBitmap.klass, "detach", VALUEFUNC(_wrap_FXBitmap_detach), -1);
+  rb_define_method(SwigClassFXBitmap.klass, "destroy", VALUEFUNC(_wrap_FXBitmap_destroy), -1);
+  rb_define_method(SwigClassFXBitmap.klass, "resize", VALUEFUNC(_wrap_FXBitmap_resize), -1);
+  rb_define_method(SwigClassFXBitmap.klass, "restore", VALUEFUNC(_wrap_FXBitmap_restore), -1);
+  rb_define_method(SwigClassFXBitmap.klass, "render", VALUEFUNC(_wrap_FXBitmap_render), -1);
+  rb_define_method(SwigClassFXBitmap.klass, "release", VALUEFUNC(_wrap_FXBitmap_release), -1);
+  rb_define_method(SwigClassFXBitmap.klass, "savePixels", VALUEFUNC(_wrap_FXBitmap_savePixels), -1);
+  rb_define_method(SwigClassFXBitmap.klass, "loadPixels", VALUEFUNC(_wrap_FXBitmap_loadPixels), -1);
+  rb_define_method(SwigClassFXBitmap.klass, "scale", VALUEFUNC(_wrap_FXBitmap_scale), -1);
+  rb_define_method(SwigClassFXBitmap.klass, "mirror", VALUEFUNC(_wrap_FXBitmap_mirror), -1);
+  rb_define_method(SwigClassFXBitmap.klass, "rotate", VALUEFUNC(_wrap_FXBitmap_rotate), -1);
+  rb_define_method(SwigClassFXBitmap.klass, "crop", VALUEFUNC(_wrap_FXBitmap_crop), -1);
+  rb_define_method(SwigClassFXBitmap.klass, "fill", VALUEFUNC(_wrap_FXBitmap_fill), -1);
+  rb_define_method(SwigClassFXBitmap.klass, "setData", VALUEFUNC(_wrap_FXBitmap_setData), -1);
+  SwigClassFXBitmap.mark = (void (*)(void *)) FXRbBitmap::markfunc;
+  SwigClassFXBitmap.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXBitmap.trackObjects = 0;
+  
+  SwigClassFXMemoryBuffer.klass = rb_define_class_under(mFox, "FXMemoryBuffer", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMemoryBuffer, (void *) &SwigClassFXMemoryBuffer);
+  rb_define_alloc_func(SwigClassFXMemoryBuffer.klass, _wrap_FXMemoryBuffer_allocate);
+  rb_define_method(SwigClassFXMemoryBuffer.klass, "initialize", VALUEFUNC(_wrap_new_FXMemoryBuffer), -1);
+  rb_define_method(SwigClassFXMemoryBuffer.klass, "getSize", VALUEFUNC(_wrap_FXMemoryBuffer_getSize), -1);
+  rb_define_method(SwigClassFXMemoryBuffer.klass, "getData", VALUEFUNC(_wrap_FXMemoryBuffer_getData), -1);
+  rb_define_method(SwigClassFXMemoryBuffer.klass, "[]", VALUEFUNC(_wrap_FXMemoryBuffer___getitem__), -1);
+  rb_define_method(SwigClassFXMemoryBuffer.klass, "[]=", VALUEFUNC(_wrap_FXMemoryBuffer___setitem__), -1);
+  SwigClassFXMemoryBuffer.mark = 0;
+  SwigClassFXMemoryBuffer.destroy = (void (*)(void *)) free_FXMemoryBuffer;
+  SwigClassFXMemoryBuffer.trackObjects = 0;
+  rb_define_const(mFox, "IMAGE_KEEP", SWIG_From_int(static_cast< int >(IMAGE_KEEP)));
+  rb_define_const(mFox, "IMAGE_OWNED", SWIG_From_int(static_cast< int >(IMAGE_OWNED)));
+  rb_define_const(mFox, "IMAGE_DITHER", SWIG_From_int(static_cast< int >(IMAGE_DITHER)));
+  rb_define_const(mFox, "IMAGE_NEAREST", SWIG_From_int(static_cast< int >(IMAGE_NEAREST)));
+  rb_define_const(mFox, "IMAGE_OPAQUE", SWIG_From_int(static_cast< int >(IMAGE_OPAQUE)));
+  rb_define_const(mFox, "IMAGE_ALPHACOLOR", SWIG_From_int(static_cast< int >(IMAGE_ALPHACOLOR)));
+  rb_define_const(mFox, "IMAGE_SHMI", SWIG_From_int(static_cast< int >(IMAGE_SHMI)));
+  rb_define_const(mFox, "IMAGE_SHMP", SWIG_From_int(static_cast< int >(IMAGE_SHMP)));
+  rb_define_const(mFox, "IMAGE_ALPHAGUESS", SWIG_From_int(static_cast< int >(IMAGE_ALPHAGUESS)));
+  
+  SwigClassFXImage.klass = rb_define_class_under(mFox, "FXImage", ((swig_class *) SWIGTYPE_p_FXDrawable->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXImage, (void *) &SwigClassFXImage);
+  rb_define_alloc_func(SwigClassFXImage.klass, _wrap_FXImage_allocate);
+  rb_define_method(SwigClassFXImage.klass, "initialize", VALUEFUNC(_wrap_new_FXImage), -1);
+  rb_define_method(SwigClassFXImage.klass, "getData", VALUEFUNC(_wrap_FXImage_getData), -1);
+  rb_define_method(SwigClassFXImage.klass, "getDataPtr", VALUEFUNC(_wrap_FXImage_getDataPtr), -1);
+  rb_define_method(SwigClassFXImage.klass, "getOptions", VALUEFUNC(_wrap_FXImage_getOptions), -1);
+  rb_define_method(SwigClassFXImage.klass, "setOptions", VALUEFUNC(_wrap_FXImage_setOptions), -1);
+  rb_define_method(SwigClassFXImage.klass, "setPixels", VALUEFUNC(_wrap_FXImage_setPixels), -1);
+  rb_define_method(SwigClassFXImage.klass, "pixels", VALUEFUNC(_wrap_FXImage_pixels), -1);
+  rb_define_method(SwigClassFXImage.klass, "pixel_string", VALUEFUNC(_wrap_FXImage_pixel_string), -1);
+  rb_define_method(SwigClassFXImage.klass, "getPixel", VALUEFUNC(_wrap_FXImage_getPixel), -1);
+  rb_define_method(SwigClassFXImage.klass, "setPixel", VALUEFUNC(_wrap_FXImage_setPixel), -1);
+  rb_define_method(SwigClassFXImage.klass, "hasAlpha?", VALUEFUNC(_wrap_FXImage_hasAlphaq___), -1);
+  rb_define_method(SwigClassFXImage.klass, "save", VALUEFUNC(_wrap_FXImage_save), -1);
+  rb_define_method(SwigClassFXImage.klass, "load", VALUEFUNC(_wrap_FXImage_load), -1);
+  rb_define_method(SwigClassFXImage.klass, "create", VALUEFUNC(_wrap_FXImage_create), -1);
+  rb_define_method(SwigClassFXImage.klass, "detach", VALUEFUNC(_wrap_FXImage_detach), -1);
+  rb_define_method(SwigClassFXImage.klass, "destroy", VALUEFUNC(_wrap_FXImage_destroy), -1);
+  rb_define_method(SwigClassFXImage.klass, "resize", VALUEFUNC(_wrap_FXImage_resize), -1);
+  rb_define_method(SwigClassFXImage.klass, "restore", VALUEFUNC(_wrap_FXImage_restore), -1);
+  rb_define_method(SwigClassFXImage.klass, "render", VALUEFUNC(_wrap_FXImage_render), -1);
+  rb_define_method(SwigClassFXImage.klass, "release", VALUEFUNC(_wrap_FXImage_release), -1);
+  rb_define_method(SwigClassFXImage.klass, "scale", VALUEFUNC(_wrap_FXImage_scale), -1);
+  rb_define_method(SwigClassFXImage.klass, "mirror", VALUEFUNC(_wrap_FXImage_mirror), -1);
+  rb_define_method(SwigClassFXImage.klass, "rotate", VALUEFUNC(_wrap_FXImage_rotate), -1);
+  rb_define_method(SwigClassFXImage.klass, "crop", VALUEFUNC(_wrap_FXImage_crop), -1);
+  rb_define_method(SwigClassFXImage.klass, "fill", VALUEFUNC(_wrap_FXImage_fill), -1);
+  rb_define_method(SwigClassFXImage.klass, "fade", VALUEFUNC(_wrap_FXImage_fade), -1);
+  rb_define_method(SwigClassFXImage.klass, "xshear", VALUEFUNC(_wrap_FXImage_xshear), -1);
+  rb_define_method(SwigClassFXImage.klass, "yshear", VALUEFUNC(_wrap_FXImage_yshear), -1);
+  rb_define_method(SwigClassFXImage.klass, "hgradient", VALUEFUNC(_wrap_FXImage_hgradient), -1);
+  rb_define_method(SwigClassFXImage.klass, "vgradient", VALUEFUNC(_wrap_FXImage_vgradient), -1);
+  rb_define_method(SwigClassFXImage.klass, "gradient", VALUEFUNC(_wrap_FXImage_gradient), -1);
+  rb_define_method(SwigClassFXImage.klass, "blend", VALUEFUNC(_wrap_FXImage_blend), -1);
+  rb_define_method(SwigClassFXImage.klass, "savePixels", VALUEFUNC(_wrap_FXImage_savePixels), -1);
+  rb_define_method(SwigClassFXImage.klass, "loadPixels", VALUEFUNC(_wrap_FXImage_loadPixels), -1);
+  SwigClassFXImage.mark = (void (*)(void *)) FXRbImage::markfunc;
+  SwigClassFXImage.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXImage.trackObjects = 0;
+  
+  SWIGTYPE_p_FXImage->dcast = (swig_dycast_func) FXImage_dynamic_cast;
+  
+  
+  SwigClassFXBMPImage.klass = rb_define_class_under(mFox, "FXBMPImage", ((swig_class *) SWIGTYPE_p_FXImage->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXBMPImage, (void *) &SwigClassFXBMPImage);
+  rb_define_alloc_func(SwigClassFXBMPImage.klass, _wrap_FXBMPImage_allocate);
+  rb_define_method(SwigClassFXBMPImage.klass, "initialize", VALUEFUNC(_wrap_new_FXBMPImage), -1);
+  rb_define_singleton_method(SwigClassFXBMPImage.klass, "fileExt", VALUEFUNC(_wrap_FXBMPImage_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXBMPImage.klass, "mimeType", VALUEFUNC(_wrap_FXBMPImage_mimeType), -1);
+  rb_define_method(SwigClassFXBMPImage.klass, "save", VALUEFUNC(_wrap_FXBMPImage_save), -1);
+  rb_define_method(SwigClassFXBMPImage.klass, "load", VALUEFUNC(_wrap_FXBMPImage_load), -1);
+  rb_define_method(SwigClassFXBMPImage.klass, "create", VALUEFUNC(_wrap_FXBMPImage_create), -1);
+  rb_define_method(SwigClassFXBMPImage.klass, "detach", VALUEFUNC(_wrap_FXBMPImage_detach), -1);
+  rb_define_method(SwigClassFXBMPImage.klass, "destroy", VALUEFUNC(_wrap_FXBMPImage_destroy), -1);
+  rb_define_method(SwigClassFXBMPImage.klass, "resize", VALUEFUNC(_wrap_FXBMPImage_resize), -1);
+  rb_define_method(SwigClassFXBMPImage.klass, "restore", VALUEFUNC(_wrap_FXBMPImage_restore), -1);
+  rb_define_method(SwigClassFXBMPImage.klass, "render", VALUEFUNC(_wrap_FXBMPImage_render), -1);
+  rb_define_method(SwigClassFXBMPImage.klass, "release", VALUEFUNC(_wrap_FXBMPImage_release), -1);
+  rb_define_method(SwigClassFXBMPImage.klass, "scale", VALUEFUNC(_wrap_FXBMPImage_scale), -1);
+  rb_define_method(SwigClassFXBMPImage.klass, "mirror", VALUEFUNC(_wrap_FXBMPImage_mirror), -1);
+  rb_define_method(SwigClassFXBMPImage.klass, "rotate", VALUEFUNC(_wrap_FXBMPImage_rotate), -1);
+  rb_define_method(SwigClassFXBMPImage.klass, "crop", VALUEFUNC(_wrap_FXBMPImage_crop), -1);
+  rb_define_method(SwigClassFXBMPImage.klass, "fill", VALUEFUNC(_wrap_FXBMPImage_fill), -1);
+  rb_define_method(SwigClassFXBMPImage.klass, "fade", VALUEFUNC(_wrap_FXBMPImage_fade), -1);
+  rb_define_method(SwigClassFXBMPImage.klass, "xshear", VALUEFUNC(_wrap_FXBMPImage_xshear), -1);
+  rb_define_method(SwigClassFXBMPImage.klass, "yshear", VALUEFUNC(_wrap_FXBMPImage_yshear), -1);
+  rb_define_method(SwigClassFXBMPImage.klass, "hgradient", VALUEFUNC(_wrap_FXBMPImage_hgradient), -1);
+  rb_define_method(SwigClassFXBMPImage.klass, "vgradient", VALUEFUNC(_wrap_FXBMPImage_vgradient), -1);
+  rb_define_method(SwigClassFXBMPImage.klass, "gradient", VALUEFUNC(_wrap_FXBMPImage_gradient), -1);
+  rb_define_method(SwigClassFXBMPImage.klass, "blend", VALUEFUNC(_wrap_FXBMPImage_blend), -1);
+  rb_define_method(SwigClassFXBMPImage.klass, "savePixels", VALUEFUNC(_wrap_FXBMPImage_savePixels), -1);
+  rb_define_method(SwigClassFXBMPImage.klass, "loadPixels", VALUEFUNC(_wrap_FXBMPImage_loadPixels), -1);
+  SwigClassFXBMPImage.mark = (void (*)(void *)) FXRbBMPImage::markfunc;
+  SwigClassFXBMPImage.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXBMPImage.trackObjects = 0;
+  
+  SwigClassFXGIFImage.klass = rb_define_class_under(mFox, "FXGIFImage", ((swig_class *) SWIGTYPE_p_FXImage->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXGIFImage, (void *) &SwigClassFXGIFImage);
+  rb_define_alloc_func(SwigClassFXGIFImage.klass, _wrap_FXGIFImage_allocate);
+  rb_define_method(SwigClassFXGIFImage.klass, "initialize", VALUEFUNC(_wrap_new_FXGIFImage), -1);
+  rb_define_singleton_method(SwigClassFXGIFImage.klass, "fileExt", VALUEFUNC(_wrap_FXGIFImage_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXGIFImage.klass, "mimeType", VALUEFUNC(_wrap_FXGIFImage_mimeType), -1);
+  rb_define_method(SwigClassFXGIFImage.klass, "save", VALUEFUNC(_wrap_FXGIFImage_save), -1);
+  rb_define_method(SwigClassFXGIFImage.klass, "load", VALUEFUNC(_wrap_FXGIFImage_load), -1);
+  rb_define_method(SwigClassFXGIFImage.klass, "create", VALUEFUNC(_wrap_FXGIFImage_create), -1);
+  rb_define_method(SwigClassFXGIFImage.klass, "detach", VALUEFUNC(_wrap_FXGIFImage_detach), -1);
+  rb_define_method(SwigClassFXGIFImage.klass, "destroy", VALUEFUNC(_wrap_FXGIFImage_destroy), -1);
+  rb_define_method(SwigClassFXGIFImage.klass, "resize", VALUEFUNC(_wrap_FXGIFImage_resize), -1);
+  rb_define_method(SwigClassFXGIFImage.klass, "restore", VALUEFUNC(_wrap_FXGIFImage_restore), -1);
+  rb_define_method(SwigClassFXGIFImage.klass, "render", VALUEFUNC(_wrap_FXGIFImage_render), -1);
+  rb_define_method(SwigClassFXGIFImage.klass, "release", VALUEFUNC(_wrap_FXGIFImage_release), -1);
+  rb_define_method(SwigClassFXGIFImage.klass, "scale", VALUEFUNC(_wrap_FXGIFImage_scale), -1);
+  rb_define_method(SwigClassFXGIFImage.klass, "mirror", VALUEFUNC(_wrap_FXGIFImage_mirror), -1);
+  rb_define_method(SwigClassFXGIFImage.klass, "rotate", VALUEFUNC(_wrap_FXGIFImage_rotate), -1);
+  rb_define_method(SwigClassFXGIFImage.klass, "crop", VALUEFUNC(_wrap_FXGIFImage_crop), -1);
+  rb_define_method(SwigClassFXGIFImage.klass, "fill", VALUEFUNC(_wrap_FXGIFImage_fill), -1);
+  rb_define_method(SwigClassFXGIFImage.klass, "fade", VALUEFUNC(_wrap_FXGIFImage_fade), -1);
+  rb_define_method(SwigClassFXGIFImage.klass, "xshear", VALUEFUNC(_wrap_FXGIFImage_xshear), -1);
+  rb_define_method(SwigClassFXGIFImage.klass, "yshear", VALUEFUNC(_wrap_FXGIFImage_yshear), -1);
+  rb_define_method(SwigClassFXGIFImage.klass, "hgradient", VALUEFUNC(_wrap_FXGIFImage_hgradient), -1);
+  rb_define_method(SwigClassFXGIFImage.klass, "vgradient", VALUEFUNC(_wrap_FXGIFImage_vgradient), -1);
+  rb_define_method(SwigClassFXGIFImage.klass, "gradient", VALUEFUNC(_wrap_FXGIFImage_gradient), -1);
+  rb_define_method(SwigClassFXGIFImage.klass, "blend", VALUEFUNC(_wrap_FXGIFImage_blend), -1);
+  rb_define_method(SwigClassFXGIFImage.klass, "savePixels", VALUEFUNC(_wrap_FXGIFImage_savePixels), -1);
+  rb_define_method(SwigClassFXGIFImage.klass, "loadPixels", VALUEFUNC(_wrap_FXGIFImage_loadPixels), -1);
+  SwigClassFXGIFImage.mark = (void (*)(void *)) FXRbGIFImage::markfunc;
+  SwigClassFXGIFImage.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXGIFImage.trackObjects = 0;
+  
+  SwigClassFXICOImage.klass = rb_define_class_under(mFox, "FXICOImage", ((swig_class *) SWIGTYPE_p_FXImage->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXICOImage, (void *) &SwigClassFXICOImage);
+  rb_define_alloc_func(SwigClassFXICOImage.klass, _wrap_FXICOImage_allocate);
+  rb_define_method(SwigClassFXICOImage.klass, "initialize", VALUEFUNC(_wrap_new_FXICOImage), -1);
+  rb_define_singleton_method(SwigClassFXICOImage.klass, "fileExt", VALUEFUNC(_wrap_FXICOImage_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXICOImage.klass, "mimeType", VALUEFUNC(_wrap_FXICOImage_mimeType), -1);
+  rb_define_method(SwigClassFXICOImage.klass, "save", VALUEFUNC(_wrap_FXICOImage_save), -1);
+  rb_define_method(SwigClassFXICOImage.klass, "load", VALUEFUNC(_wrap_FXICOImage_load), -1);
+  rb_define_method(SwigClassFXICOImage.klass, "create", VALUEFUNC(_wrap_FXICOImage_create), -1);
+  rb_define_method(SwigClassFXICOImage.klass, "detach", VALUEFUNC(_wrap_FXICOImage_detach), -1);
+  rb_define_method(SwigClassFXICOImage.klass, "destroy", VALUEFUNC(_wrap_FXICOImage_destroy), -1);
+  rb_define_method(SwigClassFXICOImage.klass, "resize", VALUEFUNC(_wrap_FXICOImage_resize), -1);
+  rb_define_method(SwigClassFXICOImage.klass, "restore", VALUEFUNC(_wrap_FXICOImage_restore), -1);
+  rb_define_method(SwigClassFXICOImage.klass, "render", VALUEFUNC(_wrap_FXICOImage_render), -1);
+  rb_define_method(SwigClassFXICOImage.klass, "release", VALUEFUNC(_wrap_FXICOImage_release), -1);
+  rb_define_method(SwigClassFXICOImage.klass, "scale", VALUEFUNC(_wrap_FXICOImage_scale), -1);
+  rb_define_method(SwigClassFXICOImage.klass, "mirror", VALUEFUNC(_wrap_FXICOImage_mirror), -1);
+  rb_define_method(SwigClassFXICOImage.klass, "rotate", VALUEFUNC(_wrap_FXICOImage_rotate), -1);
+  rb_define_method(SwigClassFXICOImage.klass, "crop", VALUEFUNC(_wrap_FXICOImage_crop), -1);
+  rb_define_method(SwigClassFXICOImage.klass, "fill", VALUEFUNC(_wrap_FXICOImage_fill), -1);
+  rb_define_method(SwigClassFXICOImage.klass, "fade", VALUEFUNC(_wrap_FXICOImage_fade), -1);
+  rb_define_method(SwigClassFXICOImage.klass, "xshear", VALUEFUNC(_wrap_FXICOImage_xshear), -1);
+  rb_define_method(SwigClassFXICOImage.klass, "yshear", VALUEFUNC(_wrap_FXICOImage_yshear), -1);
+  rb_define_method(SwigClassFXICOImage.klass, "hgradient", VALUEFUNC(_wrap_FXICOImage_hgradient), -1);
+  rb_define_method(SwigClassFXICOImage.klass, "vgradient", VALUEFUNC(_wrap_FXICOImage_vgradient), -1);
+  rb_define_method(SwigClassFXICOImage.klass, "gradient", VALUEFUNC(_wrap_FXICOImage_gradient), -1);
+  rb_define_method(SwigClassFXICOImage.klass, "blend", VALUEFUNC(_wrap_FXICOImage_blend), -1);
+  rb_define_method(SwigClassFXICOImage.klass, "savePixels", VALUEFUNC(_wrap_FXICOImage_savePixels), -1);
+  rb_define_method(SwigClassFXICOImage.klass, "loadPixels", VALUEFUNC(_wrap_FXICOImage_loadPixels), -1);
+  SwigClassFXICOImage.mark = (void (*)(void *)) FXRbICOImage::markfunc;
+  SwigClassFXICOImage.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXICOImage.trackObjects = 0;
+  
+  SwigClassFXJPGImage.klass = rb_define_class_under(mFox, "FXJPGImage", ((swig_class *) SWIGTYPE_p_FXImage->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXJPGImage, (void *) &SwigClassFXJPGImage);
+  rb_define_alloc_func(SwigClassFXJPGImage.klass, _wrap_FXJPGImage_allocate);
+  rb_define_method(SwigClassFXJPGImage.klass, "initialize", VALUEFUNC(_wrap_new_FXJPGImage), -1);
+  rb_define_singleton_method(SwigClassFXJPGImage.klass, "fileExt", VALUEFUNC(_wrap_FXJPGImage_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXJPGImage.klass, "mimeType", VALUEFUNC(_wrap_FXJPGImage_mimeType), -1);
+  rb_define_singleton_method(SwigClassFXJPGImage.klass, "supported_Sq_", VALUEFUNC(_wrap_FXJPGImage_supported_Sq_), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "setQuality", VALUEFUNC(_wrap_FXJPGImage_setQuality), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "getQuality", VALUEFUNC(_wrap_FXJPGImage_getQuality), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "save", VALUEFUNC(_wrap_FXJPGImage_save), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "load", VALUEFUNC(_wrap_FXJPGImage_load), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "create", VALUEFUNC(_wrap_FXJPGImage_create), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "detach", VALUEFUNC(_wrap_FXJPGImage_detach), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "destroy", VALUEFUNC(_wrap_FXJPGImage_destroy), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "resize", VALUEFUNC(_wrap_FXJPGImage_resize), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "restore", VALUEFUNC(_wrap_FXJPGImage_restore), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "render", VALUEFUNC(_wrap_FXJPGImage_render), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "release", VALUEFUNC(_wrap_FXJPGImage_release), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "scale", VALUEFUNC(_wrap_FXJPGImage_scale), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "mirror", VALUEFUNC(_wrap_FXJPGImage_mirror), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "rotate", VALUEFUNC(_wrap_FXJPGImage_rotate), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "crop", VALUEFUNC(_wrap_FXJPGImage_crop), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "fill", VALUEFUNC(_wrap_FXJPGImage_fill), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "fade", VALUEFUNC(_wrap_FXJPGImage_fade), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "xshear", VALUEFUNC(_wrap_FXJPGImage_xshear), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "yshear", VALUEFUNC(_wrap_FXJPGImage_yshear), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "hgradient", VALUEFUNC(_wrap_FXJPGImage_hgradient), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "vgradient", VALUEFUNC(_wrap_FXJPGImage_vgradient), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "gradient", VALUEFUNC(_wrap_FXJPGImage_gradient), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "blend", VALUEFUNC(_wrap_FXJPGImage_blend), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "savePixels", VALUEFUNC(_wrap_FXJPGImage_savePixels), -1);
+  rb_define_method(SwigClassFXJPGImage.klass, "loadPixels", VALUEFUNC(_wrap_FXJPGImage_loadPixels), -1);
+  SwigClassFXJPGImage.mark = (void (*)(void *)) FXRbJPGImage::markfunc;
+  SwigClassFXJPGImage.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXJPGImage.trackObjects = 0;
+  
+  SwigClassFXPCXImage.klass = rb_define_class_under(mFox, "FXPCXImage", ((swig_class *) SWIGTYPE_p_FXImage->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXPCXImage, (void *) &SwigClassFXPCXImage);
+  rb_define_alloc_func(SwigClassFXPCXImage.klass, _wrap_FXPCXImage_allocate);
+  rb_define_method(SwigClassFXPCXImage.klass, "initialize", VALUEFUNC(_wrap_new_FXPCXImage), -1);
+  rb_define_singleton_method(SwigClassFXPCXImage.klass, "fileExt", VALUEFUNC(_wrap_FXPCXImage_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXPCXImage.klass, "mimeType", VALUEFUNC(_wrap_FXPCXImage_mimeType), -1);
+  rb_define_method(SwigClassFXPCXImage.klass, "save", VALUEFUNC(_wrap_FXPCXImage_save), -1);
+  rb_define_method(SwigClassFXPCXImage.klass, "load", VALUEFUNC(_wrap_FXPCXImage_load), -1);
+  rb_define_method(SwigClassFXPCXImage.klass, "create", VALUEFUNC(_wrap_FXPCXImage_create), -1);
+  rb_define_method(SwigClassFXPCXImage.klass, "detach", VALUEFUNC(_wrap_FXPCXImage_detach), -1);
+  rb_define_method(SwigClassFXPCXImage.klass, "destroy", VALUEFUNC(_wrap_FXPCXImage_destroy), -1);
+  rb_define_method(SwigClassFXPCXImage.klass, "resize", VALUEFUNC(_wrap_FXPCXImage_resize), -1);
+  rb_define_method(SwigClassFXPCXImage.klass, "restore", VALUEFUNC(_wrap_FXPCXImage_restore), -1);
+  rb_define_method(SwigClassFXPCXImage.klass, "render", VALUEFUNC(_wrap_FXPCXImage_render), -1);
+  rb_define_method(SwigClassFXPCXImage.klass, "release", VALUEFUNC(_wrap_FXPCXImage_release), -1);
+  rb_define_method(SwigClassFXPCXImage.klass, "scale", VALUEFUNC(_wrap_FXPCXImage_scale), -1);
+  rb_define_method(SwigClassFXPCXImage.klass, "mirror", VALUEFUNC(_wrap_FXPCXImage_mirror), -1);
+  rb_define_method(SwigClassFXPCXImage.klass, "rotate", VALUEFUNC(_wrap_FXPCXImage_rotate), -1);
+  rb_define_method(SwigClassFXPCXImage.klass, "crop", VALUEFUNC(_wrap_FXPCXImage_crop), -1);
+  rb_define_method(SwigClassFXPCXImage.klass, "fill", VALUEFUNC(_wrap_FXPCXImage_fill), -1);
+  rb_define_method(SwigClassFXPCXImage.klass, "fade", VALUEFUNC(_wrap_FXPCXImage_fade), -1);
+  rb_define_method(SwigClassFXPCXImage.klass, "xshear", VALUEFUNC(_wrap_FXPCXImage_xshear), -1);
+  rb_define_method(SwigClassFXPCXImage.klass, "yshear", VALUEFUNC(_wrap_FXPCXImage_yshear), -1);
+  rb_define_method(SwigClassFXPCXImage.klass, "hgradient", VALUEFUNC(_wrap_FXPCXImage_hgradient), -1);
+  rb_define_method(SwigClassFXPCXImage.klass, "vgradient", VALUEFUNC(_wrap_FXPCXImage_vgradient), -1);
+  rb_define_method(SwigClassFXPCXImage.klass, "gradient", VALUEFUNC(_wrap_FXPCXImage_gradient), -1);
+  rb_define_method(SwigClassFXPCXImage.klass, "blend", VALUEFUNC(_wrap_FXPCXImage_blend), -1);
+  rb_define_method(SwigClassFXPCXImage.klass, "savePixels", VALUEFUNC(_wrap_FXPCXImage_savePixels), -1);
+  rb_define_method(SwigClassFXPCXImage.klass, "loadPixels", VALUEFUNC(_wrap_FXPCXImage_loadPixels), -1);
+  SwigClassFXPCXImage.mark = (void (*)(void *)) FXRbPCXImage::markfunc;
+  SwigClassFXPCXImage.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXPCXImage.trackObjects = 0;
+  
+  SwigClassFXPNGImage.klass = rb_define_class_under(mFox, "FXPNGImage", ((swig_class *) SWIGTYPE_p_FXImage->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXPNGImage, (void *) &SwigClassFXPNGImage);
+  rb_define_alloc_func(SwigClassFXPNGImage.klass, _wrap_FXPNGImage_allocate);
+  rb_define_method(SwigClassFXPNGImage.klass, "initialize", VALUEFUNC(_wrap_new_FXPNGImage), -1);
+  rb_define_singleton_method(SwigClassFXPNGImage.klass, "fileExt", VALUEFUNC(_wrap_FXPNGImage_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXPNGImage.klass, "mimeType", VALUEFUNC(_wrap_FXPNGImage_mimeType), -1);
+  rb_define_singleton_method(SwigClassFXPNGImage.klass, "supported_Sq_", VALUEFUNC(_wrap_FXPNGImage_supported_Sq_), -1);
+  rb_define_method(SwigClassFXPNGImage.klass, "save", VALUEFUNC(_wrap_FXPNGImage_save), -1);
+  rb_define_method(SwigClassFXPNGImage.klass, "load", VALUEFUNC(_wrap_FXPNGImage_load), -1);
+  rb_define_method(SwigClassFXPNGImage.klass, "create", VALUEFUNC(_wrap_FXPNGImage_create), -1);
+  rb_define_method(SwigClassFXPNGImage.klass, "detach", VALUEFUNC(_wrap_FXPNGImage_detach), -1);
+  rb_define_method(SwigClassFXPNGImage.klass, "destroy", VALUEFUNC(_wrap_FXPNGImage_destroy), -1);
+  rb_define_method(SwigClassFXPNGImage.klass, "resize", VALUEFUNC(_wrap_FXPNGImage_resize), -1);
+  rb_define_method(SwigClassFXPNGImage.klass, "restore", VALUEFUNC(_wrap_FXPNGImage_restore), -1);
+  rb_define_method(SwigClassFXPNGImage.klass, "render", VALUEFUNC(_wrap_FXPNGImage_render), -1);
+  rb_define_method(SwigClassFXPNGImage.klass, "release", VALUEFUNC(_wrap_FXPNGImage_release), -1);
+  rb_define_method(SwigClassFXPNGImage.klass, "scale", VALUEFUNC(_wrap_FXPNGImage_scale), -1);
+  rb_define_method(SwigClassFXPNGImage.klass, "mirror", VALUEFUNC(_wrap_FXPNGImage_mirror), -1);
+  rb_define_method(SwigClassFXPNGImage.klass, "rotate", VALUEFUNC(_wrap_FXPNGImage_rotate), -1);
+  rb_define_method(SwigClassFXPNGImage.klass, "crop", VALUEFUNC(_wrap_FXPNGImage_crop), -1);
+  rb_define_method(SwigClassFXPNGImage.klass, "fill", VALUEFUNC(_wrap_FXPNGImage_fill), -1);
+  rb_define_method(SwigClassFXPNGImage.klass, "fade", VALUEFUNC(_wrap_FXPNGImage_fade), -1);
+  rb_define_method(SwigClassFXPNGImage.klass, "xshear", VALUEFUNC(_wrap_FXPNGImage_xshear), -1);
+  rb_define_method(SwigClassFXPNGImage.klass, "yshear", VALUEFUNC(_wrap_FXPNGImage_yshear), -1);
+  rb_define_method(SwigClassFXPNGImage.klass, "hgradient", VALUEFUNC(_wrap_FXPNGImage_hgradient), -1);
+  rb_define_method(SwigClassFXPNGImage.klass, "vgradient", VALUEFUNC(_wrap_FXPNGImage_vgradient), -1);
+  rb_define_method(SwigClassFXPNGImage.klass, "gradient", VALUEFUNC(_wrap_FXPNGImage_gradient), -1);
+  rb_define_method(SwigClassFXPNGImage.klass, "blend", VALUEFUNC(_wrap_FXPNGImage_blend), -1);
+  rb_define_method(SwigClassFXPNGImage.klass, "savePixels", VALUEFUNC(_wrap_FXPNGImage_savePixels), -1);
+  rb_define_method(SwigClassFXPNGImage.klass, "loadPixels", VALUEFUNC(_wrap_FXPNGImage_loadPixels), -1);
+  SwigClassFXPNGImage.mark = (void (*)(void *)) FXRbPNGImage::markfunc;
+  SwigClassFXPNGImage.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXPNGImage.trackObjects = 0;
+  
+  SwigClassFXPPMImage.klass = rb_define_class_under(mFox, "FXPPMImage", ((swig_class *) SWIGTYPE_p_FXImage->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXPPMImage, (void *) &SwigClassFXPPMImage);
+  rb_define_alloc_func(SwigClassFXPPMImage.klass, _wrap_FXPPMImage_allocate);
+  rb_define_method(SwigClassFXPPMImage.klass, "initialize", VALUEFUNC(_wrap_new_FXPPMImage), -1);
+  rb_define_singleton_method(SwigClassFXPPMImage.klass, "fileExt", VALUEFUNC(_wrap_FXPPMImage_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXPPMImage.klass, "mimeType", VALUEFUNC(_wrap_FXPPMImage_mimeType), -1);
+  rb_define_method(SwigClassFXPPMImage.klass, "save", VALUEFUNC(_wrap_FXPPMImage_save), -1);
+  rb_define_method(SwigClassFXPPMImage.klass, "load", VALUEFUNC(_wrap_FXPPMImage_load), -1);
+  rb_define_method(SwigClassFXPPMImage.klass, "create", VALUEFUNC(_wrap_FXPPMImage_create), -1);
+  rb_define_method(SwigClassFXPPMImage.klass, "detach", VALUEFUNC(_wrap_FXPPMImage_detach), -1);
+  rb_define_method(SwigClassFXPPMImage.klass, "destroy", VALUEFUNC(_wrap_FXPPMImage_destroy), -1);
+  rb_define_method(SwigClassFXPPMImage.klass, "resize", VALUEFUNC(_wrap_FXPPMImage_resize), -1);
+  rb_define_method(SwigClassFXPPMImage.klass, "restore", VALUEFUNC(_wrap_FXPPMImage_restore), -1);
+  rb_define_method(SwigClassFXPPMImage.klass, "render", VALUEFUNC(_wrap_FXPPMImage_render), -1);
+  rb_define_method(SwigClassFXPPMImage.klass, "release", VALUEFUNC(_wrap_FXPPMImage_release), -1);
+  rb_define_method(SwigClassFXPPMImage.klass, "scale", VALUEFUNC(_wrap_FXPPMImage_scale), -1);
+  rb_define_method(SwigClassFXPPMImage.klass, "mirror", VALUEFUNC(_wrap_FXPPMImage_mirror), -1);
+  rb_define_method(SwigClassFXPPMImage.klass, "rotate", VALUEFUNC(_wrap_FXPPMImage_rotate), -1);
+  rb_define_method(SwigClassFXPPMImage.klass, "crop", VALUEFUNC(_wrap_FXPPMImage_crop), -1);
+  rb_define_method(SwigClassFXPPMImage.klass, "fill", VALUEFUNC(_wrap_FXPPMImage_fill), -1);
+  rb_define_method(SwigClassFXPPMImage.klass, "fade", VALUEFUNC(_wrap_FXPPMImage_fade), -1);
+  rb_define_method(SwigClassFXPPMImage.klass, "xshear", VALUEFUNC(_wrap_FXPPMImage_xshear), -1);
+  rb_define_method(SwigClassFXPPMImage.klass, "yshear", VALUEFUNC(_wrap_FXPPMImage_yshear), -1);
+  rb_define_method(SwigClassFXPPMImage.klass, "hgradient", VALUEFUNC(_wrap_FXPPMImage_hgradient), -1);
+  rb_define_method(SwigClassFXPPMImage.klass, "vgradient", VALUEFUNC(_wrap_FXPPMImage_vgradient), -1);
+  rb_define_method(SwigClassFXPPMImage.klass, "gradient", VALUEFUNC(_wrap_FXPPMImage_gradient), -1);
+  rb_define_method(SwigClassFXPPMImage.klass, "blend", VALUEFUNC(_wrap_FXPPMImage_blend), -1);
+  rb_define_method(SwigClassFXPPMImage.klass, "savePixels", VALUEFUNC(_wrap_FXPPMImage_savePixels), -1);
+  rb_define_method(SwigClassFXPPMImage.klass, "loadPixels", VALUEFUNC(_wrap_FXPPMImage_loadPixels), -1);
+  SwigClassFXPPMImage.mark = 0;
+  SwigClassFXPPMImage.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXPPMImage.trackObjects = 0;
+  
+  SwigClassFXRGBImage.klass = rb_define_class_under(mFox, "FXRGBImage", ((swig_class *) SWIGTYPE_p_FXImage->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXRGBImage, (void *) &SwigClassFXRGBImage);
+  rb_define_alloc_func(SwigClassFXRGBImage.klass, _wrap_FXRGBImage_allocate);
+  rb_define_method(SwigClassFXRGBImage.klass, "initialize", VALUEFUNC(_wrap_new_FXRGBImage), -1);
+  rb_define_singleton_method(SwigClassFXRGBImage.klass, "fileExt", VALUEFUNC(_wrap_FXRGBImage_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXRGBImage.klass, "mimeType", VALUEFUNC(_wrap_FXRGBImage_mimeType), -1);
+  rb_define_method(SwigClassFXRGBImage.klass, "save", VALUEFUNC(_wrap_FXRGBImage_save), -1);
+  rb_define_method(SwigClassFXRGBImage.klass, "load", VALUEFUNC(_wrap_FXRGBImage_load), -1);
+  rb_define_method(SwigClassFXRGBImage.klass, "create", VALUEFUNC(_wrap_FXRGBImage_create), -1);
+  rb_define_method(SwigClassFXRGBImage.klass, "detach", VALUEFUNC(_wrap_FXRGBImage_detach), -1);
+  rb_define_method(SwigClassFXRGBImage.klass, "destroy", VALUEFUNC(_wrap_FXRGBImage_destroy), -1);
+  rb_define_method(SwigClassFXRGBImage.klass, "resize", VALUEFUNC(_wrap_FXRGBImage_resize), -1);
+  rb_define_method(SwigClassFXRGBImage.klass, "restore", VALUEFUNC(_wrap_FXRGBImage_restore), -1);
+  rb_define_method(SwigClassFXRGBImage.klass, "render", VALUEFUNC(_wrap_FXRGBImage_render), -1);
+  rb_define_method(SwigClassFXRGBImage.klass, "release", VALUEFUNC(_wrap_FXRGBImage_release), -1);
+  rb_define_method(SwigClassFXRGBImage.klass, "scale", VALUEFUNC(_wrap_FXRGBImage_scale), -1);
+  rb_define_method(SwigClassFXRGBImage.klass, "mirror", VALUEFUNC(_wrap_FXRGBImage_mirror), -1);
+  rb_define_method(SwigClassFXRGBImage.klass, "rotate", VALUEFUNC(_wrap_FXRGBImage_rotate), -1);
+  rb_define_method(SwigClassFXRGBImage.klass, "crop", VALUEFUNC(_wrap_FXRGBImage_crop), -1);
+  rb_define_method(SwigClassFXRGBImage.klass, "fill", VALUEFUNC(_wrap_FXRGBImage_fill), -1);
+  rb_define_method(SwigClassFXRGBImage.klass, "fade", VALUEFUNC(_wrap_FXRGBImage_fade), -1);
+  rb_define_method(SwigClassFXRGBImage.klass, "xshear", VALUEFUNC(_wrap_FXRGBImage_xshear), -1);
+  rb_define_method(SwigClassFXRGBImage.klass, "yshear", VALUEFUNC(_wrap_FXRGBImage_yshear), -1);
+  rb_define_method(SwigClassFXRGBImage.klass, "hgradient", VALUEFUNC(_wrap_FXRGBImage_hgradient), -1);
+  rb_define_method(SwigClassFXRGBImage.klass, "vgradient", VALUEFUNC(_wrap_FXRGBImage_vgradient), -1);
+  rb_define_method(SwigClassFXRGBImage.klass, "gradient", VALUEFUNC(_wrap_FXRGBImage_gradient), -1);
+  rb_define_method(SwigClassFXRGBImage.klass, "blend", VALUEFUNC(_wrap_FXRGBImage_blend), -1);
+  rb_define_method(SwigClassFXRGBImage.klass, "savePixels", VALUEFUNC(_wrap_FXRGBImage_savePixels), -1);
+  rb_define_method(SwigClassFXRGBImage.klass, "loadPixels", VALUEFUNC(_wrap_FXRGBImage_loadPixels), -1);
+  SwigClassFXRGBImage.mark = (void (*)(void *)) FXRbRGBImage::markfunc;
+  SwigClassFXRGBImage.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXRGBImage.trackObjects = 0;
+  
+  SwigClassFXTGAImage.klass = rb_define_class_under(mFox, "FXTGAImage", ((swig_class *) SWIGTYPE_p_FXImage->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXTGAImage, (void *) &SwigClassFXTGAImage);
+  rb_define_alloc_func(SwigClassFXTGAImage.klass, _wrap_FXTGAImage_allocate);
+  rb_define_method(SwigClassFXTGAImage.klass, "initialize", VALUEFUNC(_wrap_new_FXTGAImage), -1);
+  rb_define_singleton_method(SwigClassFXTGAImage.klass, "fileExt", VALUEFUNC(_wrap_FXTGAImage_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXTGAImage.klass, "mimeType", VALUEFUNC(_wrap_FXTGAImage_mimeType), -1);
+  rb_define_method(SwigClassFXTGAImage.klass, "save", VALUEFUNC(_wrap_FXTGAImage_save), -1);
+  rb_define_method(SwigClassFXTGAImage.klass, "load", VALUEFUNC(_wrap_FXTGAImage_load), -1);
+  rb_define_method(SwigClassFXTGAImage.klass, "create", VALUEFUNC(_wrap_FXTGAImage_create), -1);
+  rb_define_method(SwigClassFXTGAImage.klass, "detach", VALUEFUNC(_wrap_FXTGAImage_detach), -1);
+  rb_define_method(SwigClassFXTGAImage.klass, "destroy", VALUEFUNC(_wrap_FXTGAImage_destroy), -1);
+  rb_define_method(SwigClassFXTGAImage.klass, "resize", VALUEFUNC(_wrap_FXTGAImage_resize), -1);
+  rb_define_method(SwigClassFXTGAImage.klass, "restore", VALUEFUNC(_wrap_FXTGAImage_restore), -1);
+  rb_define_method(SwigClassFXTGAImage.klass, "render", VALUEFUNC(_wrap_FXTGAImage_render), -1);
+  rb_define_method(SwigClassFXTGAImage.klass, "release", VALUEFUNC(_wrap_FXTGAImage_release), -1);
+  rb_define_method(SwigClassFXTGAImage.klass, "scale", VALUEFUNC(_wrap_FXTGAImage_scale), -1);
+  rb_define_method(SwigClassFXTGAImage.klass, "mirror", VALUEFUNC(_wrap_FXTGAImage_mirror), -1);
+  rb_define_method(SwigClassFXTGAImage.klass, "rotate", VALUEFUNC(_wrap_FXTGAImage_rotate), -1);
+  rb_define_method(SwigClassFXTGAImage.klass, "crop", VALUEFUNC(_wrap_FXTGAImage_crop), -1);
+  rb_define_method(SwigClassFXTGAImage.klass, "fill", VALUEFUNC(_wrap_FXTGAImage_fill), -1);
+  rb_define_method(SwigClassFXTGAImage.klass, "fade", VALUEFUNC(_wrap_FXTGAImage_fade), -1);
+  rb_define_method(SwigClassFXTGAImage.klass, "xshear", VALUEFUNC(_wrap_FXTGAImage_xshear), -1);
+  rb_define_method(SwigClassFXTGAImage.klass, "yshear", VALUEFUNC(_wrap_FXTGAImage_yshear), -1);
+  rb_define_method(SwigClassFXTGAImage.klass, "hgradient", VALUEFUNC(_wrap_FXTGAImage_hgradient), -1);
+  rb_define_method(SwigClassFXTGAImage.klass, "vgradient", VALUEFUNC(_wrap_FXTGAImage_vgradient), -1);
+  rb_define_method(SwigClassFXTGAImage.klass, "gradient", VALUEFUNC(_wrap_FXTGAImage_gradient), -1);
+  rb_define_method(SwigClassFXTGAImage.klass, "blend", VALUEFUNC(_wrap_FXTGAImage_blend), -1);
+  rb_define_method(SwigClassFXTGAImage.klass, "savePixels", VALUEFUNC(_wrap_FXTGAImage_savePixels), -1);
+  rb_define_method(SwigClassFXTGAImage.klass, "loadPixels", VALUEFUNC(_wrap_FXTGAImage_loadPixels), -1);
+  SwigClassFXTGAImage.mark = (void (*)(void *)) FXRbTGAImage::markfunc;
+  SwigClassFXTGAImage.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXTGAImage.trackObjects = 0;
+  
+  SwigClassFXTIFImage.klass = rb_define_class_under(mFox, "FXTIFImage", ((swig_class *) SWIGTYPE_p_FXImage->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXTIFImage, (void *) &SwigClassFXTIFImage);
+  rb_define_alloc_func(SwigClassFXTIFImage.klass, _wrap_FXTIFImage_allocate);
+  rb_define_method(SwigClassFXTIFImage.klass, "initialize", VALUEFUNC(_wrap_new_FXTIFImage), -1);
+  rb_define_singleton_method(SwigClassFXTIFImage.klass, "fileExt", VALUEFUNC(_wrap_FXTIFImage_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXTIFImage.klass, "mimeType", VALUEFUNC(_wrap_FXTIFImage_mimeType), -1);
+  rb_define_singleton_method(SwigClassFXTIFImage.klass, "supported_Sq_", VALUEFUNC(_wrap_FXTIFImage_supported_Sq_), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "setCodec", VALUEFUNC(_wrap_FXTIFImage_setCodec), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "getCodec", VALUEFUNC(_wrap_FXTIFImage_getCodec), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "save", VALUEFUNC(_wrap_FXTIFImage_save), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "load", VALUEFUNC(_wrap_FXTIFImage_load), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "create", VALUEFUNC(_wrap_FXTIFImage_create), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "detach", VALUEFUNC(_wrap_FXTIFImage_detach), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "destroy", VALUEFUNC(_wrap_FXTIFImage_destroy), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "resize", VALUEFUNC(_wrap_FXTIFImage_resize), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "restore", VALUEFUNC(_wrap_FXTIFImage_restore), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "render", VALUEFUNC(_wrap_FXTIFImage_render), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "release", VALUEFUNC(_wrap_FXTIFImage_release), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "scale", VALUEFUNC(_wrap_FXTIFImage_scale), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "mirror", VALUEFUNC(_wrap_FXTIFImage_mirror), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "rotate", VALUEFUNC(_wrap_FXTIFImage_rotate), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "crop", VALUEFUNC(_wrap_FXTIFImage_crop), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "fill", VALUEFUNC(_wrap_FXTIFImage_fill), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "fade", VALUEFUNC(_wrap_FXTIFImage_fade), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "xshear", VALUEFUNC(_wrap_FXTIFImage_xshear), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "yshear", VALUEFUNC(_wrap_FXTIFImage_yshear), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "hgradient", VALUEFUNC(_wrap_FXTIFImage_hgradient), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "vgradient", VALUEFUNC(_wrap_FXTIFImage_vgradient), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "gradient", VALUEFUNC(_wrap_FXTIFImage_gradient), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "blend", VALUEFUNC(_wrap_FXTIFImage_blend), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "savePixels", VALUEFUNC(_wrap_FXTIFImage_savePixels), -1);
+  rb_define_method(SwigClassFXTIFImage.klass, "loadPixels", VALUEFUNC(_wrap_FXTIFImage_loadPixels), -1);
+  SwigClassFXTIFImage.mark = (void (*)(void *)) FXRbTIFImage::markfunc;
+  SwigClassFXTIFImage.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXTIFImage.trackObjects = 0;
+  rb_define_module_function(mFox, "fxloadTIF", VALUEFUNC(_wrap_fxloadTIF), -1);
+  rb_define_module_function(mFox, "fxsaveTIF", VALUEFUNC(_wrap_fxsaveTIF), -1);
+  
+  SwigClassFXXBMImage.klass = rb_define_class_under(mFox, "FXXBMImage", ((swig_class *) SWIGTYPE_p_FXImage->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXXBMImage, (void *) &SwigClassFXXBMImage);
+  rb_define_alloc_func(SwigClassFXXBMImage.klass, _wrap_FXXBMImage_allocate);
+  rb_define_method(SwigClassFXXBMImage.klass, "initialize", VALUEFUNC(_wrap_new_FXXBMImage), -1);
+  rb_define_singleton_method(SwigClassFXXBMImage.klass, "fileExt", VALUEFUNC(_wrap_FXXBMImage_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXXBMImage.klass, "mimeType", VALUEFUNC(_wrap_FXXBMImage_mimeType), -1);
+  rb_define_method(SwigClassFXXBMImage.klass, "save", VALUEFUNC(_wrap_FXXBMImage_save), -1);
+  rb_define_method(SwigClassFXXBMImage.klass, "load", VALUEFUNC(_wrap_FXXBMImage_load), -1);
+  rb_define_method(SwigClassFXXBMImage.klass, "create", VALUEFUNC(_wrap_FXXBMImage_create), -1);
+  rb_define_method(SwigClassFXXBMImage.klass, "detach", VALUEFUNC(_wrap_FXXBMImage_detach), -1);
+  rb_define_method(SwigClassFXXBMImage.klass, "destroy", VALUEFUNC(_wrap_FXXBMImage_destroy), -1);
+  rb_define_method(SwigClassFXXBMImage.klass, "resize", VALUEFUNC(_wrap_FXXBMImage_resize), -1);
+  rb_define_method(SwigClassFXXBMImage.klass, "restore", VALUEFUNC(_wrap_FXXBMImage_restore), -1);
+  rb_define_method(SwigClassFXXBMImage.klass, "render", VALUEFUNC(_wrap_FXXBMImage_render), -1);
+  rb_define_method(SwigClassFXXBMImage.klass, "release", VALUEFUNC(_wrap_FXXBMImage_release), -1);
+  rb_define_method(SwigClassFXXBMImage.klass, "scale", VALUEFUNC(_wrap_FXXBMImage_scale), -1);
+  rb_define_method(SwigClassFXXBMImage.klass, "mirror", VALUEFUNC(_wrap_FXXBMImage_mirror), -1);
+  rb_define_method(SwigClassFXXBMImage.klass, "rotate", VALUEFUNC(_wrap_FXXBMImage_rotate), -1);
+  rb_define_method(SwigClassFXXBMImage.klass, "crop", VALUEFUNC(_wrap_FXXBMImage_crop), -1);
+  rb_define_method(SwigClassFXXBMImage.klass, "fill", VALUEFUNC(_wrap_FXXBMImage_fill), -1);
+  rb_define_method(SwigClassFXXBMImage.klass, "fade", VALUEFUNC(_wrap_FXXBMImage_fade), -1);
+  rb_define_method(SwigClassFXXBMImage.klass, "xshear", VALUEFUNC(_wrap_FXXBMImage_xshear), -1);
+  rb_define_method(SwigClassFXXBMImage.klass, "yshear", VALUEFUNC(_wrap_FXXBMImage_yshear), -1);
+  rb_define_method(SwigClassFXXBMImage.klass, "hgradient", VALUEFUNC(_wrap_FXXBMImage_hgradient), -1);
+  rb_define_method(SwigClassFXXBMImage.klass, "vgradient", VALUEFUNC(_wrap_FXXBMImage_vgradient), -1);
+  rb_define_method(SwigClassFXXBMImage.klass, "gradient", VALUEFUNC(_wrap_FXXBMImage_gradient), -1);
+  rb_define_method(SwigClassFXXBMImage.klass, "blend", VALUEFUNC(_wrap_FXXBMImage_blend), -1);
+  rb_define_method(SwigClassFXXBMImage.klass, "savePixels", VALUEFUNC(_wrap_FXXBMImage_savePixels), -1);
+  rb_define_method(SwigClassFXXBMImage.klass, "loadPixels", VALUEFUNC(_wrap_FXXBMImage_loadPixels), -1);
+  SwigClassFXXBMImage.mark = 0;
+  SwigClassFXXBMImage.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXXBMImage.trackObjects = 0;
+  rb_define_module_function(mFox, "fxloadXBM", VALUEFUNC(_wrap_fxloadXBM), -1);
+  rb_define_module_function(mFox, "fxsaveXBM", VALUEFUNC(_wrap_fxsaveXBM), -1);
+  rb_define_module_function(mFox, "fxsavePS", VALUEFUNC(_wrap_fxsavePS), -1);
+  rb_define_module_function(mFox, "fxcheckXBM", VALUEFUNC(_wrap_fxcheckXBM), -1);
+  
+  SwigClassFXXPMImage.klass = rb_define_class_under(mFox, "FXXPMImage", ((swig_class *) SWIGTYPE_p_FXImage->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXXPMImage, (void *) &SwigClassFXXPMImage);
+  rb_define_alloc_func(SwigClassFXXPMImage.klass, _wrap_FXXPMImage_allocate);
+  rb_define_method(SwigClassFXXPMImage.klass, "initialize", VALUEFUNC(_wrap_new_FXXPMImage), -1);
+  rb_define_singleton_method(SwigClassFXXPMImage.klass, "fileExt", VALUEFUNC(_wrap_FXXPMImage_fileExt), -1);
+  rb_define_singleton_method(SwigClassFXXPMImage.klass, "mimeType", VALUEFUNC(_wrap_FXXPMImage_mimeType), -1);
+  rb_define_method(SwigClassFXXPMImage.klass, "save", VALUEFUNC(_wrap_FXXPMImage_save), -1);
+  rb_define_method(SwigClassFXXPMImage.klass, "load", VALUEFUNC(_wrap_FXXPMImage_load), -1);
+  rb_define_method(SwigClassFXXPMImage.klass, "create", VALUEFUNC(_wrap_FXXPMImage_create), -1);
+  rb_define_method(SwigClassFXXPMImage.klass, "detach", VALUEFUNC(_wrap_FXXPMImage_detach), -1);
+  rb_define_method(SwigClassFXXPMImage.klass, "destroy", VALUEFUNC(_wrap_FXXPMImage_destroy), -1);
+  rb_define_method(SwigClassFXXPMImage.klass, "resize", VALUEFUNC(_wrap_FXXPMImage_resize), -1);
+  rb_define_method(SwigClassFXXPMImage.klass, "restore", VALUEFUNC(_wrap_FXXPMImage_restore), -1);
+  rb_define_method(SwigClassFXXPMImage.klass, "render", VALUEFUNC(_wrap_FXXPMImage_render), -1);
+  rb_define_method(SwigClassFXXPMImage.klass, "release", VALUEFUNC(_wrap_FXXPMImage_release), -1);
+  rb_define_method(SwigClassFXXPMImage.klass, "scale", VALUEFUNC(_wrap_FXXPMImage_scale), -1);
+  rb_define_method(SwigClassFXXPMImage.klass, "mirror", VALUEFUNC(_wrap_FXXPMImage_mirror), -1);
+  rb_define_method(SwigClassFXXPMImage.klass, "rotate", VALUEFUNC(_wrap_FXXPMImage_rotate), -1);
+  rb_define_method(SwigClassFXXPMImage.klass, "crop", VALUEFUNC(_wrap_FXXPMImage_crop), -1);
+  rb_define_method(SwigClassFXXPMImage.klass, "fill", VALUEFUNC(_wrap_FXXPMImage_fill), -1);
+  rb_define_method(SwigClassFXXPMImage.klass, "fade", VALUEFUNC(_wrap_FXXPMImage_fade), -1);
+  rb_define_method(SwigClassFXXPMImage.klass, "xshear", VALUEFUNC(_wrap_FXXPMImage_xshear), -1);
+  rb_define_method(SwigClassFXXPMImage.klass, "yshear", VALUEFUNC(_wrap_FXXPMImage_yshear), -1);
+  rb_define_method(SwigClassFXXPMImage.klass, "hgradient", VALUEFUNC(_wrap_FXXPMImage_hgradient), -1);
+  rb_define_method(SwigClassFXXPMImage.klass, "vgradient", VALUEFUNC(_wrap_FXXPMImage_vgradient), -1);
+  rb_define_method(SwigClassFXXPMImage.klass, "gradient", VALUEFUNC(_wrap_FXXPMImage_gradient), -1);
+  rb_define_method(SwigClassFXXPMImage.klass, "blend", VALUEFUNC(_wrap_FXXPMImage_blend), -1);
+  rb_define_method(SwigClassFXXPMImage.klass, "savePixels", VALUEFUNC(_wrap_FXXPMImage_savePixels), -1);
+  rb_define_method(SwigClassFXXPMImage.klass, "loadPixels", VALUEFUNC(_wrap_FXXPMImage_loadPixels), -1);
+  SwigClassFXXPMImage.mark = (void (*)(void *)) FXRbXPMImage::markfunc;
+  SwigClassFXXPMImage.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXXPMImage.trackObjects = 0;
+}
+
diff --git a/ext/fox16_c/impl.cpp b/ext/fox16_c/impl.cpp
index 408c363e..ed45a122 100644
--- a/ext/fox16_c/impl.cpp
+++ b/ext/fox16_c/impl.cpp
@@ -652,6 +652,8 @@ IMPLEMENT_FXWINDOW_STUBS(FXRbMessageBox)
 IMPLEMENT_FXTOPWINDOW_STUBS(FXRbMessageBox)
 IMPLEMENT_FXDIALOGBOX_STUBS(FXRbMessageBox)
 
+/* Start stub implementations for class FXRbObjRegistry */
+
 /* Start stub implementations for class FXRbObject */
 IMPLEMENT_FXOBJECT_STUBS(FXRbObject)
 
@@ -1024,7 +1026,7 @@ IMPLEMENT_FXID_STUBS(FXRbText)
 IMPLEMENT_FXDRAWABLE_STUBS(FXRbText)
 IMPLEMENT_FXWINDOW_STUBS(FXRbText)
 IMPLEMENT_FXSCROLLAREA_STUBS(FXRbText)
-IMPLEMENT_FXTEXT_STUBS(FXRbText)
+IMPLEMENT_FXTEXT_STUBS(FXRbText,FXText)
 
 /* Start stub implementations for class FXRbTextField */
 IMPLEMENT_FXOBJECT_STUBS(FXRbTextField)
diff --git a/ext/fox16_c/include/FXRbApp.h b/ext/fox16_c/include/FXRbApp.h
index 41fd1f5d..ff45ab06 100644
--- a/ext/fox16_c/include/FXRbApp.h
+++ b/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; \
@@ -46,7 +73,7 @@ static void cls ## _init(cls* self,VALUE ary,bool connect){ \
     argv[0]=const_cast<char *>("foo"); \
     for(i=1;i<argc;i++){ \
       VALUE e=rb_ary_entry(ary,i-1); \
-      argv[i]=StringValuePtr(e); \
+      argv[i]=StringValueCStr(e); \
       } \
     argv[argc]=0; \
     self->cls::init(argc,argv,connect); \
@@ -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,15 +123,15 @@ 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); \
-      argv[i]=StringValuePtr(e); \
+      argv[i]=StringValueCStr(e); \
       } \
     } \
   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
diff --git a/ext/fox16_c/include/FXRbBitmap.h b/ext/fox16_c/include/FXRbBitmap.h
index 1ee61485..b29db340 100644
--- a/ext/fox16_c/include/FXRbBitmap.h
+++ b/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); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbCommon.h b/ext/fox16_c/include/FXRbCommon.h
index 2e76475a..a211d2ee 100644
--- a/ext/fox16_c/include/FXRbCommon.h
+++ b/ext/fox16_c/include/FXRbCommon.h
@@ -24,13 +24,13 @@
  * $Id: FXRbCommon.h 2303 2005-12-09 03:17:28Z lyle $
  ***********************************************************************/
 
-extern "C" {
 #include "ruby.h"
 
+#include "extconf.h"
+
 #ifdef HAVE_RUBY_ENCODING_H
 #include "ruby/encoding.h"
 #endif
-}
 
 /**
  * The Ruby header files for Win32 redefine the symbol "select", which
@@ -97,3 +97,4 @@ extern "C" {
 #include "FXScintilla.h"
 #endif
 #include "FXRuby.h"
+#include "gvl_wrappers.h"
diff --git a/ext/fox16_c/include/FXRbCursor.h b/ext/fox16_c/include/FXRbCursor.h
index e941c21b..99dacea9 100644
--- a/ext/fox16_c/include/FXRbCursor.h
+++ b/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 {
diff --git a/ext/fox16_c/include/FXRbDC.h b/ext/fox16_c/include/FXRbDC.h
index 35bf11a6..2fd843ba 100644
--- a/ext/fox16_c/include/FXRbDC.h
+++ b/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); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbDialogBox.h b/ext/fox16_c/include/FXRbDialogBox.h
index 28eccf7c..4a748a48 100644
--- a/ext/fox16_c/include/FXRbDialogBox.h
+++ b/ext/fox16_c/include/FXRbDialogBox.h
@@ -28,14 +28,14 @@
 #define FXRBDIALOGBOX_H
 
 #define DECLARE_FXDIALOGBOX_STUBS(klass) \
-inline FXuint klass ## _execute(klass* self,FXuint placement){ \
+inline FXuint klass ## _execute_gvl(klass* self,FXuint placement){ \
   return self->klass::execute(placement); \
   }
 
 
 #define IMPLEMENT_FXDIALOGBOX_STUBS(cls) \
   FXuint cls::execute(FXuint placement){ \
-    return FXRbCallUIntMethod(this,rb_intern("execute"),placement); \
+    return FXRbCallUIntMethod(this,"execute",placement); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbDockBar.h b/ext/fox16_c/include/FXRbDockBar.h
index 9644f7f8..a797298b 100644
--- a/ext/fox16_c/include/FXRbDockBar.h
+++ b/ext/fox16_c/include/FXRbDockBar.h
@@ -40,13 +40,13 @@
 
 #define IMPLEMENT_FXDOCKBAR_STUBS(cls) \
   void cls::dock(FXDockSite* docksite,FXWindow* before,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("dock"),docksite,before,notify); \
+    FXRbCallVoidMethod(this,"dock",docksite,before,notify); \
     } \
   void cls::dock(FXDockSite* docksite,FXint localx,FXint localy,FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("dock"),docksite,localx,localy,notify); \
+    FXRbCallVoidMethod(this,"dock",docksite,localx,localy,notify); \
     } \
   void cls::undock(FXint rootx,FXint rooty, FXbool notify){ \
-    FXRbCallVoidMethod(this,rb_intern("undock"),rootx,rooty,notify); \
+    FXRbCallVoidMethod(this,"undock",rootx,rooty,notify); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbDockSite.h b/ext/fox16_c/include/FXRbDockSite.h
index 1d41db87..056dd0b1 100644
--- a/ext/fox16_c/include/FXRbDockSite.h
+++ b/ext/fox16_c/include/FXRbDockSite.h
@@ -43,16 +43,16 @@
 
 #define IMPLEMENT_FXDOCKSITE_STUBS(cls) \
   void cls::moveToolBar(FXDockBar* bar,FXint barx,FXint bary){ \
-    FXRbCallVoidMethod(this,rb_intern("moveToolBar"),bar,barx,bary); \
+    FXRbCallVoidMethod(this,"moveToolBar",bar,barx,bary); \
     } \
   void cls::dockToolBar(FXDockBar* bar,FXWindow* before){ \
-    FXRbCallVoidMethod(this,rb_intern("dockToolBar"),bar,before); \
+    FXRbCallVoidMethod(this,"dockToolBar",bar,before); \
     } \
   void cls::dockToolBar(FXDockBar* bar,FXint barx,FXint bary){ \
-    FXRbCallVoidMethod(this,rb_intern("dockToolBar"),bar,barx,bary); \
+    FXRbCallVoidMethod(this,"dockToolBar",bar,barx,bary); \
     } \
   void cls::undockToolBar(FXDockBar* bar){ \
-    FXRbCallVoidMethod(this,rb_intern("undockToolBar"),bar); \
+    FXRbCallVoidMethod(this,"undockToolBar",bar); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbDrawable.h b/ext/fox16_c/include/FXRbDrawable.h
index 74c86403..1775c6fa 100644
--- a/ext/fox16_c/include/FXRbDrawable.h
+++ b/ext/fox16_c/include/FXRbDrawable.h
@@ -35,7 +35,7 @@ inline void klass ## _resize(klass* self,FXint w,FXint h){ \
 
 #define IMPLEMENT_FXDRAWABLE_STUBS(cls) \
   void cls::resize(FXint w,FXint h){ \
-    FXRbCallVoidMethod(this,rb_intern("resize"),w,h); \
+    FXRbCallVoidMethod(this, "resize", w, h); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbFileDict.h b/ext/fox16_c/include/FXRbFileDict.h
index ed43af82..0ae083ba 100644
--- a/ext/fox16_c/include/FXRbFileDict.h
+++ b/ext/fox16_c/include/FXRbFileDict.h
@@ -61,13 +61,13 @@ inline FXFileAssoc* klass ## _findExecBinding(klass* self,const FXchar* pathname
 
 #define IMPLEMENT_FXFILEDICT_STUBS(cls) \
   FXFileAssoc* cls::findFileBinding(const FXchar* pathname){ \
-    return FXRbCallFileAssocMethod(this,rb_intern("findFileBinding"),pathname); \
+    return FXRbCallFileAssocMethod(this,"findFileBinding",pathname); \
     } \
   FXFileAssoc* cls::findDirBinding(const FXchar* pathname){ \
-    return FXRbCallFileAssocMethod(this,rb_intern("findDirBinding"),pathname); \
+    return FXRbCallFileAssocMethod(this,"findDirBinding",pathname); \
     } \
   FXFileAssoc* cls::findExecBinding(const FXchar* pathname){ \
-    return FXRbCallFileAssocMethod(this,rb_intern("findExecBinding"),pathname); \
+    return FXRbCallFileAssocMethod(this,"findExecBinding",pathname); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbFoldingList.h b/ext/fox16_c/include/FXRbFoldingList.h
index 7859137f..658336e2 100644
--- a/ext/fox16_c/include/FXRbFoldingList.h
+++ b/ext/fox16_c/include/FXRbFoldingList.h
@@ -74,46 +74,46 @@ inline void klass ## _destroy(klass* self){ \
 
 #define IMPLEMENT_FXFOLDINGITEM_STUBS(cls) \
   void cls::setText(const FXString& txt){ \
-    FXRbCallVoidMethod(this,rb_intern("setText"),txt); \
+    FXRbCallVoidMethod(this,"setText",txt); \
     } \
   void cls::setOpenIcon(FXIcon* icn,FXbool owned){ \
-    FXRbCallVoidMethod(this,rb_intern("setOpenIcon"),icn,owned); \
+    FXRbCallVoidMethod(this,"setOpenIcon",icn,owned); \
     } \
   void cls::setClosedIcon(FXIcon* icn,FXbool owned){ \
-    FXRbCallVoidMethod(this,rb_intern("setClosedIcon"),icn,owned); \
+    FXRbCallVoidMethod(this,"setClosedIcon",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::setOpened(FXbool opened){ \
-    FXRbCallVoidMethod(this,rb_intern("setOpened"),opened); \
+    FXRbCallVoidMethod(this,"setOpened",opened); \
     } \
   void cls::setExpanded(FXbool expanded){ \
-    FXRbCallVoidMethod(this,rb_intern("setExpanded"),expanded); \
+    FXRbCallVoidMethod(this,"setExpanded",expanded); \
     } \
   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 FXFoldingList* list) const { \
-    return FXRbCallIntMethod(this,rb_intern("getWidth"),list); \
+    return FXRbCallIntMethod(this,"getWidth",list); \
     } \
   FXint cls::getHeight(const FXFoldingList* list) const { \
-    return FXRbCallIntMethod(this,rb_intern("getHeight"),list); \
+    return FXRbCallIntMethod(this,"getHeight",list); \
     } \
   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"); \
     }
 
 
@@ -189,46 +189,46 @@ inline void klass ## _setCurrentItem(klass *self,FXFoldingItem *item,FXbool noti
 
 #define IMPLEMENT_FXFOLDINGLIST_STUBS(cls) \
   FXFoldingItem * cls::getItemAt(FXint x,FXint y) const { \
-    return FXRbCallFoldingItemMethod(this,rb_intern("getItemAt"),x,y); \
+    return FXRbCallFoldingItemMethod(this,"getItemAt",x,y); \
     } \
   void cls::makeItemVisible(FXFoldingItem *item) { \
-    FXRbCallVoidMethod(this,rb_intern("makeItemVisible"),item); \
+    FXRbCallVoidMethod(this,"makeItemVisible",item); \
     } \
   FXbool cls::enableItem(FXFoldingItem *item) { \
-    return FXRbCallBoolMethod(this,rb_intern("enableItem"),item); \
+    return FXRbCallBoolMethod(this,"enableItem",item); \
     } \
   FXbool cls::disableItem(FXFoldingItem *item) { \
-    return FXRbCallBoolMethod(this,rb_intern("disableItem"),item); \
+    return FXRbCallBoolMethod(this,"disableItem",item); \
     } \
   FXbool cls::selectItem(FXFoldingItem *item,FXbool notify) { \
-    return FXRbCallBoolMethod(this,rb_intern("selectItem"),item,notify); \
+    return FXRbCallBoolMethod(this,"selectItem",item,notify); \
     } \
   FXbool cls::deselectItem(FXFoldingItem *item,FXbool notify) { \
-    return FXRbCallBoolMethod(this,rb_intern("deselectItem"),item,notify); \
+    return FXRbCallBoolMethod(this,"deselectItem",item,notify); \
     } \
   FXbool cls::toggleItem(FXFoldingItem *item,FXbool notify) { \
-    return FXRbCallBoolMethod(this,rb_intern("toggleItem"),item,notify); \
+    return FXRbCallBoolMethod(this,"toggleItem",item,notify); \
     } \
   FXbool cls::extendSelection(FXFoldingItem *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(FXFoldingItem *item,FXbool notify) { \
-    return FXRbCallBoolMethod(this,rb_intern("openItem"),item,notify); \
+    return FXRbCallBoolMethod(this,"openItem",item,notify); \
     } \
   FXbool cls::closeItem(FXFoldingItem *item,FXbool notify) { \
-    return FXRbCallBoolMethod(this,rb_intern("closeItem"),item,notify); \
+    return FXRbCallBoolMethod(this,"closeItem",item,notify); \
     } \
   FXbool cls::collapseTree(FXFoldingItem *item,FXbool notify) { \
-    return FXRbCallBoolMethod(this,rb_intern("collapseTree"),item,notify); \
+    return FXRbCallBoolMethod(this,"collapseTree",item,notify); \
     } \
   FXbool cls::expandTree(FXFoldingItem *item,FXbool notify) { \
-    return FXRbCallBoolMethod(this,rb_intern("expandTree"),item,notify); \
+    return FXRbCallBoolMethod(this,"expandTree",item,notify); \
     } \
   void cls::setCurrentItem(FXFoldingItem *item,FXbool notify) { \
-    FXRbCallVoidMethod(this,rb_intern("setCurrentItem"),item,notify); \
+    FXRbCallVoidMethod(this,"setCurrentItem",item,notify); \
     }
 
 class FXRbFoldingList : public FXFoldingList {
diff --git a/ext/fox16_c/include/FXRbFont.h b/ext/fox16_c/include/FXRbFont.h
index 6e3cd1ce..2e27b232 100644
--- a/ext/fox16_c/include/FXRbFont.h
+++ b/ext/fox16_c/include/FXRbFont.h
@@ -85,58 +85,58 @@ inline FXint klass ## _getTextHeight(const klass* self,const FXString& str){ \
 
 #define IMPLEMENT_FXFONT_STUBS(cls) \
   void cls::setFontDesc(const FXFontDesc& desc) { \
-    FXRbCallVoidMethod(this,rb_intern("setFontDesc"),desc); \
+    FXRbCallVoidMethod(this,"setFontDesc",desc); \
     } \
   void cls::setAngle(FXint ang) { \
-    FXRbCallVoidMethod(this,rb_intern("setAngle"),ang); \
+    FXRbCallVoidMethod(this,"setAngle",ang); \
     } \
   void cls::setFont(const FXString& string) { \
-    FXRbCallVoidMethod(this,rb_intern("setFont"),string); \
+    FXRbCallVoidMethod(this,"setFont",string); \
     } \
   FXbool cls::isFontMono() const { \
-    return FXRbCallBoolMethod(this,rb_intern("isFontMono")); \
+    return FXRbCallBoolMethod(this,"isFontMono"); \
     } \
   FXbool cls::hasChar(FXwchar ch) const { \
-    return FXRbCallBoolMethod(this,rb_intern("hasChar"),ch); \
+    return FXRbCallBoolMethod(this,"hasChar",ch); \
     } \
   FXwchar cls::getMinChar() const { \
-    return FXRbCallWCharMethod(this,rb_intern("getMinChar")); \
+    return FXRbCallWCharMethod(this,"getMinChar"); \
     } \
   FXwchar cls::getMaxChar() const { \
-    return FXRbCallWCharMethod(this,rb_intern("getMaxChar")); \
+    return FXRbCallWCharMethod(this,"getMaxChar"); \
     } \
   FXint cls::leftBearing(FXwchar ch) const { \
-    return FXRbCallIntMethod(this,rb_intern("leftBearing"),ch); \
+    return FXRbCallIntMethod(this,"leftBearing",ch); \
     } \
   FXint cls::rightBearing(FXwchar ch) const { \
-    return FXRbCallIntMethod(this,rb_intern("rightBearing"),ch); \
+    return FXRbCallIntMethod(this,"rightBearing",ch); \
     } \
   FXint cls::getFontWidth() const { \
-    return FXRbCallIntMethod(this,rb_intern("getFontWidth")); \
+    return FXRbCallIntMethod(this,"getFontWidth"); \
     } \
   FXint cls::getFontHeight() const { \
-    return FXRbCallIntMethod(this,rb_intern("getFontHeight")); \
+    return FXRbCallIntMethod(this,"getFontHeight"); \
     } \
   FXint cls::getFontAscent() const { \
-    return FXRbCallIntMethod(this,rb_intern("getFontAscent")); \
+    return FXRbCallIntMethod(this,"getFontAscent"); \
     } \
   FXint cls::getFontDescent() const { \
-    return FXRbCallIntMethod(this,rb_intern("getFontDescent")); \
+    return FXRbCallIntMethod(this,"getFontDescent"); \
     } \
   FXint cls::getFontLeading() const { \
-    return FXRbCallIntMethod(this,rb_intern("getFontLeading")); \
+    return FXRbCallIntMethod(this,"getFontLeading"); \
     } \
   FXint cls::getFontSpacing() const { \
-    return FXRbCallIntMethod(this,rb_intern("getFontSpacing")); \
+    return FXRbCallIntMethod(this,"getFontSpacing"); \
     } \
   FXint cls::getCharWidth(FXwchar ch) const { \
-    return FXRbCallIntMethod(this,rb_intern("getCharWidth"),ch); \
+    return FXRbCallIntMethod(this,"getCharWidth",ch); \
     } \
   FXint cls::getTextWidth(const FXString& str) const { \
-    return FXRbCallIntMethod(this,rb_intern("getTextWidth"),str); \
+    return FXRbCallIntMethod(this,"getTextWidth",str); \
     } \
   FXint cls::getTextHeight(const FXString& str) const { \
-    return FXRbCallIntMethod(this,rb_intern("getTextHeight"),str); \
+    return FXRbCallIntMethod(this,"getTextHeight",str); \
     }
 
 class FXRbFont : public FXFont {
diff --git a/ext/fox16_c/include/FXRbGLCanvas.h b/ext/fox16_c/include/FXRbGLCanvas.h
index 78917ddb..b82029c7 100644
--- a/ext/fox16_c/include/FXRbGLCanvas.h
+++ b/ext/fox16_c/include/FXRbGLCanvas.h
@@ -44,16 +44,16 @@ inline void klass ## _swapBuffers(klass* self){ \
 
 #define IMPLEMENT_FXGLCANVAS_STUBS(cls) \
   FXbool cls::makeCurrent(){ \
-    return FXRbCallBoolMethod(this,rb_intern("makeCurrent")); \
+    return FXRbCallBoolMethod(this,"makeCurrent"); \
     } \
   FXbool cls::makeNonCurrent(){ \
-    return FXRbCallBoolMethod(this,rb_intern("makeNonCurrent")); \
+    return FXRbCallBoolMethod(this,"makeNonCurrent"); \
     } \
   FXbool cls::isCurrent() const { \
-    return FXRbCallBoolMethod(this,rb_intern("isCurrent")); \
+    return FXRbCallBoolMethod(this,"isCurrent"); \
     } \
   void cls::swapBuffers(){ \
-    FXRbCallVoidMethod(this,rb_intern("swapBuffers")); \
+    FXRbCallVoidMethod(this,"swapBuffers"); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbGLObject.h b/ext/fox16_c/include/FXRbGLObject.h
index 7c0646c1..87cd2c03 100644
--- a/ext/fox16_c/include/FXRbGLObject.h
+++ b/ext/fox16_c/include/FXRbGLObject.h
@@ -55,28 +55,28 @@ inline FXbool klass ## _drag(klass* self,FXGLViewer* viewer,FXint fx,FXint fy,FX
 
 #define IMPLEMENT_FXGLOBJECT_STUBS(cls) \
   void cls::bounds(FXRangef& box){ \
-    box=FXRbCallRangeMethod(this,rb_intern("bounds")); \
+    box=FXRbCallRangeMethod(this,"bounds"); \
     } \
   void cls::draw(FXGLViewer* viewer){ \
-    FXRbCallVoidMethod(this,rb_intern("draw"),viewer); \
+    FXRbCallVoidMethod(this,"draw",viewer); \
     } \
   void cls::hit(FXGLViewer* viewer){ \
-    FXRbCallVoidMethod(this,rb_intern("hit"),viewer); \
+    FXRbCallVoidMethod(this,"hit",viewer); \
     } \
   FXGLObject* cls::copy(){ \
-    return FXRbCallGLObjectMethod(this,rb_intern("copy")); \
+    return FXRbCallGLObjectMethod(this,"copy"); \
     } \
   FXGLObject* cls::identify(FXuint* path,FXint n){ \
-    return FXRbCallGLObjectMethod(this,rb_intern("identify"),path,n); \
+    return FXRbCallGLObjectMethod(this,"identify",path,n); \
     } \
   FXbool cls::canDrag() const { \
-    return FXRbCallBoolMethod(this,rb_intern("canDrag")); \
+    return FXRbCallBoolMethod(this,"canDrag"); \
     } \
   FXbool cls::canDelete() const{ \
-    return FXRbCallBoolMethod(this,rb_intern("canDelete")); \
+    return FXRbCallBoolMethod(this,"canDelete"); \
     } \
   FXbool cls::drag(FXGLViewer* viewer,FXint fx,FXint fy,FXint tx,FXint ty){ \
-    return FXRbCallBoolMethod(this,rb_intern("drag"),viewer,fx,fy,tx,ty); \
+    return FXRbCallBoolMethod(this,"drag",viewer,fx,fy,tx,ty); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbGLShape.h b/ext/fox16_c/include/FXRbGLShape.h
index e1c10ec9..f5f15043 100644
--- a/ext/fox16_c/include/FXRbGLShape.h
+++ b/ext/fox16_c/include/FXRbGLShape.h
@@ -35,7 +35,7 @@ inline void klass ## _drawshape(klass* self,FXGLViewer* viewer){ \
 
 #define IMPLEMENT_FXGLSHAPE_STUBS(klass,superklass) \
   void klass::drawshape(FXGLViewer* viewer){ \
-    FXRbCallVoidMethod(this,rb_intern("drawshape"),viewer); \
+    FXRbCallVoidMethod(this,"drawshape",viewer); \
     } \
   void klass::_drawshape(FXGLViewer* viewer){ \
     superklass::drawshape(viewer); \
diff --git a/ext/fox16_c/include/FXRbGLViewer.h b/ext/fox16_c/include/FXRbGLViewer.h
index b9880e64..09406554 100644
--- a/ext/fox16_c/include/FXRbGLViewer.h
+++ b/ext/fox16_c/include/FXRbGLViewer.h
@@ -42,13 +42,13 @@ inline FXbool klass ## _setBounds(klass *self,const FXRangef& box){ \
 
 #define IMPLEMENT_FXGLVIEWER_STUBS(cls) \
   FXGLObject** cls::select(FXint x,FXint y,FXint w,FXint h){ \
-    return FXRbCallGLObjectArrayMethod(this,rb_intern("select"),x,y,w,h); \
+    return FXRbCallGLObjectArrayMethod(this,"select",x,y,w,h); \
     } \
   FXGLObject* cls::pick(FXint x,FXint y){ \
-    return FXRbCallGLObjectMethod(this,rb_intern("pick"),x,y); \
+    return FXRbCallGLObjectMethod(this,"pick",x,y); \
     } \
   FXbool cls::setBounds(const FXRangef& box){ \
-    return FXRbCallBoolMethod(this,rb_intern("setBounds"),box); \
+    return FXRbCallBoolMethod(this,"setBounds",box); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbHeader.h b/ext/fox16_c/include/FXRbHeader.h
index f83d61d4..c89f0f61 100644
--- a/ext/fox16_c/include/FXRbHeader.h
+++ b/ext/fox16_c/include/FXRbHeader.h
@@ -53,25 +53,25 @@ inline void klass ## _destroy(klass* self){ \
 
 #define IMPLEMENT_FXHEADERITEM_STUBS(cls) \
   void cls::setText(const FXString& text){ \
-    FXRbCallVoidMethod(this,rb_intern("setText"),text); \
+    FXRbCallVoidMethod(this,"setText",text); \
     } \
   void cls::setIcon(FXIcon* icn){ \
-    FXRbCallVoidMethod(this,rb_intern("setIcon"),icn); \
+    FXRbCallVoidMethod(this,"setIcon",icn); \
     } \
   FXint cls::getWidth(const FXHeader* header) const { \
-    return FXRbCallIntMethod(this,rb_intern("getWidth"),header); \
+    return FXRbCallIntMethod(this,"getWidth",header); \
     } \
   FXint cls::getHeight(const FXHeader* header) const { \
-    return FXRbCallIntMethod(this,rb_intern("getHeight"),header); \
+    return FXRbCallIntMethod(this,"getHeight",header); \
     } \
   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"); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbIconList.h b/ext/fox16_c/include/FXRbIconList.h
index 15b0ae12..b92ff205 100644
--- a/ext/fox16_c/include/FXRbIconList.h
+++ b/ext/fox16_c/include/FXRbIconList.h
@@ -88,70 +88,70 @@ inline void klass ## _destroy(klass* self){ \
 
 #define IMPLEMENT_FXICONITEM_STUBS(klass,superklass) \
   void klass::draw(const FXIconList* list,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const { \
-    FXRbCallVoidMethod(this,rb_intern("draw"),list,dc,x,y,w,h); \
+    FXRbCallVoidMethod(this,"draw",list,dc,x,y,w,h); \
     } \
   void klass::public_draw(const FXIconList* list,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const { \
     superklass::draw(list,dc,x,y,w,h); \
     } \
   FXint klass::hitItem(const FXIconList* list,FXint rx,FXint ry,FXint rw,FXint rh) const { \
-    return FXRbCallIntMethod(this,rb_intern("hitItem"),list,rx,ry,rw,rh); \
+    return FXRbCallIntMethod(this,"hitItem",list,rx,ry,rw,rh); \
     } \
   FXint klass::public_hitItem(const FXIconList* list,FXint rx,FXint ry,FXint rw,FXint rh) const { \
     return superklass::hitItem(list,rx,ry,rw,rh); \
     } \
   void klass::drawBigIcon(const FXIconList* list,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const { \
-    FXRbCallVoidMethod(this,rb_intern("drawBigIcon"),list,dc,x,y,w,h); \
+    FXRbCallVoidMethod(this,"drawBigIcon",list,dc,x,y,w,h); \
     } \
   void klass::public_drawBigIcon(const FXIconList* list,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const { \
     superklass::drawBigIcon(list,dc,x,y,w,h); \
     } \
   void klass::drawMiniIcon(const FXIconList* list,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const { \
-    FXRbCallVoidMethod(this,rb_intern("drawMiniIcon"),list,dc,x,y,w,h); \
+    FXRbCallVoidMethod(this,"drawMiniIcon",list,dc,x,y,w,h); \
     } \
   void klass::public_drawMiniIcon(const FXIconList* list,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const { \
     superklass::drawMiniIcon(list,dc,x,y,w,h); \
     } \
   void klass::drawDetails(const FXIconList* list,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const { \
-    FXRbCallVoidMethod(this,rb_intern("drawDetails"),list,dc,x,y,w,h); \
+    FXRbCallVoidMethod(this,"drawDetails",list,dc,x,y,w,h); \
     } \
   void klass::public_drawDetails(const FXIconList* list,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const { \
     superklass::drawDetails(list,dc,x,y,w,h); \
     } \
   void klass::setText(const FXString& txt){ \
-    FXRbCallVoidMethod(this,rb_intern("setText"),txt); \
+    FXRbCallVoidMethod(this,"setText",txt); \
     } \
   void klass::setBigIcon(FXIcon* icn,FXbool owned){ \
-    FXRbCallVoidMethod(this,rb_intern("setBigIcon"),icn,owned); \
+    FXRbCallVoidMethod(this,"setBigIcon",icn,owned); \
     } \
   void klass::setMiniIcon(FXIcon* icn,FXbool owned){ \
-    FXRbCallVoidMethod(this,rb_intern("setMiniIcon"),icn,owned); \
+    FXRbCallVoidMethod(this,"setMiniIcon",icn,owned); \
     } \
   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); \
     } \
   FXint klass::getWidth(const FXIconList* list) const { \
-    return FXRbCallIntMethod(this,rb_intern("getWidth"),list); \
+    return FXRbCallIntMethod(this,"getWidth",list); \
     } \
   FXint klass::getHeight(const FXIconList* 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"); \
     }
 
 
@@ -219,37 +219,37 @@ inline FXbool klass ## _disableItem(klass* self,FXint index){ \
 
 #define IMPLEMENT_FXICONLIST_STUBS(cls) \
   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::selectInRectangle(FXint x,FXint y,FXint w,FXint h,FXbool notify){ \
-    return FXRbCallBoolMethod(this,rb_intern("selectInRectangle"),x,y,w,h,notify); \
+    return FXRbCallBoolMethod(this,"selectInRectangle",x,y,w,h,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); \
     } \
   FXint cls::getItemAt(FXint x,FXint y) const { \
-    return FXRbCallIntMethod(this,rb_intern("getItemAt"),x,y); \
+    return FXRbCallIntMethod(this,"getItemAt",x,y); \
     } \
   void cls::makeItemVisible(FXint index){ \
-    FXRbCallVoidMethod(this,rb_intern("makeItemVisible"),index); \
+    FXRbCallVoidMethod(this,"makeItemVisible",index); \
     } \
   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); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbIconSource.h b/ext/fox16_c/include/FXRbIconSource.h
index d512d725..bf8d22b2 100644
--- a/ext/fox16_c/include/FXRbIconSource.h
+++ b/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); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbId.h b/ext/fox16_c/include/FXRbId.h
index e11fce4f..0db8c020 100644
--- a/ext/fox16_c/include/FXRbId.h
+++ b/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"); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbImage.h b/ext/fox16_c/include/FXRbImage.h
index c071d8d6..d7f80304 100644
--- a/ext/fox16_c/include/FXRbImage.h
+++ b/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); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbList.h b/ext/fox16_c/include/FXRbList.h
index e6b1d423..54e2dea7 100644
--- a/ext/fox16_c/include/FXRbList.h
+++ b/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); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbListBox.h b/ext/fox16_c/include/FXRbListBox.h
index ff4fc8b3..48cb3379 100644
--- a/ext/fox16_c/include/FXRbListBox.h
+++ b/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 {
diff --git a/ext/fox16_c/include/FXRbMDIChild.h b/ext/fox16_c/include/FXRbMDIChild.h
index 3b5dfce5..369d98ec 100644
--- a/ext/fox16_c/include/FXRbMDIChild.h
+++ b/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); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbMDIClient.h b/ext/fox16_c/include/FXRbMDIClient.h
index b4ddddbe..714ad871 100644
--- a/ext/fox16_c/include/FXRbMDIClient.h
+++ b/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 {
diff --git a/ext/fox16_c/include/FXRbObjRegistry.h b/ext/fox16_c/include/FXRbObjRegistry.h
new file mode 100644
index 00000000..8475ff21
--- /dev/null
+++ b/ext/fox16_c/include/FXRbObjRegistry.h
@@ -0,0 +1,98 @@
+/***********************************************************************
+ * FXRuby -- the Ruby language bindings for the FOX GUI toolkit.
+ * Copyright (c) 2017-2017 by Lyle Johnson. All Rights Reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * For further information please contact the author by e-mail
+ * at "lars@greiz-reinsdorf.de".
+ ***********************************************************************/
+
+#ifndef FXRBOBJREGISTRY_H
+#define FXRBOBJREGISTRY_H
+
+extern "C" {
+  // Opaque type declaration for SWIG runtime support
+  struct swig_type_info;
+}
+
+class FXRbObjRegistry {
+
+  /**
+  * The FXRuby_Objects hash table basically maps C++ objects to Ruby instances.
+  * Each key in the table is a pointer to a C++ object we've seen before, and
+  * the corresponding value is an FXRubyObjDesc struct (see below) that tells
+  * us which Ruby instance corresponds to that C++ object.
+  */
+
+  st_table * FXRuby_Objects;
+
+  /**
+  * Each value in the FXRuby_Objects hash table is an instance of this
+  * struct. It identifies the Ruby instance associated with a C++ object.
+  * It also indicates whether this is merely a "borrowed" reference to
+  * some C++ object (i.e. it's not one we need to destroy later).
+  *
+  * in_gc is set for FXWindows that are in garbage collection and must
+  * not call ruby code anymore.
+  */
+
+  enum ObjType { own, borrowed, callback };
+
+  struct ObjDesc {
+    VALUE obj;
+    enum ObjType type;
+    bool in_gc;
+  };
+
+  const char * safe_rb_obj_classname(VALUE obj);
+
+public:
+
+  FXRbObjRegistry();
+
+  /**
+  * NewBorrowedObj() is a wrapper around SWIG_Ruby_NewPointerObj() that also
+  * registers this C++ object & Ruby instance pair in our FXRuby_Objects
+  * hash table. This function should only get called for methods that return
+  * a reference to an already-existing C++ object (i.e. one that FOX "owns")
+  * and for that reason we mark these objects as "borrowed".
+  */
+  VALUE NewBorrowedObj(void *ptr,swig_type_info* ty);
+
+  // Register this Ruby class instance
+  void RegisterRubyObj(VALUE rubyObj,const void* foxObj);
+
+  void UnregisterRubyObj(const void* foxObj, bool alsoOwned);
+
+  /**
+  * Return the registered Ruby class instance associated with this
+  * FOX object, or Qnil if not found.
+  */
+  VALUE GetRubyObj(const void *foxObj,bool alsoBorrowed, bool in_gc_mark=false);
+
+  /**
+  * FXRbIsBorrowed() returns true if the specified C++ object is one that
+  * FOX owns (i.e. it's borrowed).
+  */
+  bool IsBorrowed(void* ptr);
+
+  bool SetInGC(const void* ptr, bool enabled);
+  bool IsInGC(const void* ptr);
+
+  static FXRbObjRegistry main;
+};
+
+#endif
diff --git a/ext/fox16_c/include/FXRbObject.h b/ext/fox16_c/include/FXRbObject.h
index 50a86ff4..3a75a432 100644
--- a/ext/fox16_c/include/FXRbObject.h
+++ b/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); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbPopup.h b/ext/fox16_c/include/FXRbPopup.h
index cec6e3b2..1b142167 100644
--- a/ext/fox16_c/include/FXRbPopup.h
+++ b/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"); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbRealSpinner.h b/ext/fox16_c/include/FXRbRealSpinner.h
index 89a17230..4692bc63 100644
--- a/ext/fox16_c/include/FXRbRealSpinner.h
+++ b/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); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbScrollArea.h b/ext/fox16_c/include/FXRbScrollArea.h
index 4014502d..43a27eb9 100644
--- a/ext/fox16_c/include/FXRbScrollArea.h
+++ b/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"); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbShutter.h b/ext/fox16_c/include/FXRbShutter.h
index 5d60b2f2..ccc34362 100644
--- a/ext/fox16_c/include/FXRbShutter.h
+++ b/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); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbSpinner.h b/ext/fox16_c/include/FXRbSpinner.h
index cdedffa1..0027886a 100644
--- a/ext/fox16_c/include/FXRbSpinner.h
+++ b/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); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbStream.h b/ext/fox16_c/include/FXRbStream.h
index f9a3d670..982813a4 100644
--- a/ext/fox16_c/include/FXRbStream.h
+++ b/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); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbTabBar.h b/ext/fox16_c/include/FXRbTabBar.h
index c2e1b63f..539a8559 100644
--- a/ext/fox16_c/include/FXRbTabBar.h
+++ b/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); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbTable.h b/ext/fox16_c/include/FXRbTable.h
index 7eca5671..6a3f60b6 100644
--- a/ext/fox16_c/include/FXRbTable.h
+++ b/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 {
diff --git a/ext/fox16_c/include/FXRbText.h b/ext/fox16_c/include/FXRbText.h
index ec9e5821..a0d9a1b2 100644
--- a/ext/fox16_c/include/FXRbText.h
+++ b/ext/fox16_c/include/FXRbText.h
@@ -27,7 +27,39 @@
 #ifndef FXRBTEXT_H
 #define FXRBTEXT_H
 
-#define DECLARE_FXTEXT_STUBS(klass) \
+#define DECLARE_FXTEXT_STUBS(klass,subklass) \
+inline void klass ## _eraseCursorOverhang(klass* self){ \
+  FXASSERT(self->isMemberOf(FXMETACLASS(subklass))); \
+  dynamic_cast<subklass*>(self)->public_eraseCursorOverhang(); \
+  } \
+inline void klass ## _drawCursor(klass* self,FXuint state){ \
+  FXASSERT(self->isMemberOf(FXMETACLASS(subklass))); \
+  dynamic_cast<subklass*>(self)->public_drawCursor(state); \
+  } \
+inline FXuint klass ## _style(klass* self,FXint row,FXint beg,FXint end,FXint pos){ \
+  FXASSERT(self->isMemberOf(FXMETACLASS(subklass))); \
+  return dynamic_cast<subklass*>(self)->public_style(row, beg, end, pos); \
+  } \
+inline void klass ## _drawBufferText(klass* self,FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h,FXint pos,FXint n,FXuint style){ \
+  FXASSERT(self->isMemberOf(FXMETACLASS(subklass))); \
+  dynamic_cast<subklass*>(self)->public_drawBufferText(dc, x, y, w, h, pos, n, style); \
+  } \
+inline void klass ## _fillBufferRect(klass* self,FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h,FXuint style){ \
+  FXASSERT(self->isMemberOf(FXMETACLASS(subklass))); \
+  dynamic_cast<subklass*>(self)->public_fillBufferRect(dc, x, y, w, h, style); \
+  } \
+inline void klass ## _drawTextRow(klass* self,FXDCWindow& dc,FXint line,FXint left,FXint right){ \
+  FXASSERT(self->isMemberOf(FXMETACLASS(subklass))); \
+  dynamic_cast<subklass*>(self)->public_drawTextRow(dc, line, left, right); \
+  } \
+inline void klass ## _drawContents(klass* self,FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h){ \
+  FXASSERT(self->isMemberOf(FXMETACLASS(subklass))); \
+  dynamic_cast<subklass*>(self)->public_drawContents(dc, x, y, w, h); \
+  } \
+inline void klass ## _drawNumbers(klass* self,FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h){ \
+  FXASSERT(self->isMemberOf(FXMETACLASS(subklass))); \
+  dynamic_cast<subklass*>(self)->public_drawNumbers(dc, x, y, w, h); \
+  } \
 inline void klass ## _setCursorPos(klass* self,FXint pos,FXbool notify){ \
   self->klass::setCursorPos(pos,notify); \
   } \
@@ -72,75 +104,123 @@ inline void klass ## _setStyledText(klass* self,const FXString& text,FXint style
   }
 
 
-#define IMPLEMENT_FXTEXT_STUBS(cls) \
+#define IMPLEMENT_FXTEXT_STUBS(cls,superklass) \
+  void cls::eraseCursorOverhang(){ \
+    FXRbCallVoidMethod(this,"eraseCursorOverhang"); \
+    } \
+  void cls::public_eraseCursorOverhang(){ \
+    superklass::eraseCursorOverhang(); \
+    } \
+  void cls::drawCursor(FXuint state){ \
+    FXRbCallVoidMethod(this,"drawCursor", state); \
+    } \
+  void cls::public_drawCursor(FXuint state){ \
+    superklass::drawCursor(state); \
+    } \
+  FXuint cls::style(FXint row,FXint beg,FXint end,FXint pos){ \
+    return FXRbCallUIntMethod(this,"style", row, beg, end, pos); \
+    } \
+  FXuint cls::public_style(FXint row,FXint beg,FXint end,FXint pos){ \
+    return superklass::style(row, beg, end, pos); \
+    } \
+  void cls::drawBufferText(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h,FXint pos,FXint n,FXuint style){ \
+    FXRbCallVoidMethod(this,"drawBufferText", dc, x, y, w, h, pos, n, style); \
+    } \
+  void cls::public_drawBufferText(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h,FXint pos,FXint n,FXuint style){ \
+    superklass::drawBufferText(dc, x, y, w, h, pos, n, style); \
+    } \
+  void cls::fillBufferRect(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h,FXuint style){ \
+    FXRbCallVoidMethod(this,"fillBufferRect", dc, x, y, w, h, style); \
+    } \
+  void cls::public_fillBufferRect(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h,FXuint style){ \
+    superklass::fillBufferRect(dc, x, y, w, h, style); \
+    } \
+  void cls::drawTextRow(FXDCWindow& dc,FXint line,FXint left,FXint right){ \
+    FXRbCallVoidMethod(this,"drawTextRow", dc, line, left, right); \
+    } \
+  void cls::public_drawTextRow(FXDCWindow& dc,FXint line,FXint left,FXint right){ \
+    superklass::drawTextRow(dc, line, left, right); \
+    } \
+  void cls::drawContents(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h){ \
+    FXRbCallVoidMethod(this,"drawContents", dc, x, y, w, h); \
+    } \
+  void cls::public_drawContents(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h){ \
+    superklass::drawContents(dc, x, y, w, h); \
+    } \
+  void cls::drawNumbers(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h){ \
+    FXRbCallVoidMethod(this,"drawNumbers", dc, x, y, w, h); \
+    } \
+  void cls::public_drawNumbers(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h){ \
+    superklass::drawNumbers(dc, x, y, w, h); \
+    } \
   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); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbTextVirtuals.h b/ext/fox16_c/include/FXRbTextVirtuals.h
index ea848c50..71062002 100644
--- a/ext/fox16_c/include/FXRbTextVirtuals.h
+++ b/ext/fox16_c/include/FXRbTextVirtuals.h
@@ -1,3 +1,25 @@
+protected:
+  // Overrides the base class versions of these virtual functions
+  virtual void eraseCursorOverhang();
+  virtual void drawCursor(FXuint state);
+  virtual FXuint style(FXint row,FXint beg,FXint end,FXint pos);
+  virtual void drawBufferText(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h,FXint pos,FXint n,FXuint style);
+  virtual void fillBufferRect(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h,FXuint style);
+  virtual void drawTextRow(FXDCWindow& dc,FXint line,FXint left,FXint right);
+  virtual void drawContents(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
+  virtual void drawNumbers(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
+
+public:
+  // Publically accessible versions of those protected functions
+  void public_eraseCursorOverhang();
+  void public_drawCursor(FXuint state);
+  FXuint public_style(FXint row,FXint beg,FXint end,FXint pos);
+  void public_drawBufferText(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h,FXint pos,FXint n,FXuint style);
+  void public_fillBufferRect(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h,FXuint style);
+  void public_drawTextRow(FXDCWindow& dc,FXint line,FXint left,FXint right);
+  void public_drawContents(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
+  void public_drawNumbers(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
+
 public:
   // Overrides the base class version of setCursorPos()
   virtual void setCursorPos(FXint pos,FXbool notify=FALSE);
diff --git a/ext/fox16_c/include/FXRbTopWindow.h b/ext/fox16_c/include/FXRbTopWindow.h
index fef45bec..1b1d78ca 100644
--- a/ext/fox16_c/include/FXRbTopWindow.h
+++ b/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); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbTranslator.h b/ext/fox16_c/include/FXRbTranslator.h
index 64418c55..7bf6dbe5 100644
--- a/ext/fox16_c/include/FXRbTranslator.h
+++ b/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 {
diff --git a/ext/fox16_c/include/FXRbTreeList.h b/ext/fox16_c/include/FXRbTreeList.h
index 608ebcc1..02951bf5 100644
--- a/ext/fox16_c/include/FXRbTreeList.h
+++ b/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); \
     }
 
 
diff --git a/ext/fox16_c/include/FXRbTreeListBox.h b/ext/fox16_c/include/FXRbTreeListBox.h
index f28b609a..2980d509 100644
--- a/ext/fox16_c/include/FXRbTreeListBox.h
+++ b/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 {
diff --git a/ext/fox16_c/include/FXRbWindow.h b/ext/fox16_c/include/FXRbWindow.h
index 1e702339..e3c0a181 100644
--- a/ext/fox16_c/include/FXRbWindow.h
+++ b/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 {
diff --git a/ext/fox16_c/include/FXRuby.h b/ext/fox16_c/include/FXRuby.h
index d54a3e7a..00aaf196 100644
--- a/ext/fox16_c/include/FXRuby.h
+++ b/ext/fox16_c/include/FXRuby.h
@@ -27,20 +27,6 @@
 #ifndef FXRUBY_H
 #define FXRUBY_H
 
-// RARRAY_LEN, RARRAY_PTR, RSTRING_LEN and RSTRING_PTR macros not defined before Ruby 1.8.6
-#ifndef RARRAY_LEN
-#define RARRAY_LEN(a) RARRAY((a))->len
-#endif
-#ifndef RARRAY_PTR
-#define RARRAY_PTR(a) RARRAY((a))->ptr
-#endif
-#ifndef RSTRING_LEN
-#define RSTRING_LEN(s) RSTRING((s))->len
-#endif
-#ifndef RSTRING_PTR
-#define RSTRING_PTR(s) RSTRING((s))->ptr
-#endif
-
 #ifndef NUM2SIZET
 #define NUM2SIZET(s) NUM2ULONG(s)
 #endif
@@ -55,16 +41,14 @@ struct swig_type_info;
 extern "C" {
 static const char * SWIG_TypeName(const swig_type_info *ty);
 static VALUE SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int own);
-#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
-typedef void (*ruby_owntype)(void*);
-static int SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, ruby_owntype *own);
+static int FXSWIG_ConvertPtr(VALUE obj, void **ptr, swig_type_info *ty, int flags);
 }
 
 // Helper for overloaded show() functions
 template <class TYPE>
 VALUE showHelper(VALUE self, int argc, VALUE *argv, TYPE *p, swig_type_info *typeinfo) {
   TYPE *win;
-  SWIG_ConvertPtr(self,(void**)&win,typeinfo,1);
+  FXSWIG_ConvertPtr(self,(void**)&win,typeinfo,1);
   if (argc == 0) {
     win->_show();
     }
@@ -80,6 +64,7 @@ VALUE showHelper(VALUE self, int argc, VALUE *argv, TYPE *p, swig_type_info *typ
 
 // Wrapper around SWIG_Ruby_NewPointerObj()
 VALUE FXRbNewPointerObj(void *ptr, swig_type_info *typeinfo);
+VALUE FXRbNewPointerObjCb(void *ptr, swig_type_info *typeinfo);
 bool FXRbIsBorrowed(void* ptr);
 bool FXRbSetInGC(const void* ptr, bool enabled);
 bool FXRbIsInGC(const void* ptr);
@@ -91,8 +76,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);
@@ -117,7 +104,7 @@ void FXRbDestroyAppSensitiveObjects();
  * FOX object (if any). If searchBoth is false, only considers the
  * Ruby-owned objects; otherwise considers all outstanding references.
  */
-VALUE FXRbGetRubyObj(const void *foxObj, bool searchBoth);
+VALUE FXRbGetRubyObj(const void *foxObj, bool searchBoth, bool in_gc_mark=false);
 
 /**
  * Return the registered Ruby class instance associated with this
@@ -125,6 +112,8 @@ VALUE FXRbGetRubyObj(const void *foxObj, bool searchBoth);
  */
 VALUE FXRbGetRubyObj(const void *foxObj, const char *type);
 VALUE FXRbGetRubyObj(const void *foxObj, swig_type_info *type);
+VALUE FXRbGetRubyObjCb(const void *foxObj, swig_type_info *type);
+
 
 // Mark this object as used for the garbage collector
 void FXRbGcMark(void *obj);
@@ -168,10 +157,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);
@@ -322,6 +311,64 @@ inline VALUE to_ruby(FXDC& dc){
   return FXRbGetRubyObj(reinterpret_cast<void*>(&dc),FXRbTypeQuery("FXDC *"));
   }
 
+
+
+
+extern VALUE to_ruby_cb(const FXObject* obj);
+
+inline VALUE to_ruby_cb(const FXRangef& range){
+  return FXRbNewPointerObjCb(static_cast<void*>(const_cast<FXRangef*>(&range)), FXRbTypeQuery("FXRangef *"));
+}
+
+inline VALUE to_ruby_cb(FXStream& store){
+  return (VALUE) 0; // FIXME
+}
+
+inline VALUE to_ruby_cb(const FXPoint* point){
+  return FXRbNewPointerObjCb(static_cast<void*>(const_cast<FXPoint*>(point)), FXRbTypeQuery("FXPoint *"));
+}
+
+inline VALUE to_ruby_cb(const FXSegment* segment){
+  return FXRbNewPointerObjCb(static_cast<void*>(const_cast<FXSegment*>(segment)), FXRbTypeQuery("FXSegment *"));
+}
+
+inline VALUE to_ruby_cb(const FXRectangle* rect){
+  return FXRbNewPointerObjCb(static_cast<void*>(const_cast<FXRectangle*>(rect)), FXRbTypeQuery("FXRectangle *"));
+}
+
+inline VALUE to_ruby_cb(const FXRectangle& rect){
+  return FXRbNewPointerObjCb(static_cast<void*>(const_cast<FXRectangle*>(&rect)), FXRbTypeQuery("FXRectangle *"));
+}
+
+inline VALUE to_ruby_cb(const FXArc* arc){
+  return FXRbNewPointerObjCb(static_cast<void*>(const_cast<FXArc*>(arc)), FXRbTypeQuery("FXArc *"));
+}
+
+inline VALUE to_ruby_cb(FXEvent* event){
+  return FXRbGetRubyObjCb(reinterpret_cast<void*>(event), FXRbTypeQuery("FXEvent *"));
+}
+
+inline VALUE to_ruby_cb(FXFontDesc* fontdesc){
+  return FXRbNewPointerObjCb(reinterpret_cast<void*>(fontdesc), FXRbTypeQuery("FXFontDesc *"));
+}
+
+inline VALUE to_ruby_cb(const FXFontDesc& fontdesc){
+  return FXRbNewPointerObjCb(reinterpret_cast<void*>(const_cast<FXFontDesc*>(&fontdesc)), FXRbTypeQuery("FXFontDesc *"));
+}
+
+inline VALUE to_ruby_cb(FXDC& dc){
+  return FXRbGetRubyObjCb(reinterpret_cast<void*>(&dc), FXRbTypeQuery("FXDC *"));
+}
+inline VALUE to_ruby_cb(FXDCWindow& dc){
+  return FXRbGetRubyObjCb(reinterpret_cast<void*>(&dc), FXRbTypeQuery("FXDCWindow *"));
+}
+
+template<class TYPE>
+VALUE to_ruby_cb(TYPE obj){
+  return to_ruby(obj);
+}
+
+
 /**
  * Remember: FXID is typedef'd as an unsigned int on non-Windows platforms,
  * but as a void * on Win32.
@@ -351,324 +398,352 @@ 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_cb(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_cb(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_cb(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_cb(arg1),to_ruby_cb(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_cb(arg1),to_ruby_cb(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);
+}
+
+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_cb(arg1),to_ruby_cb(arg2),to_ruby_cb(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_cb(arg1),to_ruby_cb(arg2),to_ruby_cb(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_cb(arg1),to_ruby_cb(arg2),to_ruby_cb(arg3),to_ruby_cb(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_cb(arg1),to_ruby_cb(arg2),to_ruby_cb(arg3),to_ruby_cb(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_cb(arg1),to_ruby_cb(arg2),to_ruby_cb(arg3),to_ruby_cb(arg4),to_ruby_cb(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_cb(arg1),to_ruby_cb(arg2),to_ruby_cb(arg3),to_ruby_cb(arg4),to_ruby_cb(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_cb(arg1),to_ruby_cb(arg2),to_ruby_cb(arg3),to_ruby_cb(arg4),to_ruby_cb(arg5),to_ruby_cb(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_cb(arg1),to_ruby_cb(arg2),to_ruby_cb(arg3),to_ruby_cb(arg4),to_ruby_cb(arg5),to_ruby_cb(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_cb(arg1),to_ruby_cb(arg2),to_ruby_cb(arg3),to_ruby_cb(arg4),to_ruby_cb(arg5),to_ruby_cb(arg6),to_ruby_cb(arg7));
+  }
+
+template<class TYPE1, class TYPE2, class TYPE3, class TYPE4, class TYPE5, class TYPE6, class TYPE7, class TYPE8>
+void FXRbCallVoidMethod_gvlcb(FXObject* recv, const char *func, TYPE1& arg1, TYPE2 arg2, TYPE3 arg3, TYPE4 arg4, TYPE5 arg5, TYPE6 arg6, TYPE7 arg7, TYPE8 arg8){
+  VALUE obj=FXRbGetRubyObj(recv,false);
+  FXASSERT(!NIL_P(obj));
+  rb_funcall(obj,rb_intern(func),8,to_ruby_cb(arg1),to_ruby_cb(arg2),to_ruby_cb(arg3),to_ruby_cb(arg4),to_ruby_cb(arg5),to_ruby_cb(arg6),to_ruby_cb(arg7), to_ruby_cb(arg8));
   }
 
 /* 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_cb(arg1),to_ruby_cb(arg2),to_ruby_cb(arg3),to_ruby_cb(arg4),to_ruby_cb(arg5),to_ruby_cb(arg6),to_ruby_cb(arg7), to_ruby_cb(arg8), to_ruby_cb(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_cb(arg1),to_ruby_cb(arg2),to_ruby_cb(arg3),to_ruby_cb(arg4),to_ruby_cb(arg5),to_ruby_cb(arg6),to_ruby_cb(arg7),to_ruby_cb(arg8),to_ruby_cb(arg9),to_ruby_cb(arg10),to_ruby_cb(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);
   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_cb(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_cb(arg1),to_ruby_cb(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_cb(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_cb(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_cb(arg1),to_ruby_cb(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_cb(arg1),to_ruby_cb(arg2),to_ruby_cb(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_cb(arg1),to_ruby_cb(arg2),to_ruby_cb(arg3),to_ruby_cb(arg4),to_ruby_cb(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_cb(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_cb(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_cb(arg1),to_ruby_cb(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_cb(arg1),to_ruby_cb(arg2),to_ruby_cb(arg3),to_ruby_cb(arg4),to_ruby_cb(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_cb(arg1),to_ruby_cb(arg2),to_ruby_cb(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,rb_intern(func),1,to_ruby_cb(arg));
+  return static_cast<FXuint>(NUM2UINT(v));
+  }
+
+template<class TYPE1, class TYPE2, class TYPE3, class TYPE4>
+FXuint FXRbCallUIntMethod_gvlcb(FXObject* recv, const char *func, TYPE1 arg1, TYPE2 arg2, TYPE3 arg3, TYPE4 arg4){
   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),4,to_ruby_cb(arg1),to_ruby_cb(arg2),to_ruby_cb(arg3),to_ruby_cb(arg4));
   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 +769,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"
diff --git a/ext/fox16_c/include/gvl_wrappers.h b/ext/fox16_c/include/gvl_wrappers.h
new file mode 100644
index 00000000..86f47fa8
--- /dev/null
+++ b/ext/fox16_c/include/gvl_wrappers.h
@@ -0,0 +1,616 @@
+/*
+ * gvl_wrappers.h - Wrapper functions for locking/unlocking the Ruby GVL
+ *
+ * These are some obscure preprocessor directives that allow to generate
+ * drop-in replacement wrapper functions in a declarative manner.
+ * These wrapper functions ensure that ruby's GVL is released on each
+ * function call and reacquired at the end of the call or in callbacks.
+ * This way blocking functions calls don't block concurrent ruby threads.
+ *
+ * The wrapper of each function is prefixed by "gvl_".
+ *
+ * Use "gcc -E" to retrieve the generated code.
+ */
+
+#ifndef __gvl_wrappers_h
+#define __gvl_wrappers_h
+
+#if defined(HAVE_RB_THREAD_CALL_WITH_GVL)
+extern "C" void *rb_thread_call_with_gvl(void *(*func)(void *), void *data1);
+#endif
+
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
+extern "C" void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1,
+        rb_unblock_function_t *ubf, void *data2);
+#endif
+
+void fxrb_wakeup_fox(void *);
+
+#define DEFINE_PARAM_LIST1(type, ref, name) \
+  , name
+
+#define DEFINE_PARAM_LIST2(type, ref, name) \
+  , p->params.name
+
+#define DEFINE_PARAM_LIST3(type, ref, name) \
+  , type ref name
+
+#define DEFINE_PARAM_LIST4(type, ref, name) \
+  , typename type
+
+#define DEFINE_PARAM_LIST5(type, ref, name) \
+  , type
+
+#define DEFINE_PARAM_DECL(type, ref, name) \
+  type ref name;
+
+#define DEFINE_GVL_WRAPPER_STRUCT(klass, name, baseclass, when_non_void, rettype, firstparamtype, firstparamname) \
+  struct gvl_wrapper_##klass##_##name##_params { \
+    struct { \
+      firstparamtype firstparamname; \
+      FOR_EACH_PARAM_OF_##baseclass##_##name(DEFINE_PARAM_DECL) \
+    } params; \
+    when_non_void( rettype retval; ) \
+  };
+
+#ifdef HAVE___THREAD
+  extern __thread int g_fxrb_thread_has_gvl;
+#endif
+
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
+  #define DEFINE_GVL_SKELETON(klass, name, baseclass, when_non_void, rettype, firstparamtype, firstparamname) \
+    static void * gvl_##klass##_##name##_skeleton( void *data ){ \
+      struct gvl_wrapper_##klass##_##name##_params *p = (struct gvl_wrapper_##klass##_##name##_params*)data; \
+      g_fxrb_thread_has_gvl = 0; \
+      when_non_void( p->retval = ) \
+        klass##_##name##_gvl( p->params.firstparamname FOR_EACH_PARAM_OF_##baseclass##_##name(DEFINE_PARAM_LIST2) ); \
+      g_fxrb_thread_has_gvl = 1; \
+      return NULL; \
+    }
+
+  #define DEFINE_GVL_STUB(klass, name, baseclass, when_non_void, rettype, firstparamtype, firstparamname) \
+    rettype klass##_##name(firstparamtype firstparamname FOR_EACH_PARAM_OF_##baseclass##_##name(DEFINE_PARAM_LIST3)){ \
+      struct gvl_wrapper_##klass##_##name##_params params = { \
+        {firstparamname FOR_EACH_PARAM_OF_##baseclass##_##name(DEFINE_PARAM_LIST1)}, when_non_void((rettype)0) \
+      }; \
+      rb_thread_call_without_gvl(gvl_##klass##_##name##_skeleton, &params, fxrb_wakeup_fox, 0); \
+      when_non_void( return params.retval; ) \
+    }
+#else
+  #define DEFINE_GVL_SKELETON(klass, name, baseclass, when_non_void, rettype, firstparamtype, firstparamname)
+
+  #define DEFINE_GVL_STUB(klass, name, baseclass, when_non_void, rettype, firstparamtype, firstparamname) \
+    rettype klass##_##name(firstparamtype firstparamname FOR_EACH_PARAM_OF_##baseclass##_##name(DEFINE_PARAM_LIST3)){ \
+      return klass##_##name##_gvl(firstparamname FOR_EACH_PARAM_OF_##baseclass##_##name(DEFINE_PARAM_LIST1)); \
+    }
+#endif
+
+#define DEFINE_GVL_STUB_DECL(klass, name, baseclass, when_non_void, rettype, firstparamtype, firstparamname) \
+  rettype klass##_##name( firstparamtype firstparamname FOR_EACH_PARAM_OF_##baseclass##_##name(DEFINE_PARAM_LIST3));
+
+
+
+#define DEFINE_GVLCB_WRAPPER_STRUCT(name, when_non_void, rettype, firstparamtype, firstparamname, paramcount) \
+  template<typename firstparamtype FOR_EACH_PARAM_OF_##name##_##paramcount(DEFINE_PARAM_LIST4)> \
+        struct gvl_wrapper_##name##_##paramcount##_params { \
+    struct { \
+      firstparamtype firstparamname; \
+      FOR_EACH_PARAM_OF_##name##_##paramcount(DEFINE_PARAM_DECL) \
+    } params; \
+    when_non_void( rettype retval; ) \
+  };
+
+#define DEFINE_GVLCB_STUB_DECL(name, when_non_void, rettype, firstparamtype, firstparamname, paramcount) \
+  template<typename firstparamtype FOR_EACH_PARAM_OF_##name##_##paramcount(DEFINE_PARAM_LIST4)> \
+        rettype name( firstparamtype firstparamname FOR_EACH_PARAM_OF_##name##_##paramcount(DEFINE_PARAM_LIST3));
+
+#define DEFINE_GVLCB_SKELETON(name, when_non_void, rettype, firstparamtype, firstparamname, paramcount) \
+  template<typename firstparamtype FOR_EACH_PARAM_OF_##name##_##paramcount(DEFINE_PARAM_LIST4)> \
+        static void * gvl_##name##_##paramcount##_skeleton( void *data ){ \
+    struct gvl_wrapper_##name##_##paramcount##_params<firstparamtype FOR_EACH_PARAM_OF_##name##_##paramcount(DEFINE_PARAM_LIST5)>  *p = \
+        (struct gvl_wrapper_##name##_##paramcount##_params<firstparamtype FOR_EACH_PARAM_OF_##name##_##paramcount(DEFINE_PARAM_LIST5)>*)data; \
+    when_non_void( p->retval = ) \
+      name##_gvlcb( p->params.firstparamname FOR_EACH_PARAM_OF_##name##_##paramcount(DEFINE_PARAM_LIST2) ); \
+    return NULL; \
+  }
+
+#if defined(HAVE_RB_THREAD_CALL_WITH_GVL)
+  #define DEFINE_GVLCB_STUB(name, when_non_void, rettype, firstparamtype, firstparamname, paramcount) \
+    template<typename firstparamtype FOR_EACH_PARAM_OF_##name##_##paramcount(DEFINE_PARAM_LIST4)> \
+          rettype name(firstparamtype firstparamname FOR_EACH_PARAM_OF_##name##_##paramcount(DEFINE_PARAM_LIST3)){ \
+      if( g_fxrb_thread_has_gvl ){ \
+        return name##_gvlcb( firstparamname FOR_EACH_PARAM_OF_##name##_##paramcount(DEFINE_PARAM_LIST1) ); \
+      } else { \
+        struct gvl_wrapper_##name##_##paramcount##_params<firstparamtype FOR_EACH_PARAM_OF_##name##_##paramcount(DEFINE_PARAM_LIST5)> params = { \
+          {firstparamname FOR_EACH_PARAM_OF_##name##_##paramcount(DEFINE_PARAM_LIST1)} \
+        }; \
+        g_fxrb_thread_has_gvl = 1; \
+        rb_thread_call_with_gvl(gvl_##name##_##paramcount##_skeleton<firstparamtype FOR_EACH_PARAM_OF_##name##_##paramcount(DEFINE_PARAM_LIST5)>, &params); \
+        g_fxrb_thread_has_gvl = 0; \
+        when_non_void( return params.retval; ) \
+      } \
+    }
+#else
+  #define DEFINE_GVLCB_STUB(name, when_non_void, rettype, firstparamtype, firstparamname, paramcount) \
+    template<typename firstparamtype FOR_EACH_PARAM_OF_##name##_##paramcount(DEFINE_PARAM_LIST4)> \
+          rettype name(firstparamtype firstparamname FOR_EACH_PARAM_OF_##name##_##paramcount(DEFINE_PARAM_LIST3)){ \
+      return name##_gvlcb( firstparamname FOR_EACH_PARAM_OF_##name##_##paramcount(DEFINE_PARAM_LIST1) ); \
+    }
+#endif
+
+#define GVL_TYPE_VOID(string)
+#define GVL_TYPE_NONVOID(string) string
+
+
+/*
+* Definitions of blocking functions and their parameters
+*/
+
+#define FOR_EACH_PARAM_OF_FXImage_loadPixels(param) \
+  param(FXStream, &, store)
+#define FOR_EACH_PARAM_OF_FXImage_savePixels(param) \
+  param(FXStream, &, store)
+
+#define FOR_EACH_PARAM_OF_FXDialogBox_execute(param) \
+  param(FXuint, , placement)
+
+#define FOR_EACH_PARAM_OF_FXApp_run(param)
+
+#define FOR_EACH_PARAM_OF_FXApp_runOneEvent(param) \
+  param(bool, , blocking)
+
+#define FOR_EACH_PARAM_OF_FXApp_runUntil(param) \
+  param(FXuint, &, condition)
+
+#define FOR_EACH_PARAM_OF_FXApp_runWhileEvents(param)
+
+#define FOR_EACH_PARAM_OF_FXApp_runModalWhileEvents(param) \
+  param(FXWindow*, , window)
+
+#define FOR_EACH_PARAM_OF_FXApp_runModal(param)
+
+#define FOR_EACH_PARAM_OF_FXApp_runModalFor(param) \
+  param(FXWindow*, , window)
+
+#define FOR_EACH_PARAM_OF_FXApp_runModalWhileShown(param) \
+  param(FXWindow*, , window)
+
+#define FOR_EACH_PARAM_OF_FXApp_runPopup(param) \
+  param(FXWindow*, , owner)
+
+
+
+/* function( class, name, baseclass, void_or_nonvoid, returntype, firstparamtype, firstparamname ) */
+#define FOR_EACH_BLOCKING_FUNCTION(function) \
+  function(FXImage, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXImage *, self) \
+  function(FXImage, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXImage *, self) \
+  function(FXBMPImage, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXBMPImage *, self) \
+  function(FXBMPImage, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXBMPImage *, self) \
+  function(FXJPGImage, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXJPGImage *, self) \
+  function(FXJPGImage, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXJPGImage *, self) \
+  function(FXGIFImage, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXGIFImage *, self) \
+  function(FXGIFImage, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXGIFImage *, self) \
+  function(FXICOImage, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXICOImage *, self) \
+  function(FXICOImage, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXICOImage *, self) \
+  function(FXPNGImage, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXPNGImage *, self) \
+  function(FXPNGImage, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXPNGImage *, self) \
+  function(FXPPMImage, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXPPMImage *, self) \
+  function(FXPPMImage, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXPPMImage *, self) \
+  function(FXPCXImage, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXPCXImage *, self) \
+  function(FXPCXImage, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXPCXImage *, self) \
+  function(FXRGBImage, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXRGBImage *, self) \
+  function(FXRGBImage, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXRGBImage *, self) \
+  function(FXTGAImage, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXTGAImage *, self) \
+  function(FXTGAImage, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXTGAImage *, self) \
+  function(FXTIFImage, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXTIFImage *, self) \
+  function(FXTIFImage, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXTIFImage *, self) \
+  function(FXXBMImage, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXXBMImage *, self) \
+  function(FXXBMImage, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXXBMImage *, self) \
+  function(FXXPMImage, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXXPMImage *, self) \
+  function(FXXPMImage, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXXPMImage *, self) \
+  function(FXIcon, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXIcon *, self) \
+  function(FXIcon, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXIcon *, self) \
+  function(FXBMPIcon, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXBMPIcon *, self) \
+  function(FXBMPIcon, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXBMPIcon *, self) \
+  function(FXJPGIcon, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXJPGIcon *, self) \
+  function(FXJPGIcon, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXJPGIcon *, self) \
+  function(FXGIFIcon, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXGIFIcon *, self) \
+  function(FXGIFIcon, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXGIFIcon *, self) \
+  function(FXICOIcon, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXICOIcon *, self) \
+  function(FXICOIcon, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXICOIcon *, self) \
+  function(FXPNGIcon, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXPNGIcon *, self) \
+  function(FXPNGIcon, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXPNGIcon *, self) \
+  function(FXPPMIcon, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXPPMIcon *, self) \
+  function(FXPPMIcon, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXPPMIcon *, self) \
+  function(FXPCXIcon, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXPCXIcon *, self) \
+  function(FXPCXIcon, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXPCXIcon *, self) \
+  function(FXRGBIcon, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXRGBIcon *, self) \
+  function(FXRGBIcon, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXRGBIcon *, self) \
+  function(FXTGAIcon, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXTGAIcon *, self) \
+  function(FXTGAIcon, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXTGAIcon *, self) \
+  function(FXTIFIcon, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXTIFIcon *, self) \
+  function(FXTIFIcon, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXTIFIcon *, self) \
+  function(FXXBMIcon, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXXBMIcon *, self) \
+  function(FXXBMIcon, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXXBMIcon *, self) \
+  function(FXXPMIcon, loadPixels, FXImage, GVL_TYPE_NONVOID, bool, FXXPMIcon *, self) \
+  function(FXXPMIcon, savePixels, FXImage, GVL_TYPE_NONVOID, bool, const FXXPMIcon *, self) \
+  function(FXChoiceBox, execute, FXDialogBox, GVL_TYPE_NONVOID, FXuint, FXChoiceBox *, self) \
+  function(FXColorDialog, execute, FXDialogBox, GVL_TYPE_NONVOID, FXuint, FXColorDialog *, self) \
+  function(FXDialogBox, execute, FXDialogBox, GVL_TYPE_NONVOID, FXuint, FXDialogBox *, self) \
+  function(FXDirDialog, execute, FXDialogBox, GVL_TYPE_NONVOID, FXuint, FXDirDialog *, self) \
+  function(FXFileDialog, execute, FXDialogBox, GVL_TYPE_NONVOID, FXuint, FXFileDialog *, self) \
+  function(FXFontDialog, execute, FXDialogBox, GVL_TYPE_NONVOID, FXuint, FXFontDialog *, self) \
+  function(FXInputDialog, execute, FXDialogBox, GVL_TYPE_NONVOID, FXuint, FXInputDialog *, self) \
+  function(FXMessageBox, execute, FXDialogBox, GVL_TYPE_NONVOID, FXuint, FXMessageBox *, self) \
+  function(FXPrintDialog, execute, FXDialogBox, GVL_TYPE_NONVOID, FXuint, FXPrintDialog *, self) \
+  function(FXProgressDialog, execute, FXDialogBox, GVL_TYPE_NONVOID, FXuint, FXProgressDialog *, self) \
+  function(FXReplaceDialog, execute, FXDialogBox, GVL_TYPE_NONVOID, FXuint, FXReplaceDialog *, self) \
+  function(FXSearchDialog, execute, FXDialogBox, GVL_TYPE_NONVOID, FXuint, FXSearchDialog *, self) \
+  function(FXWizard, execute, FXDialogBox, GVL_TYPE_NONVOID, FXuint, FXWizard *, self) \
+  function(FXApp, run, FXApp, GVL_TYPE_NONVOID, FXint, FXApp *, self) \
+  function(FXApp, runOneEvent, FXApp, GVL_TYPE_NONVOID, bool, FXApp *, self) \
+  function(FXApp, runUntil, FXApp, GVL_TYPE_NONVOID, FXint, FXApp *, self) \
+  function(FXApp, runWhileEvents, FXApp, GVL_TYPE_NONVOID, FXint, FXApp *, self) \
+  function(FXApp, runModalWhileEvents, FXApp, GVL_TYPE_NONVOID, FXint, FXApp *, self) \
+  function(FXApp, runModal, FXApp, GVL_TYPE_NONVOID, FXint, FXApp *, self) \
+  function(FXApp, runModalFor, FXApp, GVL_TYPE_NONVOID, FXint, FXApp *, self) \
+  function(FXApp, runModalWhileShown, FXApp, GVL_TYPE_NONVOID, FXint, FXApp *, self) \
+  function(FXApp, runPopup, FXApp, GVL_TYPE_NONVOID, FXint, FXApp *, self) \
+
+
+
+FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_STUB_DECL )
+
+/*
+ * Definitions of callback functions and their parameters
+ */
+
+#define FOR_EACH_PARAM_OF_FXRbCallVoidMethod_2(param) \
+  param(ID, , func)
+
+#define FOR_EACH_PARAM_OF_FXRbCallVoidMethod_3(param) \
+  param(ID, , func) \
+  param(TYPE1, &, arg1)
+
+#define FOR_EACH_PARAM_OF_FXRbCallVoidMethod_4(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2)
+
+#define FOR_EACH_PARAM_OF_FXRbCallVoidMethod_5(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2) \
+  param(TYPE3, , arg3)
+
+#define FOR_EACH_PARAM_OF_FXRbCallVoidMethod_6(param) \
+  param(ID, , func) \
+  param(TYPE1, &, arg1) \
+  param(TYPE2, , arg2) \
+  param(TYPE3, , arg3) \
+  param(TYPE4, , arg4)
+
+#define FOR_EACH_PARAM_OF_FXRbCallVoidMethod_7(param) \
+  param(ID, , func) \
+  param(TYPE1, &, arg1) \
+  param(TYPE2, , arg2) \
+  param(TYPE3, , arg3) \
+  param(TYPE4, , arg4) \
+  param(TYPE5, , arg5)
+
+#define FOR_EACH_PARAM_OF_FXRbCallVoidMethod_8(param) \
+  param(ID, , func) \
+  param(TYPE1, &, arg1) \
+  param(TYPE2, &, arg2) \
+  param(TYPE3, , arg3) \
+  param(TYPE4, , arg4) \
+  param(TYPE5, , arg5) \
+  param(TYPE6, , arg6)
+
+#define FOR_EACH_PARAM_OF_FXRbCallVoidMethod_9(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2) \
+  param(TYPE3, , arg3) \
+  param(TYPE4, , arg4) \
+  param(TYPE5, , arg5) \
+  param(TYPE6, , arg6) \
+  param(TYPE7, , arg7)
+
+#define FOR_EACH_PARAM_OF_FXRbCallVoidMethod_10(param) \
+  param(ID, , func) \
+  param(TYPE1, &, arg1) \
+  param(TYPE2, , arg2) \
+  param(TYPE3, , arg3) \
+  param(TYPE4, , arg4) \
+  param(TYPE5, , arg5) \
+  param(TYPE6, , arg6) \
+  param(TYPE7, , arg7) \
+  param(TYPE8, , arg8)
+
+#define FOR_EACH_PARAM_OF_FXRbCallVoidMethod_11(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2) \
+  param(TYPE3, , arg3) \
+  param(TYPE4, , arg4) \
+  param(TYPE5, , arg5) \
+  param(TYPE6, , arg6) \
+  param(TYPE7, , arg7) \
+  param(TYPE8, , arg8) \
+  param(TYPE9, , arg9)
+
+#define FOR_EACH_PARAM_OF_FXRbCallBoolMethod_2(param) \
+  param(ID, , func)
+
+#define FOR_EACH_PARAM_OF_FXRbCallBoolMethod_3(param) \
+  param(ID, , func) \
+  param(TYPE1, &, arg1)
+
+#define FOR_EACH_PARAM_OF_FXRbCallBoolMethod_4(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2)
+
+#define FOR_EACH_PARAM_OF_FXRbCallBoolMethod_5(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2) \
+  param(TYPE3, , arg3)
+
+#define FOR_EACH_PARAM_OF_FXRbCallBoolMethod_7(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2) \
+  param(TYPE3, , arg3) \
+  param(TYPE4, , arg4) \
+  param(TYPE5, , arg5)
+
+#define FOR_EACH_PARAM_OF_FXRbCallIntMethod_2(param) \
+  param(ID, , func)
+
+#define FOR_EACH_PARAM_OF_FXRbCallIntMethod_3(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1)
+
+#define FOR_EACH_PARAM_OF_FXRbCallIntMethod_4(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2)
+
+#define FOR_EACH_PARAM_OF_FXRbCallIntMethod_7(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2) \
+  param(TYPE3, , arg3) \
+  param(TYPE4, , arg4) \
+  param(TYPE5, , arg5)
+
+#define FOR_EACH_PARAM_OF_FXRbCallLongMethod_5(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2) \
+  param(TYPE3, , arg3)
+
+#define FOR_EACH_PARAM_OF_FXRbCallUIntMethod_3(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1)
+
+#define FOR_EACH_PARAM_OF_FXRbCallUIntMethod_6(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2) \
+  param(TYPE3, , arg3) \
+  param(TYPE4, , arg4)
+
+#define FOR_EACH_PARAM_OF_FXRbCallGLObjectMethod_2(param) \
+  param(ID, , func)
+
+#define FOR_EACH_PARAM_OF_FXRbCallGLObjectMethod_3(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1)
+
+#define FOR_EACH_PARAM_OF_FXRbCallGLObjectMethod_4(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2)
+
+#define FOR_EACH_PARAM_OF_FXRbCallStringMethod_2(param) \
+  param(ID, , func)
+
+#define FOR_EACH_PARAM_OF_FXRbCallCStringMethod_4(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2)
+
+#define FOR_EACH_PARAM_OF_FXRbCallCStringMethod_5(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2) \
+  param(TYPE3, , arg3)
+
+#define FOR_EACH_PARAM_OF_FXRbCallGLObjectArrayMethod_6(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2) \
+  param(TYPE3, , arg3) \
+  param(TYPE4, , arg4)
+
+#define FOR_EACH_PARAM_OF_FXRbCallTableItemMethod_5(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2) \
+  param(TYPE3, , arg3)
+
+#define FOR_EACH_PARAM_OF_FXRbCallFileAssocMethod_3(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1)
+
+#define FOR_EACH_PARAM_OF_FXRbCallIconMethod_2(param) \
+  param(ID, , func)
+
+#define FOR_EACH_PARAM_OF_FXRbCallIconMethod_4(param) \
+  param(ID, , func) \
+  param(TYPE1, &, arg1) \
+  param(TYPE2, &, arg2)
+
+#define FOR_EACH_PARAM_OF_FXRbCallIconMethod_6(param) \
+  param(ID, , func) \
+  param(TYPE1, &, arg1) \
+  param(TYPE2, &, arg2) \
+  param(TYPE3, &, arg3) \
+  param(TYPE4, &, arg4)
+
+#define FOR_EACH_PARAM_OF_FXRbCallImageMethod_4(param) \
+  param(ID, , func) \
+  param(TYPE1, &, arg1) \
+  param(TYPE2, &, arg2)
+
+#define FOR_EACH_PARAM_OF_FXRbCallImageMethod_6(param) \
+  param(ID, , func) \
+  param(TYPE1, &, arg1) \
+  param(TYPE2, &, arg2) \
+  param(TYPE3, &, arg3) \
+  param(TYPE4, &, arg4)
+
+#define FOR_EACH_PARAM_OF_FXRbCallWindowMethod_3(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1)
+
+#define FOR_EACH_PARAM_OF_FXRbCallColorMethod_4(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2)
+
+#define FOR_EACH_PARAM_OF_FXRbCallRangeMethod_2(param) \
+  param(ID, , func)
+
+#define FOR_EACH_PARAM_OF_FXRbCallWCharMethod_2(param) \
+  param(ID, , func)
+
+#define FOR_EACH_PARAM_OF_FXRbCallSetDashes_5(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2) \
+  param(TYPE3, , arg3)
+
+#define FOR_EACH_PARAM_OF_FXRbLookupHandler_2(param) \
+  param(ITEMB, , itemb)
+
+#define FOR_EACH_PARAM_OF_FXRbHandleMessage_5(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2) \
+  param(TYPE3, , arg3)
+
+#define FOR_EACH_PARAM_OF_FXRbComboBox_sortFunc_2(param) \
+  param(ITEMB, , itemb)
+
+#define FOR_EACH_PARAM_OF_FXRbFoldingList_sortFunc_2(param) \
+  param(ITEMB, , itemb)
+
+#define FOR_EACH_PARAM_OF_FXRbIconList_sortFunc_2(param) \
+  param(ITEMB, , itemb)
+
+#define FOR_EACH_PARAM_OF_FXRbList_sortFunc_2(param) \
+  param(ITEMB, , itemb)
+
+#define FOR_EACH_PARAM_OF_FXRbListBox_sortFunc_2(param) \
+  param(ITEMB, , itemb)
+
+#define FOR_EACH_PARAM_OF_FXRbTreeList_sortFunc_2(param) \
+  param(ITEMB, , itemb)
+
+#define FOR_EACH_PARAM_OF_FXRbCallDCDrawMethod_5(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2) \
+  param(TYPE3, &, arg3)
+
+#define FOR_EACH_PARAM_OF_FXRbCallDCDrawMethod_6(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2) \
+  param(TYPE3, , arg3) \
+  param(TYPE4, , arg4)
+
+#define FOR_EACH_PARAM_OF_FXRbCallTreeItemMethod_4(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2)
+
+#define FOR_EACH_PARAM_OF_FXRbCallFoldingItemMethod_4(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2)
+
+#define FOR_EACH_PARAM_OF_FXRbApp_onChoreThreads_4(param) \
+  param(ID, , func) \
+  param(TYPE1, , arg1) \
+  param(TYPE2, , arg2)
+
+
+/* function( name, void_or_nonvoid, returntype, firstparamtype, firstparamname, paramcount ) */
+#define FOR_EACH_CALLBACK_FUNCTION(function) \
+  function(FXRbCallVoidMethod, GVL_TYPE_VOID, void, RECV, recv, 2) \
+  function(FXRbCallVoidMethod, GVL_TYPE_VOID, void, RECV, recv, 3) \
+  function(FXRbCallVoidMethod, GVL_TYPE_VOID, void, RECV, recv, 4) \
+  function(FXRbCallVoidMethod, GVL_TYPE_VOID, void, RECV, recv, 5) \
+  function(FXRbCallVoidMethod, GVL_TYPE_VOID, void, RECV, recv, 6) \
+  function(FXRbCallVoidMethod, GVL_TYPE_VOID, void, RECV, recv, 7) \
+  function(FXRbCallVoidMethod, GVL_TYPE_VOID, void, RECV, recv, 8) \
+  function(FXRbCallVoidMethod, GVL_TYPE_VOID, void, RECV, recv, 9) \
+  function(FXRbCallVoidMethod, GVL_TYPE_VOID, void, RECV, recv, 10) \
+  function(FXRbCallVoidMethod, GVL_TYPE_VOID, void, RECV, recv, 11) \
+  function(FXRbCallBoolMethod, GVL_TYPE_NONVOID, bool, RECV, recv, 2) \
+  function(FXRbCallBoolMethod, GVL_TYPE_NONVOID, bool, RECV, recv, 3) \
+  function(FXRbCallBoolMethod, GVL_TYPE_NONVOID, bool, RECV, recv, 4) \
+  function(FXRbCallBoolMethod, GVL_TYPE_NONVOID, bool, RECV, recv, 5) \
+  function(FXRbCallBoolMethod, GVL_TYPE_NONVOID, bool, RECV, recv, 7) \
+  function(FXRbCallIntMethod, GVL_TYPE_NONVOID, FXint, RECV, recv, 2) \
+  function(FXRbCallIntMethod, GVL_TYPE_NONVOID, FXint, RECV, recv, 3) \
+  function(FXRbCallIntMethod, GVL_TYPE_NONVOID, FXint, RECV, recv, 4) \
+  function(FXRbCallIntMethod, GVL_TYPE_NONVOID, FXint, RECV, recv, 7) \
+  function(FXRbCallLongMethod, GVL_TYPE_NONVOID, FXint, RECV, recv, 5) \
+  function(FXRbCallUIntMethod, GVL_TYPE_NONVOID, FXint, RECV, recv, 3) \
+  function(FXRbCallUIntMethod, GVL_TYPE_NONVOID, FXint, RECV, recv, 6) \
+  function(FXRbCallGLObjectMethod, GVL_TYPE_NONVOID, FXGLObject*, RECV, recv, 2) \
+  function(FXRbCallGLObjectMethod, GVL_TYPE_NONVOID, FXGLObject*, RECV, recv, 3) \
+  function(FXRbCallGLObjectMethod, GVL_TYPE_NONVOID, FXGLObject*, RECV, recv, 4) \
+  function(FXRbCallStringMethod, GVL_TYPE_NONVOID, FXString, RECV, recv, 2) \
+  function(FXRbCallCStringMethod, GVL_TYPE_NONVOID, const FXchar*, RECV, recv, 4) \
+  function(FXRbCallCStringMethod, GVL_TYPE_NONVOID, const FXchar*, RECV, recv, 5) \
+  function(FXRbCallGLObjectArrayMethod, GVL_TYPE_NONVOID, FXGLObject**, RECV, recv, 6) \
+  function(FXRbCallTableItemMethod, GVL_TYPE_NONVOID, FXTableItem*, RECV, recv, 5) \
+  function(FXRbCallFileAssocMethod, GVL_TYPE_NONVOID, FXFileAssoc*, RECV, recv, 3) \
+  function(FXRbCallIconMethod, GVL_TYPE_NONVOID, FXIcon*, RECV, recv, 2) \
+  function(FXRbCallIconMethod, GVL_TYPE_NONVOID, FXIcon*, RECV, recv, 4) \
+  function(FXRbCallIconMethod, GVL_TYPE_NONVOID, FXIcon*, RECV, recv, 6) \
+  function(FXRbCallImageMethod, GVL_TYPE_NONVOID, FXImage*, RECV, recv, 4) \
+  function(FXRbCallImageMethod, GVL_TYPE_NONVOID, FXImage*, RECV, recv, 6) \
+  function(FXRbCallWindowMethod, GVL_TYPE_NONVOID, FXWindow*, RECV, recv, 3) \
+  function(FXRbCallColorMethod, GVL_TYPE_NONVOID, FXColor, RECV, recv, 4) \
+  function(FXRbCallRangeMethod, GVL_TYPE_NONVOID, FXRangef, RECV, recv, 2) \
+  function(FXRbCallWCharMethod, GVL_TYPE_NONVOID, FXwchar, RECV, recv, 2) \
+  function(FXRbCallSetDashes, GVL_TYPE_VOID, void, RECV, recv, 5) \
+  function(FXRbLookupHandler, GVL_TYPE_NONVOID, ID, RECV, recv, 2) \
+  function(FXRbHandleMessage, GVL_TYPE_NONVOID, long, RECV, recv, 5) \
+  function(FXRbComboBox_sortFunc, GVL_TYPE_NONVOID, FXint, ITEMA, itema, 2) \
+  function(FXRbFoldingList_sortFunc, GVL_TYPE_NONVOID, FXint, ITEMA, itema, 2) \
+  function(FXRbIconList_sortFunc, GVL_TYPE_NONVOID, FXint, ITEMA, itema, 2) \
+  function(FXRbList_sortFunc, GVL_TYPE_NONVOID, FXint, ITEMA, itema, 2) \
+  function(FXRbListBox_sortFunc, GVL_TYPE_NONVOID, FXint, ITEMA, itema, 2) \
+  function(FXRbTreeList_sortFunc, GVL_TYPE_NONVOID, FXint, ITEMA, itema, 2) \
+  function(FXRbCallDCDrawMethod, GVL_TYPE_VOID, void, RECV, recv, 5) \
+  function(FXRbCallDCDrawMethod, GVL_TYPE_VOID, void, RECV, recv, 6) \
+  function(FXRbCallTreeItemMethod, GVL_TYPE_NONVOID, FXTreeItem*, RECV, recv, 4) \
+  function(FXRbCallFoldingItemMethod, GVL_TYPE_NONVOID, FXFoldingItem*, RECV, recv, 4) \
+  function(FXRbApp_onChoreThreads, GVL_TYPE_NONVOID, long, RECV, recv, 4) \
+
+
+FOR_EACH_CALLBACK_FUNCTION( DEFINE_GVLCB_STUB_DECL )
+FOR_EACH_CALLBACK_FUNCTION( DEFINE_GVLCB_WRAPPER_STRUCT )
+FOR_EACH_CALLBACK_FUNCTION( DEFINE_GVLCB_SKELETON )
+FOR_EACH_CALLBACK_FUNCTION( DEFINE_GVLCB_STUB )
+
+#endif /* end __gvl_wrappers_h */
diff --git a/ext/fox16_c/include/inlinestubs.h b/ext/fox16_c/include/inlinestubs.h
new file mode 100644
index 00000000..ecebf2c1
--- /dev/null
+++ b/ext/fox16_c/include/inlinestubs.h
@@ -0,0 +1,1157 @@
+/* Start stub declarations for class FXMemoryBuffer */
+
+/* Start stub declarations for class FXRb4Splitter */
+DECLARE_FXOBJECT_STUBS(FX4Splitter)
+DECLARE_FXID_STUBS(FX4Splitter)
+DECLARE_FXDRAWABLE_STUBS(FX4Splitter)
+DECLARE_FXWINDOW_STUBS(FX4Splitter)
+
+/* Start stub declarations for class FXRb7Segment */
+DECLARE_FXOBJECT_STUBS(FX7Segment)
+DECLARE_FXID_STUBS(FX7Segment)
+DECLARE_FXDRAWABLE_STUBS(FX7Segment)
+DECLARE_FXWINDOW_STUBS(FX7Segment)
+
+/* Start stub declarations for class FXRbAccelTable */
+DECLARE_FXOBJECT_STUBS(FXAccelTable)
+
+/* Start stub declarations for class FXRbApp */
+DECLARE_FXOBJECT_STUBS(FXApp)
+DECLARE_FXAPP_STUBS(FXApp)
+
+/* Start stub declarations for class FXRbArrowButton */
+DECLARE_FXOBJECT_STUBS(FXArrowButton)
+DECLARE_FXID_STUBS(FXArrowButton)
+DECLARE_FXDRAWABLE_STUBS(FXArrowButton)
+DECLARE_FXWINDOW_STUBS(FXArrowButton)
+
+/* Start stub declarations for class FXRbBMPIcon */
+DECLARE_FXOBJECT_STUBS(FXBMPIcon)
+DECLARE_FXID_STUBS(FXBMPIcon)
+DECLARE_FXDRAWABLE_STUBS(FXBMPIcon)
+DECLARE_FXIMAGE_STUBS(FXBMPIcon)
+
+/* Start stub declarations for class FXRbBMPImage */
+DECLARE_FXOBJECT_STUBS(FXBMPImage)
+DECLARE_FXID_STUBS(FXBMPImage)
+DECLARE_FXDRAWABLE_STUBS(FXBMPImage)
+DECLARE_FXIMAGE_STUBS(FXBMPImage)
+
+/* Start stub declarations for class FXRbBitmap */
+DECLARE_FXOBJECT_STUBS(FXBitmap)
+DECLARE_FXID_STUBS(FXBitmap)
+DECLARE_FXDRAWABLE_STUBS(FXBitmap)
+DECLARE_FXBITMAP_STUBS(FXBitmap)
+
+/* Start stub declarations for class FXRbBitmapFrame */
+DECLARE_FXOBJECT_STUBS(FXBitmapFrame)
+DECLARE_FXID_STUBS(FXBitmapFrame)
+DECLARE_FXDRAWABLE_STUBS(FXBitmapFrame)
+DECLARE_FXWINDOW_STUBS(FXBitmapFrame)
+
+/* Start stub declarations for class FXRbButton */
+DECLARE_FXOBJECT_STUBS(FXButton)
+DECLARE_FXID_STUBS(FXButton)
+DECLARE_FXDRAWABLE_STUBS(FXButton)
+DECLARE_FXWINDOW_STUBS(FXButton)
+
+/* Start stub declarations for class FXRbCURCursor */
+DECLARE_FXOBJECT_STUBS(FXCURCursor)
+DECLARE_FXID_STUBS(FXCURCursor)
+DECLARE_FXCURSOR_STUBS(FXCURCursor)
+
+/* Start stub declarations for class FXRbCanvas */
+DECLARE_FXOBJECT_STUBS(FXCanvas)
+DECLARE_FXID_STUBS(FXCanvas)
+DECLARE_FXDRAWABLE_STUBS(FXCanvas)
+DECLARE_FXWINDOW_STUBS(FXCanvas)
+
+/* Start stub declarations for class FXRbCheckButton */
+DECLARE_FXOBJECT_STUBS(FXCheckButton)
+DECLARE_FXID_STUBS(FXCheckButton)
+DECLARE_FXDRAWABLE_STUBS(FXCheckButton)
+DECLARE_FXWINDOW_STUBS(FXCheckButton)
+
+/* Start stub declarations for class FXRbChoiceBox */
+DECLARE_FXOBJECT_STUBS(FXChoiceBox)
+DECLARE_FXID_STUBS(FXChoiceBox)
+DECLARE_FXDRAWABLE_STUBS(FXChoiceBox)
+DECLARE_FXWINDOW_STUBS(FXChoiceBox)
+DECLARE_FXTOPWINDOW_STUBS(FXChoiceBox)
+DECLARE_FXDIALOGBOX_STUBS(FXChoiceBox)
+
+/* Start stub declarations for class FXRbColorBar */
+DECLARE_FXOBJECT_STUBS(FXColorBar)
+DECLARE_FXID_STUBS(FXColorBar)
+DECLARE_FXDRAWABLE_STUBS(FXColorBar)
+DECLARE_FXWINDOW_STUBS(FXColorBar)
+
+/* Start stub declarations for class FXRbColorDialog */
+DECLARE_FXOBJECT_STUBS(FXColorDialog)
+DECLARE_FXID_STUBS(FXColorDialog)
+DECLARE_FXDRAWABLE_STUBS(FXColorDialog)
+DECLARE_FXWINDOW_STUBS(FXColorDialog)
+DECLARE_FXTOPWINDOW_STUBS(FXColorDialog)
+DECLARE_FXDIALOGBOX_STUBS(FXColorDialog)
+
+/* Start stub declarations for class FXRbColorItem */
+DECLARE_FXOBJECT_STUBS(FXColorItem)
+DECLARE_FXLISTITEM_STUBS(FXColorItem)
+
+/* Start stub declarations for class FXRbColorList */
+DECLARE_FXOBJECT_STUBS(FXColorList)
+DECLARE_FXID_STUBS(FXColorList)
+DECLARE_FXDRAWABLE_STUBS(FXColorList)
+DECLARE_FXWINDOW_STUBS(FXColorList)
+DECLARE_FXSCROLLAREA_STUBS(FXColorList)
+DECLARE_FXLIST_STUBS(FXColorList)
+
+/* Start stub declarations for class FXRbColorRing */
+DECLARE_FXOBJECT_STUBS(FXColorRing)
+DECLARE_FXID_STUBS(FXColorRing)
+DECLARE_FXDRAWABLE_STUBS(FXColorRing)
+DECLARE_FXWINDOW_STUBS(FXColorRing)
+
+/* Start stub declarations for class FXRbColorSelector */
+DECLARE_FXOBJECT_STUBS(FXColorSelector)
+DECLARE_FXID_STUBS(FXColorSelector)
+DECLARE_FXDRAWABLE_STUBS(FXColorSelector)
+DECLARE_FXWINDOW_STUBS(FXColorSelector)
+
+/* Start stub declarations for class FXRbColorWell */
+DECLARE_FXOBJECT_STUBS(FXColorWell)
+DECLARE_FXID_STUBS(FXColorWell)
+DECLARE_FXDRAWABLE_STUBS(FXColorWell)
+DECLARE_FXWINDOW_STUBS(FXColorWell)
+
+/* Start stub declarations for class FXRbColorWheel */
+DECLARE_FXOBJECT_STUBS(FXColorWheel)
+DECLARE_FXID_STUBS(FXColorWheel)
+DECLARE_FXDRAWABLE_STUBS(FXColorWheel)
+DECLARE_FXWINDOW_STUBS(FXColorWheel)
+
+/* Start stub declarations for class FXRbComboBox */
+DECLARE_FXOBJECT_STUBS(FXComboBox)
+DECLARE_FXID_STUBS(FXComboBox)
+DECLARE_FXDRAWABLE_STUBS(FXComboBox)
+DECLARE_FXWINDOW_STUBS(FXComboBox)
+
+/* Start stub declarations for class FXRbComposite */
+DECLARE_FXOBJECT_STUBS(FXComposite)
+DECLARE_FXID_STUBS(FXComposite)
+DECLARE_FXDRAWABLE_STUBS(FXComposite)
+DECLARE_FXWINDOW_STUBS(FXComposite)
+
+/* Start stub declarations for class FXRbCursor */
+DECLARE_FXOBJECT_STUBS(FXCursor)
+DECLARE_FXID_STUBS(FXCursor)
+DECLARE_FXCURSOR_STUBS(FXCursor)
+
+/* Start stub declarations for class FXRbDC */
+DECLARE_FXDC_STUBS(FXDC)
+
+/* Start stub declarations for class FXRbDCPrint */
+DECLARE_FXDC_STUBS(FXDCPrint)
+
+/* Start stub declarations for class FXRbDCWindow */
+DECLARE_FXDC_STUBS(FXDCWindow)
+
+/* Start stub declarations for class FXRbDataTarget */
+DECLARE_FXOBJECT_STUBS(FXDataTarget)
+
+/* Start stub declarations for class FXRbDebugTarget */
+DECLARE_FXOBJECT_STUBS(FXDebugTarget)
+
+/* Start stub declarations for class FXRbDelegator */
+DECLARE_FXOBJECT_STUBS(FXDelegator)
+
+/* Start stub declarations for class FXRbDial */
+DECLARE_FXOBJECT_STUBS(FXDial)
+DECLARE_FXID_STUBS(FXDial)
+DECLARE_FXDRAWABLE_STUBS(FXDial)
+DECLARE_FXWINDOW_STUBS(FXDial)
+
+/* Start stub declarations for class FXRbDialogBox */
+DECLARE_FXOBJECT_STUBS(FXDialogBox)
+DECLARE_FXID_STUBS(FXDialogBox)
+DECLARE_FXDRAWABLE_STUBS(FXDialogBox)
+DECLARE_FXWINDOW_STUBS(FXDialogBox)
+DECLARE_FXTOPWINDOW_STUBS(FXDialogBox)
+DECLARE_FXDIALOGBOX_STUBS(FXDialogBox)
+
+/* Start stub declarations for class FXRbDict */
+DECLARE_FXOBJECT_STUBS(FXDict)
+
+/* Start stub declarations for class FXRbDirBox */
+DECLARE_FXOBJECT_STUBS(FXDirBox)
+DECLARE_FXID_STUBS(FXDirBox)
+DECLARE_FXDRAWABLE_STUBS(FXDirBox)
+DECLARE_FXWINDOW_STUBS(FXDirBox)
+DECLARE_FXTREELISTBOX_STUBS(FXDirBox)
+
+/* Start stub declarations for class FXRbDirDialog */
+DECLARE_FXOBJECT_STUBS(FXDirDialog)
+DECLARE_FXID_STUBS(FXDirDialog)
+DECLARE_FXDRAWABLE_STUBS(FXDirDialog)
+DECLARE_FXWINDOW_STUBS(FXDirDialog)
+DECLARE_FXTOPWINDOW_STUBS(FXDirDialog)
+DECLARE_FXDIALOGBOX_STUBS(FXDirDialog)
+
+/* Start stub declarations for class FXRbDirItem */
+DECLARE_FXOBJECT_STUBS(FXDirItem)
+DECLARE_FXTREEITEM_STUBS(FXDirItem,FXRbDirItem)
+
+/* Start stub declarations for class FXRbDirList */
+DECLARE_FXOBJECT_STUBS(FXDirList)
+DECLARE_FXID_STUBS(FXDirList)
+DECLARE_FXDRAWABLE_STUBS(FXDirList)
+DECLARE_FXWINDOW_STUBS(FXDirList)
+DECLARE_FXSCROLLAREA_STUBS(FXDirList)
+DECLARE_FXTREELIST_STUBS(FXDirList)
+
+/* Start stub declarations for class FXRbDirSelector */
+DECLARE_FXOBJECT_STUBS(FXDirSelector)
+DECLARE_FXID_STUBS(FXDirSelector)
+DECLARE_FXDRAWABLE_STUBS(FXDirSelector)
+DECLARE_FXWINDOW_STUBS(FXDirSelector)
+
+/* Start stub declarations for class FXRbDockBar */
+DECLARE_FXOBJECT_STUBS(FXDockBar)
+DECLARE_FXID_STUBS(FXDockBar)
+DECLARE_FXDRAWABLE_STUBS(FXDockBar)
+DECLARE_FXWINDOW_STUBS(FXDockBar)
+DECLARE_FXDOCKBAR_STUBS(FXDockBar)
+
+/* Start stub declarations for class FXRbDockHandler */
+DECLARE_FXOBJECT_STUBS(FXDockHandler)
+DECLARE_FXID_STUBS(FXDockHandler)
+DECLARE_FXDRAWABLE_STUBS(FXDockHandler)
+DECLARE_FXWINDOW_STUBS(FXDockHandler)
+
+/* Start stub declarations for class FXRbDockSite */
+DECLARE_FXOBJECT_STUBS(FXDockSite)
+DECLARE_FXID_STUBS(FXDockSite)
+DECLARE_FXDRAWABLE_STUBS(FXDockSite)
+DECLARE_FXWINDOW_STUBS(FXDockSite)
+DECLARE_FXDOCKSITE_STUBS(FXDockSite)
+
+/* Start stub declarations for class FXRbDockTitle */
+DECLARE_FXOBJECT_STUBS(FXDockTitle)
+DECLARE_FXID_STUBS(FXDockTitle)
+DECLARE_FXDRAWABLE_STUBS(FXDockTitle)
+DECLARE_FXWINDOW_STUBS(FXDockTitle)
+
+/* Start stub declarations for class FXRbDocument */
+DECLARE_FXOBJECT_STUBS(FXDocument)
+
+/* Start stub declarations for class FXRbDragCorner */
+DECLARE_FXOBJECT_STUBS(FXDragCorner)
+DECLARE_FXID_STUBS(FXDragCorner)
+DECLARE_FXDRAWABLE_STUBS(FXDragCorner)
+DECLARE_FXWINDOW_STUBS(FXDragCorner)
+
+/* Start stub declarations for class FXRbDrawable */
+DECLARE_FXOBJECT_STUBS(FXDrawable)
+DECLARE_FXID_STUBS(FXDrawable)
+DECLARE_FXDRAWABLE_STUBS(FXDrawable)
+
+/* Start stub declarations for class FXRbDriveBox */
+DECLARE_FXOBJECT_STUBS(FXDriveBox)
+DECLARE_FXID_STUBS(FXDriveBox)
+DECLARE_FXDRAWABLE_STUBS(FXDriveBox)
+DECLARE_FXWINDOW_STUBS(FXDriveBox)
+DECLARE_FXLISTBOX_STUBS(FXDriveBox)
+
+/* Start stub declarations for class FXRbFileDialog */
+DECLARE_FXOBJECT_STUBS(FXFileDialog)
+DECLARE_FXID_STUBS(FXFileDialog)
+DECLARE_FXDRAWABLE_STUBS(FXFileDialog)
+DECLARE_FXWINDOW_STUBS(FXFileDialog)
+DECLARE_FXTOPWINDOW_STUBS(FXFileDialog)
+DECLARE_FXDIALOGBOX_STUBS(FXFileDialog)
+
+/* Start stub declarations for class FXRbIconDict */
+DECLARE_FXOBJECT_STUBS(FXIconDict)
+
+/* Start stub declarations for class FXRbFileDict */
+DECLARE_FXOBJECT_STUBS(FXFileDict)
+DECLARE_FXFILEDICT_STUBS(FXFileDict)
+
+/* Start stub declarations for class FXRbFileItem */
+DECLARE_FXOBJECT_STUBS(FXFileItem)
+DECLARE_FXICONITEM_STUBS(FXFileItem,FXRbFileItem)
+
+/* Start stub declarations for class FXRbFileList */
+DECLARE_FXOBJECT_STUBS(FXFileList)
+DECLARE_FXID_STUBS(FXFileList)
+DECLARE_FXDRAWABLE_STUBS(FXFileList)
+DECLARE_FXWINDOW_STUBS(FXFileList)
+DECLARE_FXSCROLLAREA_STUBS(FXFileList)
+DECLARE_FXICONLIST_STUBS(FXFileList)
+
+/* Start stub declarations for class FXRbFileSelector */
+DECLARE_FXOBJECT_STUBS(FXFileSelector)
+DECLARE_FXID_STUBS(FXFileSelector)
+DECLARE_FXDRAWABLE_STUBS(FXFileSelector)
+DECLARE_FXWINDOW_STUBS(FXFileSelector)
+
+/* Start stub declarations for class FXRbFoldingItem */
+DECLARE_FXOBJECT_STUBS(FXFoldingItem)
+DECLARE_FXFOLDINGITEM_STUBS(FXFoldingItem)
+
+/* Start stub declarations for class FXRbFoldingList */
+DECLARE_FXOBJECT_STUBS(FXFoldingList)
+DECLARE_FXID_STUBS(FXFoldingList)
+DECLARE_FXDRAWABLE_STUBS(FXFoldingList)
+DECLARE_FXWINDOW_STUBS(FXFoldingList)
+DECLARE_FXSCROLLAREA_STUBS(FXFoldingList)
+DECLARE_FXFOLDINGLIST_STUBS(FXFoldingList)
+
+/* Start stub declarations for class FXRbFont */
+DECLARE_FXOBJECT_STUBS(FXFont)
+DECLARE_FXID_STUBS(FXFont)
+DECLARE_FXFONT_STUBS(FXFont)
+
+/* Start stub declarations for class FXRbFontDialog */
+DECLARE_FXOBJECT_STUBS(FXFontDialog)
+DECLARE_FXID_STUBS(FXFontDialog)
+DECLARE_FXDRAWABLE_STUBS(FXFontDialog)
+DECLARE_FXWINDOW_STUBS(FXFontDialog)
+DECLARE_FXTOPWINDOW_STUBS(FXFontDialog)
+DECLARE_FXDIALOGBOX_STUBS(FXFontDialog)
+
+/* Start stub declarations for class FXRbFontSelector */
+DECLARE_FXOBJECT_STUBS(FXFontSelector)
+DECLARE_FXID_STUBS(FXFontSelector)
+DECLARE_FXDRAWABLE_STUBS(FXFontSelector)
+DECLARE_FXWINDOW_STUBS(FXFontSelector)
+
+/* Start stub declarations for class FXRbFrame */
+DECLARE_FXOBJECT_STUBS(FXFrame)
+DECLARE_FXID_STUBS(FXFrame)
+DECLARE_FXDRAWABLE_STUBS(FXFrame)
+DECLARE_FXWINDOW_STUBS(FXFrame)
+
+/* Start stub declarations for class FXRbGIFCursor */
+DECLARE_FXOBJECT_STUBS(FXGIFCursor)
+DECLARE_FXID_STUBS(FXGIFCursor)
+DECLARE_FXCURSOR_STUBS(FXGIFCursor)
+
+/* Start stub declarations for class FXRbGIFIcon */
+DECLARE_FXOBJECT_STUBS(FXGIFIcon)
+DECLARE_FXID_STUBS(FXGIFIcon)
+DECLARE_FXDRAWABLE_STUBS(FXGIFIcon)
+DECLARE_FXIMAGE_STUBS(FXGIFIcon)
+
+/* Start stub declarations for class FXRbGIFImage */
+DECLARE_FXOBJECT_STUBS(FXGIFImage)
+DECLARE_FXID_STUBS(FXGIFImage)
+DECLARE_FXDRAWABLE_STUBS(FXGIFImage)
+DECLARE_FXIMAGE_STUBS(FXGIFImage)
+
+/* Start stub declarations for class FXRbGLCanvas */
+DECLARE_FXOBJECT_STUBS(FXGLCanvas)
+DECLARE_FXID_STUBS(FXGLCanvas)
+DECLARE_FXDRAWABLE_STUBS(FXGLCanvas)
+DECLARE_FXWINDOW_STUBS(FXGLCanvas)
+DECLARE_FXGLCANVAS_STUBS(FXGLCanvas)
+
+/* Start stub declarations for class FXRbGLContext */
+DECLARE_FXOBJECT_STUBS(FXGLContext)
+DECLARE_FXID_STUBS(FXGLContext)
+
+/* Start stub declarations for class FXRbGLObject */
+DECLARE_FXOBJECT_STUBS(FXGLObject)
+DECLARE_FXGLOBJECT_STUBS(FXGLObject)
+
+/* Start stub declarations for class FXRbGLShape */
+DECLARE_FXOBJECT_STUBS(FXGLShape)
+DECLARE_FXGLOBJECT_STUBS(FXGLShape)
+DECLARE_FXGLSHAPE_STUBS(FXGLShape,FXRbGLShape)
+
+/* Start stub declarations for class FXRbGLViewer */
+DECLARE_FXOBJECT_STUBS(FXGLViewer)
+DECLARE_FXID_STUBS(FXGLViewer)
+DECLARE_FXDRAWABLE_STUBS(FXGLViewer)
+DECLARE_FXWINDOW_STUBS(FXGLViewer)
+DECLARE_FXGLCANVAS_STUBS(FXGLViewer)
+DECLARE_FXGLVIEWER_STUBS(FXGLViewer)
+
+/* Start stub declarations for class FXRbGLVisual */
+DECLARE_FXOBJECT_STUBS(FXGLVisual)
+DECLARE_FXID_STUBS(FXGLVisual)
+
+/* Start stub declarations for class FXRbGradientBar */
+DECLARE_FXOBJECT_STUBS(FXGradientBar)
+DECLARE_FXID_STUBS(FXGradientBar)
+DECLARE_FXDRAWABLE_STUBS(FXGradientBar)
+DECLARE_FXWINDOW_STUBS(FXGradientBar)
+
+/* Start stub declarations for class FXRbGroupBox */
+DECLARE_FXOBJECT_STUBS(FXGroupBox)
+DECLARE_FXID_STUBS(FXGroupBox)
+DECLARE_FXDRAWABLE_STUBS(FXGroupBox)
+DECLARE_FXWINDOW_STUBS(FXGroupBox)
+
+/* Start stub declarations for class FXRbHeaderItem */
+DECLARE_FXOBJECT_STUBS(FXHeaderItem)
+DECLARE_FXHEADERITEM_STUBS(FXHeaderItem)
+
+/* Start stub declarations for class FXRbHeader */
+DECLARE_FXOBJECT_STUBS(FXHeader)
+DECLARE_FXID_STUBS(FXHeader)
+DECLARE_FXDRAWABLE_STUBS(FXHeader)
+DECLARE_FXWINDOW_STUBS(FXHeader)
+
+/* Start stub declarations for class FXRbHorizontalFrame */
+DECLARE_FXOBJECT_STUBS(FXHorizontalFrame)
+DECLARE_FXID_STUBS(FXHorizontalFrame)
+DECLARE_FXDRAWABLE_STUBS(FXHorizontalFrame)
+DECLARE_FXWINDOW_STUBS(FXHorizontalFrame)
+
+/* Start stub declarations for class FXRbICOIcon */
+DECLARE_FXOBJECT_STUBS(FXICOIcon)
+DECLARE_FXID_STUBS(FXICOIcon)
+DECLARE_FXDRAWABLE_STUBS(FXICOIcon)
+DECLARE_FXIMAGE_STUBS(FXICOIcon)
+
+/* Start stub declarations for class FXRbICOImage */
+DECLARE_FXOBJECT_STUBS(FXICOImage)
+DECLARE_FXID_STUBS(FXICOImage)
+DECLARE_FXDRAWABLE_STUBS(FXICOImage)
+DECLARE_FXIMAGE_STUBS(FXICOImage)
+
+/* Start stub declarations for class FXRbIcon */
+DECLARE_FXOBJECT_STUBS(FXIcon)
+DECLARE_FXID_STUBS(FXIcon)
+DECLARE_FXDRAWABLE_STUBS(FXIcon)
+DECLARE_FXIMAGE_STUBS(FXIcon)
+
+/* Start stub declarations for class FXRbIconItem */
+DECLARE_FXOBJECT_STUBS(FXIconItem)
+DECLARE_FXICONITEM_STUBS(FXIconItem,FXRbIconItem)
+
+/* Start stub declarations for class FXRbIconList */
+DECLARE_FXOBJECT_STUBS(FXIconList)
+DECLARE_FXID_STUBS(FXIconList)
+DECLARE_FXDRAWABLE_STUBS(FXIconList)
+DECLARE_FXWINDOW_STUBS(FXIconList)
+DECLARE_FXSCROLLAREA_STUBS(FXIconList)
+DECLARE_FXICONLIST_STUBS(FXIconList)
+
+/* Start stub declarations for class FXRbIconSource */
+DECLARE_FXOBJECT_STUBS(FXIconSource)
+DECLARE_FXICONSOURCE_STUBS(FXIconSource)
+
+/* Start stub declarations for class FXRbId */
+DECLARE_FXOBJECT_STUBS(FXId)
+DECLARE_FXID_STUBS(FXId)
+
+/* Start stub declarations for class FXRbImage */
+DECLARE_FXOBJECT_STUBS(FXImage)
+DECLARE_FXID_STUBS(FXImage)
+DECLARE_FXDRAWABLE_STUBS(FXImage)
+DECLARE_FXIMAGE_STUBS(FXImage)
+
+/* Start stub declarations for class FXRbImageFrame */
+DECLARE_FXOBJECT_STUBS(FXImageFrame)
+DECLARE_FXID_STUBS(FXImageFrame)
+DECLARE_FXDRAWABLE_STUBS(FXImageFrame)
+DECLARE_FXWINDOW_STUBS(FXImageFrame)
+
+/* Start stub declarations for class FXRbImageView */
+DECLARE_FXOBJECT_STUBS(FXImageView)
+DECLARE_FXID_STUBS(FXImageView)
+DECLARE_FXDRAWABLE_STUBS(FXImageView)
+DECLARE_FXWINDOW_STUBS(FXImageView)
+DECLARE_FXSCROLLAREA_STUBS(FXImageView)
+
+/* Start stub declarations for class FXRbInputDialog */
+DECLARE_FXOBJECT_STUBS(FXInputDialog)
+DECLARE_FXID_STUBS(FXInputDialog)
+DECLARE_FXDRAWABLE_STUBS(FXInputDialog)
+DECLARE_FXWINDOW_STUBS(FXInputDialog)
+DECLARE_FXTOPWINDOW_STUBS(FXInputDialog)
+DECLARE_FXDIALOGBOX_STUBS(FXInputDialog)
+
+/* Start stub declarations for class FXRbJPGIcon */
+DECLARE_FXOBJECT_STUBS(FXJPGIcon)
+DECLARE_FXID_STUBS(FXJPGIcon)
+DECLARE_FXDRAWABLE_STUBS(FXJPGIcon)
+DECLARE_FXIMAGE_STUBS(FXJPGIcon)
+
+/* Start stub declarations for class FXRbJPGImage */
+DECLARE_FXOBJECT_STUBS(FXJPGImage)
+DECLARE_FXID_STUBS(FXJPGImage)
+DECLARE_FXDRAWABLE_STUBS(FXJPGImage)
+DECLARE_FXIMAGE_STUBS(FXJPGImage)
+
+/* Start stub declarations for class FXRbKnob */
+DECLARE_FXOBJECT_STUBS(FXKnob)
+DECLARE_FXID_STUBS(FXKnob)
+DECLARE_FXDRAWABLE_STUBS(FXKnob)
+DECLARE_FXWINDOW_STUBS(FXKnob)
+
+/* Start stub declarations for class FXRbLabel */
+DECLARE_FXOBJECT_STUBS(FXLabel)
+DECLARE_FXID_STUBS(FXLabel)
+DECLARE_FXDRAWABLE_STUBS(FXLabel)
+DECLARE_FXWINDOW_STUBS(FXLabel)
+
+/* Start stub declarations for class FXRbListItem */
+DECLARE_FXOBJECT_STUBS(FXListItem)
+DECLARE_FXLISTITEM_STUBS(FXListItem)
+
+/* Start stub declarations for class FXRbList */
+DECLARE_FXOBJECT_STUBS(FXList)
+DECLARE_FXID_STUBS(FXList)
+DECLARE_FXDRAWABLE_STUBS(FXList)
+DECLARE_FXWINDOW_STUBS(FXList)
+DECLARE_FXSCROLLAREA_STUBS(FXList)
+DECLARE_FXLIST_STUBS(FXList)
+
+/* Start stub declarations for class FXRbListBox */
+DECLARE_FXOBJECT_STUBS(FXListBox)
+DECLARE_FXID_STUBS(FXListBox)
+DECLARE_FXDRAWABLE_STUBS(FXListBox)
+DECLARE_FXWINDOW_STUBS(FXListBox)
+DECLARE_FXLISTBOX_STUBS(FXListBox)
+
+/* Start stub declarations for class FXRbMDIDeleteButton */
+DECLARE_FXOBJECT_STUBS(FXMDIDeleteButton)
+DECLARE_FXID_STUBS(FXMDIDeleteButton)
+DECLARE_FXDRAWABLE_STUBS(FXMDIDeleteButton)
+DECLARE_FXWINDOW_STUBS(FXMDIDeleteButton)
+
+/* Start stub declarations for class FXRbMDIRestoreButton */
+DECLARE_FXOBJECT_STUBS(FXMDIRestoreButton)
+DECLARE_FXID_STUBS(FXMDIRestoreButton)
+DECLARE_FXDRAWABLE_STUBS(FXMDIRestoreButton)
+DECLARE_FXWINDOW_STUBS(FXMDIRestoreButton)
+
+/* Start stub declarations for class FXRbMDIMinimizeButton */
+DECLARE_FXOBJECT_STUBS(FXMDIMinimizeButton)
+DECLARE_FXID_STUBS(FXMDIMinimizeButton)
+DECLARE_FXDRAWABLE_STUBS(FXMDIMinimizeButton)
+DECLARE_FXWINDOW_STUBS(FXMDIMinimizeButton)
+
+/* Start stub declarations for class FXRbMDIMaximizeButton */
+DECLARE_FXOBJECT_STUBS(FXMDIMaximizeButton)
+DECLARE_FXID_STUBS(FXMDIMaximizeButton)
+DECLARE_FXDRAWABLE_STUBS(FXMDIMaximizeButton)
+DECLARE_FXWINDOW_STUBS(FXMDIMaximizeButton)
+
+/* Start stub declarations for class FXRbMDIWindowButton */
+DECLARE_FXOBJECT_STUBS(FXMDIWindowButton)
+DECLARE_FXID_STUBS(FXMDIWindowButton)
+DECLARE_FXDRAWABLE_STUBS(FXMDIWindowButton)
+DECLARE_FXWINDOW_STUBS(FXMDIWindowButton)
+
+/* Start stub declarations for class FXRbMDIMenu */
+DECLARE_FXOBJECT_STUBS(FXMDIMenu)
+DECLARE_FXID_STUBS(FXMDIMenu)
+DECLARE_FXDRAWABLE_STUBS(FXMDIMenu)
+DECLARE_FXWINDOW_STUBS(FXMDIMenu)
+DECLARE_FXPOPUP_STUBS(FXMDIMenu)
+
+/* Start stub declarations for class FXRbMDIChild */
+DECLARE_FXOBJECT_STUBS(FXMDIChild)
+DECLARE_FXID_STUBS(FXMDIChild)
+DECLARE_FXDRAWABLE_STUBS(FXMDIChild)
+DECLARE_FXWINDOW_STUBS(FXMDIChild)
+DECLARE_FXMDICHILD_STUBS(FXMDIChild)
+
+/* Start stub declarations for class FXRbMDIClient */
+DECLARE_FXOBJECT_STUBS(FXMDIClient)
+DECLARE_FXID_STUBS(FXMDIClient)
+DECLARE_FXDRAWABLE_STUBS(FXMDIClient)
+DECLARE_FXWINDOW_STUBS(FXMDIClient)
+DECLARE_FXMDICLIENT_STUBS(FXMDIClient)
+
+/* Start stub declarations for class FXRbMainWindow */
+DECLARE_FXOBJECT_STUBS(FXMainWindow)
+DECLARE_FXID_STUBS(FXMainWindow)
+DECLARE_FXDRAWABLE_STUBS(FXMainWindow)
+DECLARE_FXWINDOW_STUBS(FXMainWindow)
+DECLARE_FXTOPWINDOW_STUBS(FXMainWindow)
+
+/* Start stub declarations for class FXRbMatrix */
+DECLARE_FXOBJECT_STUBS(FXMatrix)
+DECLARE_FXID_STUBS(FXMatrix)
+DECLARE_FXDRAWABLE_STUBS(FXMatrix)
+DECLARE_FXWINDOW_STUBS(FXMatrix)
+
+/* Start stub declarations for class FXRbMenuBar */
+DECLARE_FXOBJECT_STUBS(FXMenuBar)
+DECLARE_FXID_STUBS(FXMenuBar)
+DECLARE_FXDRAWABLE_STUBS(FXMenuBar)
+DECLARE_FXWINDOW_STUBS(FXMenuBar)
+DECLARE_FXDOCKBAR_STUBS(FXMenuBar)
+
+/* Start stub declarations for class FXRbMenuButton */
+DECLARE_FXOBJECT_STUBS(FXMenuButton)
+DECLARE_FXID_STUBS(FXMenuButton)
+DECLARE_FXDRAWABLE_STUBS(FXMenuButton)
+DECLARE_FXWINDOW_STUBS(FXMenuButton)
+
+/* Start stub declarations for class FXRbMenuCaption */
+DECLARE_FXOBJECT_STUBS(FXMenuCaption)
+DECLARE_FXID_STUBS(FXMenuCaption)
+DECLARE_FXDRAWABLE_STUBS(FXMenuCaption)
+DECLARE_FXWINDOW_STUBS(FXMenuCaption)
+
+/* Start stub declarations for class FXRbMenuCascade */
+DECLARE_FXOBJECT_STUBS(FXMenuCascade)
+DECLARE_FXID_STUBS(FXMenuCascade)
+DECLARE_FXDRAWABLE_STUBS(FXMenuCascade)
+DECLARE_FXWINDOW_STUBS(FXMenuCascade)
+
+/* Start stub declarations for class FXRbMenuCheck */
+DECLARE_FXOBJECT_STUBS(FXMenuCheck)
+DECLARE_FXID_STUBS(FXMenuCheck)
+DECLARE_FXDRAWABLE_STUBS(FXMenuCheck)
+DECLARE_FXWINDOW_STUBS(FXMenuCheck)
+
+/* Start stub declarations for class FXRbMenuCommand */
+DECLARE_FXOBJECT_STUBS(FXMenuCommand)
+DECLARE_FXID_STUBS(FXMenuCommand)
+DECLARE_FXDRAWABLE_STUBS(FXMenuCommand)
+DECLARE_FXWINDOW_STUBS(FXMenuCommand)
+
+/* Start stub declarations for class FXRbMenuPane */
+DECLARE_FXOBJECT_STUBS(FXMenuPane)
+DECLARE_FXID_STUBS(FXMenuPane)
+DECLARE_FXDRAWABLE_STUBS(FXMenuPane)
+DECLARE_FXWINDOW_STUBS(FXMenuPane)
+DECLARE_FXPOPUP_STUBS(FXMenuPane)
+
+/* Start stub declarations for class FXRbMenuRadio */
+DECLARE_FXOBJECT_STUBS(FXMenuRadio)
+DECLARE_FXID_STUBS(FXMenuRadio)
+DECLARE_FXDRAWABLE_STUBS(FXMenuRadio)
+DECLARE_FXWINDOW_STUBS(FXMenuRadio)
+
+/* Start stub declarations for class FXRbMenuSeparator */
+DECLARE_FXOBJECT_STUBS(FXMenuSeparator)
+DECLARE_FXID_STUBS(FXMenuSeparator)
+DECLARE_FXDRAWABLE_STUBS(FXMenuSeparator)
+DECLARE_FXWINDOW_STUBS(FXMenuSeparator)
+
+/* Start stub declarations for class FXRbMenuTitle */
+DECLARE_FXOBJECT_STUBS(FXMenuTitle)
+DECLARE_FXID_STUBS(FXMenuTitle)
+DECLARE_FXDRAWABLE_STUBS(FXMenuTitle)
+DECLARE_FXWINDOW_STUBS(FXMenuTitle)
+
+/* Start stub declarations for class FXRbMessageBox */
+DECLARE_FXOBJECT_STUBS(FXMessageBox)
+DECLARE_FXID_STUBS(FXMessageBox)
+DECLARE_FXDRAWABLE_STUBS(FXMessageBox)
+DECLARE_FXWINDOW_STUBS(FXMessageBox)
+DECLARE_FXTOPWINDOW_STUBS(FXMessageBox)
+DECLARE_FXDIALOGBOX_STUBS(FXMessageBox)
+
+/* Start stub declarations for class FXRbObjRegistry */
+
+/* Start stub declarations for class FXRbObject */
+DECLARE_FXOBJECT_STUBS(FXObject)
+
+/* Start stub declarations for class FXRbOption */
+DECLARE_FXOBJECT_STUBS(FXOption)
+DECLARE_FXID_STUBS(FXOption)
+DECLARE_FXDRAWABLE_STUBS(FXOption)
+DECLARE_FXWINDOW_STUBS(FXOption)
+
+/* Start stub declarations for class FXRbOptionMenu */
+DECLARE_FXOBJECT_STUBS(FXOptionMenu)
+DECLARE_FXID_STUBS(FXOptionMenu)
+DECLARE_FXDRAWABLE_STUBS(FXOptionMenu)
+DECLARE_FXWINDOW_STUBS(FXOptionMenu)
+
+/* Start stub declarations for class FXRbPCXIcon */
+DECLARE_FXOBJECT_STUBS(FXPCXIcon)
+DECLARE_FXID_STUBS(FXPCXIcon)
+DECLARE_FXDRAWABLE_STUBS(FXPCXIcon)
+DECLARE_FXIMAGE_STUBS(FXPCXIcon)
+
+/* Start stub declarations for class FXRbPCXImage */
+DECLARE_FXOBJECT_STUBS(FXPCXImage)
+DECLARE_FXID_STUBS(FXPCXImage)
+DECLARE_FXDRAWABLE_STUBS(FXPCXImage)
+DECLARE_FXIMAGE_STUBS(FXPCXImage)
+
+/* Start stub declarations for class FXRbPNGIcon */
+DECLARE_FXOBJECT_STUBS(FXPNGIcon)
+DECLARE_FXID_STUBS(FXPNGIcon)
+DECLARE_FXDRAWABLE_STUBS(FXPNGIcon)
+DECLARE_FXIMAGE_STUBS(FXPNGIcon)
+
+/* Start stub declarations for class FXRbPNGImage */
+DECLARE_FXOBJECT_STUBS(FXPNGImage)
+DECLARE_FXID_STUBS(FXPNGImage)
+DECLARE_FXDRAWABLE_STUBS(FXPNGImage)
+DECLARE_FXIMAGE_STUBS(FXPNGImage)
+
+/* Start stub declarations for class FXRbPPMIcon */
+DECLARE_FXOBJECT_STUBS(FXPPMIcon)
+DECLARE_FXID_STUBS(FXPPMIcon)
+DECLARE_FXDRAWABLE_STUBS(FXPPMIcon)
+DECLARE_FXIMAGE_STUBS(FXPPMIcon)
+
+/* Start stub declarations for class FXRbPPMImage */
+DECLARE_FXOBJECT_STUBS(FXPPMImage)
+DECLARE_FXID_STUBS(FXPPMImage)
+DECLARE_FXDRAWABLE_STUBS(FXPPMImage)
+DECLARE_FXIMAGE_STUBS(FXPPMImage)
+
+/* Start stub declarations for class FXRbPacker */
+DECLARE_FXOBJECT_STUBS(FXPacker)
+DECLARE_FXID_STUBS(FXPacker)
+DECLARE_FXDRAWABLE_STUBS(FXPacker)
+DECLARE_FXWINDOW_STUBS(FXPacker)
+
+/* Start stub declarations for class FXRbPicker */
+DECLARE_FXOBJECT_STUBS(FXPicker)
+DECLARE_FXID_STUBS(FXPicker)
+DECLARE_FXDRAWABLE_STUBS(FXPicker)
+DECLARE_FXWINDOW_STUBS(FXPicker)
+
+/* Start stub declarations for class FXRbPopup */
+DECLARE_FXOBJECT_STUBS(FXPopup)
+DECLARE_FXID_STUBS(FXPopup)
+DECLARE_FXDRAWABLE_STUBS(FXPopup)
+DECLARE_FXWINDOW_STUBS(FXPopup)
+DECLARE_FXPOPUP_STUBS(FXPopup)
+
+/* Start stub declarations for class FXRbPrintDialog */
+DECLARE_FXOBJECT_STUBS(FXPrintDialog)
+DECLARE_FXID_STUBS(FXPrintDialog)
+DECLARE_FXDRAWABLE_STUBS(FXPrintDialog)
+DECLARE_FXWINDOW_STUBS(FXPrintDialog)
+DECLARE_FXTOPWINDOW_STUBS(FXPrintDialog)
+DECLARE_FXDIALOGBOX_STUBS(FXPrintDialog)
+
+/* Start stub declarations for class FXRbProgressBar */
+DECLARE_FXOBJECT_STUBS(FXProgressBar)
+DECLARE_FXID_STUBS(FXProgressBar)
+DECLARE_FXDRAWABLE_STUBS(FXProgressBar)
+DECLARE_FXWINDOW_STUBS(FXProgressBar)
+
+/* Start stub declarations for class FXRbProgressDialog */
+DECLARE_FXOBJECT_STUBS(FXProgressDialog)
+DECLARE_FXID_STUBS(FXProgressDialog)
+DECLARE_FXDRAWABLE_STUBS(FXProgressDialog)
+DECLARE_FXWINDOW_STUBS(FXProgressDialog)
+DECLARE_FXTOPWINDOW_STUBS(FXProgressDialog)
+DECLARE_FXDIALOGBOX_STUBS(FXProgressDialog)
+
+/* Start stub declarations for class FXRbRGBIcon */
+DECLARE_FXOBJECT_STUBS(FXRGBIcon)
+DECLARE_FXID_STUBS(FXRGBIcon)
+DECLARE_FXDRAWABLE_STUBS(FXRGBIcon)
+DECLARE_FXIMAGE_STUBS(FXRGBIcon)
+
+/* Start stub declarations for class FXRbRGBImage */
+DECLARE_FXOBJECT_STUBS(FXRGBImage)
+DECLARE_FXID_STUBS(FXRGBImage)
+DECLARE_FXDRAWABLE_STUBS(FXRGBImage)
+DECLARE_FXIMAGE_STUBS(FXRGBImage)
+
+/* Start stub declarations for class FXRbRadioButton */
+DECLARE_FXOBJECT_STUBS(FXRadioButton)
+DECLARE_FXID_STUBS(FXRadioButton)
+DECLARE_FXDRAWABLE_STUBS(FXRadioButton)
+DECLARE_FXWINDOW_STUBS(FXRadioButton)
+
+/* Start stub declarations for class FXRbRealSlider */
+DECLARE_FXOBJECT_STUBS(FXRealSlider)
+DECLARE_FXID_STUBS(FXRealSlider)
+DECLARE_FXDRAWABLE_STUBS(FXRealSlider)
+DECLARE_FXWINDOW_STUBS(FXRealSlider)
+
+/* Start stub declarations for class FXRbRealSpinner */
+DECLARE_FXOBJECT_STUBS(FXRealSpinner)
+DECLARE_FXID_STUBS(FXRealSpinner)
+DECLARE_FXDRAWABLE_STUBS(FXRealSpinner)
+DECLARE_FXWINDOW_STUBS(FXRealSpinner)
+DECLARE_FXREALSPINNER_STUBS(FXRealSpinner)
+
+/* Start stub declarations for class FXRbRecentFiles */
+DECLARE_FXOBJECT_STUBS(FXRecentFiles)
+
+/* Start stub declarations for class FXRbRegistry */
+DECLARE_FXOBJECT_STUBS(FXRegistry)
+
+/* Start stub declarations for class FXRbReplaceDialog */
+DECLARE_FXOBJECT_STUBS(FXReplaceDialog)
+DECLARE_FXID_STUBS(FXReplaceDialog)
+DECLARE_FXDRAWABLE_STUBS(FXReplaceDialog)
+DECLARE_FXWINDOW_STUBS(FXReplaceDialog)
+DECLARE_FXTOPWINDOW_STUBS(FXReplaceDialog)
+DECLARE_FXDIALOGBOX_STUBS(FXReplaceDialog)
+
+/* Start stub declarations for class FXRbRootWindow */
+DECLARE_FXOBJECT_STUBS(FXRootWindow)
+DECLARE_FXID_STUBS(FXRootWindow)
+DECLARE_FXDRAWABLE_STUBS(FXRootWindow)
+DECLARE_FXWINDOW_STUBS(FXRootWindow)
+
+/* Start stub declarations for class FXRbRuler */
+DECLARE_FXOBJECT_STUBS(FXRuler)
+DECLARE_FXID_STUBS(FXRuler)
+DECLARE_FXDRAWABLE_STUBS(FXRuler)
+DECLARE_FXWINDOW_STUBS(FXRuler)
+
+/* Start stub declarations for class FXRbRulerView */
+DECLARE_FXOBJECT_STUBS(FXRulerView)
+DECLARE_FXID_STUBS(FXRulerView)
+DECLARE_FXDRAWABLE_STUBS(FXRulerView)
+DECLARE_FXWINDOW_STUBS(FXRulerView)
+DECLARE_FXSCROLLAREA_STUBS(FXRulerView)
+
+#ifdef WITH_FXSCINTILLA
+
+/* Start stub declarations for class FXRbScintilla */
+DECLARE_FXOBJECT_STUBS(FXScintilla)
+DECLARE_FXID_STUBS(FXScintilla)
+DECLARE_FXDRAWABLE_STUBS(FXScintilla)
+DECLARE_FXWINDOW_STUBS(FXScintilla)
+DECLARE_FXSCROLLAREA_STUBS(FXScintilla)
+
+#endif
+
+/* Start stub declarations for class FXRbScrollArea */
+DECLARE_FXOBJECT_STUBS(FXScrollArea)
+DECLARE_FXID_STUBS(FXScrollArea)
+DECLARE_FXDRAWABLE_STUBS(FXScrollArea)
+DECLARE_FXWINDOW_STUBS(FXScrollArea)
+DECLARE_FXSCROLLAREA_STUBS(FXScrollArea)
+
+/* Start stub declarations for class FXRbScrollBar */
+DECLARE_FXOBJECT_STUBS(FXScrollBar)
+DECLARE_FXID_STUBS(FXScrollBar)
+DECLARE_FXDRAWABLE_STUBS(FXScrollBar)
+DECLARE_FXWINDOW_STUBS(FXScrollBar)
+
+/* Start stub declarations for class FXRbScrollCorner */
+DECLARE_FXOBJECT_STUBS(FXScrollCorner)
+DECLARE_FXID_STUBS(FXScrollCorner)
+DECLARE_FXDRAWABLE_STUBS(FXScrollCorner)
+DECLARE_FXWINDOW_STUBS(FXScrollCorner)
+
+/* Start stub declarations for class FXRbScrollPane */
+DECLARE_FXOBJECT_STUBS(FXScrollPane)
+DECLARE_FXID_STUBS(FXScrollPane)
+DECLARE_FXDRAWABLE_STUBS(FXScrollPane)
+DECLARE_FXWINDOW_STUBS(FXScrollPane)
+DECLARE_FXPOPUP_STUBS(FXScrollPane)
+
+/* Start stub declarations for class FXRbScrollWindow */
+DECLARE_FXOBJECT_STUBS(FXScrollWindow)
+DECLARE_FXID_STUBS(FXScrollWindow)
+DECLARE_FXDRAWABLE_STUBS(FXScrollWindow)
+DECLARE_FXWINDOW_STUBS(FXScrollWindow)
+DECLARE_FXSCROLLAREA_STUBS(FXScrollWindow)
+
+/* Start stub declarations for class FXRbSearchDialog */
+DECLARE_FXOBJECT_STUBS(FXSearchDialog)
+DECLARE_FXID_STUBS(FXSearchDialog)
+DECLARE_FXDRAWABLE_STUBS(FXSearchDialog)
+DECLARE_FXWINDOW_STUBS(FXSearchDialog)
+DECLARE_FXTOPWINDOW_STUBS(FXSearchDialog)
+DECLARE_FXDIALOGBOX_STUBS(FXSearchDialog)
+
+/* Start stub declarations for class FXRbSeparator */
+DECLARE_FXOBJECT_STUBS(FXSeparator)
+DECLARE_FXID_STUBS(FXSeparator)
+DECLARE_FXDRAWABLE_STUBS(FXSeparator)
+DECLARE_FXWINDOW_STUBS(FXSeparator)
+
+/* Start stub declarations for class FXRbHorizontalSeparator */
+DECLARE_FXOBJECT_STUBS(FXHorizontalSeparator)
+DECLARE_FXID_STUBS(FXHorizontalSeparator)
+DECLARE_FXDRAWABLE_STUBS(FXHorizontalSeparator)
+DECLARE_FXWINDOW_STUBS(FXHorizontalSeparator)
+
+/* Start stub declarations for class FXRbVerticalSeparator */
+DECLARE_FXOBJECT_STUBS(FXVerticalSeparator)
+DECLARE_FXID_STUBS(FXVerticalSeparator)
+DECLARE_FXDRAWABLE_STUBS(FXVerticalSeparator)
+DECLARE_FXWINDOW_STUBS(FXVerticalSeparator)
+
+/* Start stub declarations for class FXRbSettings */
+DECLARE_FXOBJECT_STUBS(FXSettings)
+
+/* Start stub declarations for class FXRbShell */
+DECLARE_FXOBJECT_STUBS(FXShell)
+DECLARE_FXID_STUBS(FXShell)
+DECLARE_FXDRAWABLE_STUBS(FXShell)
+DECLARE_FXWINDOW_STUBS(FXShell)
+
+/* Start stub declarations for class FXRbShutterItem */
+DECLARE_FXOBJECT_STUBS(FXShutterItem)
+DECLARE_FXID_STUBS(FXShutterItem)
+DECLARE_FXDRAWABLE_STUBS(FXShutterItem)
+DECLARE_FXWINDOW_STUBS(FXShutterItem)
+
+/* Start stub declarations for class FXRbShutter */
+DECLARE_FXOBJECT_STUBS(FXShutter)
+DECLARE_FXID_STUBS(FXShutter)
+DECLARE_FXDRAWABLE_STUBS(FXShutter)
+DECLARE_FXWINDOW_STUBS(FXShutter)
+DECLARE_FXSHUTTER_STUBS(FXShutter)
+
+/* Start stub declarations for class FXRbSlider */
+DECLARE_FXOBJECT_STUBS(FXSlider)
+DECLARE_FXID_STUBS(FXSlider)
+DECLARE_FXDRAWABLE_STUBS(FXSlider)
+DECLARE_FXWINDOW_STUBS(FXSlider)
+
+/* Start stub declarations for class FXRbSpinner */
+DECLARE_FXOBJECT_STUBS(FXSpinner)
+DECLARE_FXID_STUBS(FXSpinner)
+DECLARE_FXDRAWABLE_STUBS(FXSpinner)
+DECLARE_FXWINDOW_STUBS(FXSpinner)
+DECLARE_FXSPINNER_STUBS(FXSpinner)
+
+/* Start stub declarations for class FXRbSplashWindow */
+DECLARE_FXOBJECT_STUBS(FXSplashWindow)
+DECLARE_FXID_STUBS(FXSplashWindow)
+DECLARE_FXDRAWABLE_STUBS(FXSplashWindow)
+DECLARE_FXWINDOW_STUBS(FXSplashWindow)
+DECLARE_FXTOPWINDOW_STUBS(FXSplashWindow)
+
+/* Start stub declarations for class FXRbSplitter */
+DECLARE_FXOBJECT_STUBS(FXSplitter)
+DECLARE_FXID_STUBS(FXSplitter)
+DECLARE_FXDRAWABLE_STUBS(FXSplitter)
+DECLARE_FXWINDOW_STUBS(FXSplitter)
+
+/* Start stub declarations for class FXRbSpring */
+DECLARE_FXOBJECT_STUBS(FXSpring)
+DECLARE_FXID_STUBS(FXSpring)
+DECLARE_FXDRAWABLE_STUBS(FXSpring)
+DECLARE_FXWINDOW_STUBS(FXSpring)
+
+/* Start stub declarations for class FXRbStatusBar */
+DECLARE_FXOBJECT_STUBS(FXStatusBar)
+DECLARE_FXID_STUBS(FXStatusBar)
+DECLARE_FXDRAWABLE_STUBS(FXStatusBar)
+DECLARE_FXWINDOW_STUBS(FXStatusBar)
+
+/* Start stub declarations for class FXRbStatusLine */
+DECLARE_FXOBJECT_STUBS(FXStatusLine)
+DECLARE_FXID_STUBS(FXStatusLine)
+DECLARE_FXDRAWABLE_STUBS(FXStatusLine)
+DECLARE_FXWINDOW_STUBS(FXStatusLine)
+
+/* Start stub declarations for class FXRbStream */
+DECLARE_FXSTREAM_STUBS(FXStream)
+
+/* Start stub declarations for class FXRbFileStream */
+DECLARE_FXSTREAM_STUBS(FXFileStream)
+
+/* Start stub declarations for class FXRbMemoryStream */
+DECLARE_FXSTREAM_STUBS(FXMemoryStream)
+
+/* Start stub declarations for class FXRbStringDict */
+DECLARE_FXOBJECT_STUBS(FXStringDict)
+
+/* Start stub declarations for class FXRbSwitcher */
+DECLARE_FXOBJECT_STUBS(FXSwitcher)
+DECLARE_FXID_STUBS(FXSwitcher)
+DECLARE_FXDRAWABLE_STUBS(FXSwitcher)
+DECLARE_FXWINDOW_STUBS(FXSwitcher)
+
+/* Start stub declarations for class FXRbTGAIcon */
+DECLARE_FXOBJECT_STUBS(FXTGAIcon)
+DECLARE_FXID_STUBS(FXTGAIcon)
+DECLARE_FXDRAWABLE_STUBS(FXTGAIcon)
+DECLARE_FXIMAGE_STUBS(FXTGAIcon)
+
+/* Start stub declarations for class FXRbTGAImage */
+DECLARE_FXOBJECT_STUBS(FXTGAImage)
+DECLARE_FXID_STUBS(FXTGAImage)
+DECLARE_FXDRAWABLE_STUBS(FXTGAImage)
+DECLARE_FXIMAGE_STUBS(FXTGAImage)
+
+/* Start stub declarations for class FXRbTIFIcon */
+DECLARE_FXOBJECT_STUBS(FXTIFIcon)
+DECLARE_FXID_STUBS(FXTIFIcon)
+DECLARE_FXDRAWABLE_STUBS(FXTIFIcon)
+DECLARE_FXIMAGE_STUBS(FXTIFIcon)
+
+/* Start stub declarations for class FXRbTIFImage */
+DECLARE_FXOBJECT_STUBS(FXTIFImage)
+DECLARE_FXID_STUBS(FXTIFImage)
+DECLARE_FXDRAWABLE_STUBS(FXTIFImage)
+DECLARE_FXIMAGE_STUBS(FXTIFImage)
+
+/* Start stub declarations for class FXRbTabBar */
+DECLARE_FXOBJECT_STUBS(FXTabBar)
+DECLARE_FXID_STUBS(FXTabBar)
+DECLARE_FXDRAWABLE_STUBS(FXTabBar)
+DECLARE_FXWINDOW_STUBS(FXTabBar)
+DECLARE_FXTABBAR_STUBS(FXTabBar)
+
+/* Start stub declarations for class FXRbTabBook */
+DECLARE_FXOBJECT_STUBS(FXTabBook)
+DECLARE_FXID_STUBS(FXTabBook)
+DECLARE_FXDRAWABLE_STUBS(FXTabBook)
+DECLARE_FXWINDOW_STUBS(FXTabBook)
+DECLARE_FXTABBAR_STUBS(FXTabBook)
+
+/* Start stub declarations for class FXRbTabItem */
+DECLARE_FXOBJECT_STUBS(FXTabItem)
+DECLARE_FXID_STUBS(FXTabItem)
+DECLARE_FXDRAWABLE_STUBS(FXTabItem)
+DECLARE_FXWINDOW_STUBS(FXTabItem)
+
+/* Start stub declarations for class FXRbTableItem */
+DECLARE_FXOBJECT_STUBS(FXTableItem)
+DECLARE_FXTABLEITEM_STUBS(FXTableItem,FXRbTableItem)
+
+/* Start stub declarations for class FXRbTable */
+DECLARE_FXOBJECT_STUBS(FXTable)
+DECLARE_FXID_STUBS(FXTable)
+DECLARE_FXDRAWABLE_STUBS(FXTable)
+DECLARE_FXWINDOW_STUBS(FXTable)
+DECLARE_FXSCROLLAREA_STUBS(FXTable)
+DECLARE_FXTABLE_STUBS(FXTable,FXRbTable)
+
+/* Start stub declarations for class FXRbText */
+DECLARE_FXOBJECT_STUBS(FXText)
+DECLARE_FXID_STUBS(FXText)
+DECLARE_FXDRAWABLE_STUBS(FXText)
+DECLARE_FXWINDOW_STUBS(FXText)
+DECLARE_FXSCROLLAREA_STUBS(FXText)
+DECLARE_FXTEXT_STUBS(FXText,FXRbText)
+
+/* Start stub declarations for class FXRbTextField */
+DECLARE_FXOBJECT_STUBS(FXTextField)
+DECLARE_FXID_STUBS(FXTextField)
+DECLARE_FXDRAWABLE_STUBS(FXTextField)
+DECLARE_FXWINDOW_STUBS(FXTextField)
+
+/* Start stub declarations for class FXRbToggleButton */
+DECLARE_FXOBJECT_STUBS(FXToggleButton)
+DECLARE_FXID_STUBS(FXToggleButton)
+DECLARE_FXDRAWABLE_STUBS(FXToggleButton)
+DECLARE_FXWINDOW_STUBS(FXToggleButton)
+
+/* Start stub declarations for class FXRbToolBar */
+DECLARE_FXOBJECT_STUBS(FXToolBar)
+DECLARE_FXID_STUBS(FXToolBar)
+DECLARE_FXDRAWABLE_STUBS(FXToolBar)
+DECLARE_FXWINDOW_STUBS(FXToolBar)
+DECLARE_FXDOCKBAR_STUBS(FXToolBar)
+
+/* Start stub declarations for class FXRbToolBarGrip */
+DECLARE_FXOBJECT_STUBS(FXToolBarGrip)
+DECLARE_FXID_STUBS(FXToolBarGrip)
+DECLARE_FXDRAWABLE_STUBS(FXToolBarGrip)
+DECLARE_FXWINDOW_STUBS(FXToolBarGrip)
+
+/* Start stub declarations for class FXRbToolBarShell */
+DECLARE_FXOBJECT_STUBS(FXToolBarShell)
+DECLARE_FXID_STUBS(FXToolBarShell)
+DECLARE_FXDRAWABLE_STUBS(FXToolBarShell)
+DECLARE_FXWINDOW_STUBS(FXToolBarShell)
+DECLARE_FXTOPWINDOW_STUBS(FXToolBarShell)
+
+/* Start stub declarations for class FXRbToolBarTab */
+DECLARE_FXOBJECT_STUBS(FXToolBarTab)
+DECLARE_FXID_STUBS(FXToolBarTab)
+DECLARE_FXDRAWABLE_STUBS(FXToolBarTab)
+DECLARE_FXWINDOW_STUBS(FXToolBarTab)
+
+/* Start stub declarations for class FXRbToolTip */
+DECLARE_FXOBJECT_STUBS(FXToolTip)
+DECLARE_FXID_STUBS(FXToolTip)
+DECLARE_FXDRAWABLE_STUBS(FXToolTip)
+DECLARE_FXWINDOW_STUBS(FXToolTip)
+
+/* Start stub declarations for class FXRbTopWindow */
+DECLARE_FXOBJECT_STUBS(FXTopWindow)
+DECLARE_FXID_STUBS(FXTopWindow)
+DECLARE_FXDRAWABLE_STUBS(FXTopWindow)
+DECLARE_FXWINDOW_STUBS(FXTopWindow)
+DECLARE_FXTOPWINDOW_STUBS(FXTopWindow)
+
+/* Start stub declarations for class FXRbTranslator */
+DECLARE_FXOBJECT_STUBS(FXTranslator)
+DECLARE_FXTRANSLATOR_STUBS(FXTranslator)
+
+/* Start stub declarations for class FXRbTreeItem */
+DECLARE_FXOBJECT_STUBS(FXTreeItem)
+DECLARE_FXTREEITEM_STUBS(FXTreeItem,FXRbTreeItem)
+
+/* Start stub declarations for class FXRbTreeList */
+DECLARE_FXOBJECT_STUBS(FXTreeList)
+DECLARE_FXID_STUBS(FXTreeList)
+DECLARE_FXDRAWABLE_STUBS(FXTreeList)
+DECLARE_FXWINDOW_STUBS(FXTreeList)
+DECLARE_FXSCROLLAREA_STUBS(FXTreeList)
+DECLARE_FXTREELIST_STUBS(FXTreeList)
+
+/* Start stub declarations for class FXRbTreeListBox */
+DECLARE_FXOBJECT_STUBS(FXTreeListBox)
+DECLARE_FXID_STUBS(FXTreeListBox)
+DECLARE_FXDRAWABLE_STUBS(FXTreeListBox)
+DECLARE_FXWINDOW_STUBS(FXTreeListBox)
+DECLARE_FXTREELISTBOX_STUBS(FXTreeListBox)
+
+/* Start stub declarations for class FXRbTriStateButton */
+DECLARE_FXOBJECT_STUBS(FXTriStateButton)
+DECLARE_FXID_STUBS(FXTriStateButton)
+DECLARE_FXDRAWABLE_STUBS(FXTriStateButton)
+DECLARE_FXWINDOW_STUBS(FXTriStateButton)
+
+/* Start stub declarations for class FXRbVerticalFrame */
+DECLARE_FXOBJECT_STUBS(FXVerticalFrame)
+DECLARE_FXID_STUBS(FXVerticalFrame)
+DECLARE_FXDRAWABLE_STUBS(FXVerticalFrame)
+DECLARE_FXWINDOW_STUBS(FXVerticalFrame)
+
+/* Start stub declarations for class FXRbVisual */
+DECLARE_FXOBJECT_STUBS(FXVisual)
+DECLARE_FXID_STUBS(FXVisual)
+
+/* Start stub declarations for class FXRbWindow */
+DECLARE_FXOBJECT_STUBS(FXWindow)
+DECLARE_FXID_STUBS(FXWindow)
+DECLARE_FXDRAWABLE_STUBS(FXWindow)
+DECLARE_FXWINDOW_STUBS(FXWindow)
+
+/* Start stub declarations for class FXRbWizard */
+DECLARE_FXOBJECT_STUBS(FXWizard)
+DECLARE_FXID_STUBS(FXWizard)
+DECLARE_FXDRAWABLE_STUBS(FXWizard)
+DECLARE_FXWINDOW_STUBS(FXWizard)
+DECLARE_FXTOPWINDOW_STUBS(FXWizard)
+DECLARE_FXDIALOGBOX_STUBS(FXWizard)
+
+/* Start stub declarations for class FXRbXBMIcon */
+DECLARE_FXOBJECT_STUBS(FXXBMIcon)
+DECLARE_FXID_STUBS(FXXBMIcon)
+DECLARE_FXDRAWABLE_STUBS(FXXBMIcon)
+DECLARE_FXIMAGE_STUBS(FXXBMIcon)
+
+/* Start stub declarations for class FXRbXBMImage */
+DECLARE_FXOBJECT_STUBS(FXXBMImage)
+DECLARE_FXID_STUBS(FXXBMImage)
+DECLARE_FXDRAWABLE_STUBS(FXXBMImage)
+DECLARE_FXIMAGE_STUBS(FXXBMImage)
+
+/* Start stub declarations for class FXRbXPMIcon */
+DECLARE_FXOBJECT_STUBS(FXXPMIcon)
+DECLARE_FXID_STUBS(FXXPMIcon)
+DECLARE_FXDRAWABLE_STUBS(FXXPMIcon)
+DECLARE_FXIMAGE_STUBS(FXXPMIcon)
+
+/* Start stub declarations for class FXRbXPMImage */
+DECLARE_FXOBJECT_STUBS(FXXPMImage)
+DECLARE_FXID_STUBS(FXXPMImage)
+DECLARE_FXDRAWABLE_STUBS(FXXPMImage)
+DECLARE_FXIMAGE_STUBS(FXXPMImage)
+
diff --git a/ext/fox16_c/label_wrap.cpp b/ext/fox16_c/label_wrap.cpp
new file mode 100644
index 00000000..fb42c93b
--- /dev/null
+++ b/ext/fox16_c/label_wrap.cpp
@@ -0,0 +1,22792 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 3.0.12
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+
+#ifndef SWIGRUBY
+#define SWIGRUBY
+#endif
+
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
+};
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic C API SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "4"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/*  Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN           0x1
+
+
+/*
+   Flags/methods for returning states.
+
+   The SWIG conversion methods, as ConvertPtr, return an integer
+   that tells if the conversion was successful or not. And if not,
+   an error code can be returned (see swigerrors.swg for the codes).
+
+   Use the following macros/flags to set or process the returning
+   states.
+
+   In old versions of SWIG, code such as the following was usually written:
+
+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+       // success code
+     } else {
+       //fail code
+     }
+
+   Now you can be more explicit:
+
+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+    } else {
+      // fail code
+    }
+
+   which is the same really, but now you can also do
+
+    Type *ptr;
+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+      if (SWIG_IsNewObj(res) {
+        ...
+	delete *ptr;
+      } else {
+        ...
+      }
+    } else {
+      // fail code
+    }
+
+   I.e., now SWIG_ConvertPtr can return new objects and you can
+   identify the case and take care of the deallocation. Of course that
+   also requires SWIG_ConvertPtr to return new result values, such as
+
+      int SWIG_ConvertPtr(obj, ptr,...) {
+        if (<obj is ok>) {
+          if (<need new object>) {
+            *ptr = <ptr to new allocated object>;
+            return SWIG_NEWOBJ;
+          } else {
+            *ptr = <ptr to old object>;
+            return SWIG_OLDOBJ;
+          }
+        } else {
+          return SWIG_BADOBJ;
+        }
+      }
+
+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+   SWIG errors code.
+
+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+   allows to return the 'cast rank', for example, if you have this
+
+       int food(double)
+       int fooi(int);
+
+   and you call
+
+      food(1)   // cast rank '1'  (1 -> 1.0)
+      fooi(1)   // cast rank '0'
+
+   just use the SWIG_AddCast()/SWIG_CheckState()
+*/
+
+#define SWIG_OK                    (0)
+#define SWIG_ERROR                 (-1)
+#define SWIG_IsOK(r)               (r >= 0)
+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT         (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ                (SWIG_ERROR)
+#define SWIG_OLDOBJ                (SWIG_OK)
+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+#  ifndef SWIG_TypeRank
+#    define SWIG_TypeRank             unsigned long
+#  endif
+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
+#    define SWIG_MAXCASTRANK          (2)
+#  endif
+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+#  define SWIG_AddCast(r) (r)
+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *, int *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store information on one type */
+typedef struct swig_type_info {
+  const char             *name;			/* mangled name of this type */
+  const char             *str;			/* human readable name of this type */
+  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
+  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
+  void                   *clientdata;		/* language specific type data */
+  int                    owndata;		/* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
+  swig_converter_func     converter;		/* function to cast the void pointers */
+  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
+  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
+  size_t                 size;		        /* Number of types in this module */
+  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
+  swig_type_info         **type_initial;	/* Array of initially generated type structures */
+  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
+  void                    *clientdata;		/* Language specific module data */
+} swig_module_info;
+
+/*
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+  }
+  return (int)((l1 - f1) - (l2 - f2));
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCmp(const char *nb, const char *tb) {
+  int equiv = 1;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (equiv != 0 && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
+}
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
+}
+
+/*
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+  swig_type_info *lastty = ty;
+  if (!ty || !ty->dcast) return ty;
+  while (ty && (ty->dcast)) {
+    ty = (*ty->dcast)(ptr);
+    if (ty) lastty = ty;
+  }
+  return lastty;
+}
+
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+  return ty->name;
+}
+
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (!type) return NULL;
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
+  }
+  else
+    return type->name;
+}
+
+/*
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+  swig_cast_info *cast = ti->cast;
+  /* if (ti->clientdata == clientdata) return; */
+  ti->clientdata = clientdata;
+
+  while (cast) {
+    if (!cast->converter) {
+      swig_type_info *tc = cast->type;
+      if (!tc->clientdata) {
+	SWIG_TypeClientData(tc, clientdata);
+      }
+    }
+    cast = cast->next;
+  }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientData(ti, clientdata);
+  ti->owndata = 1;
+}
+
+/*
+  Search for a swig_type_info structure only by mangled name
+  Search is a O(log #types)
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+                            swig_module_info *end,
+		            const char *name) {
+  swig_module_info *iter = start;
+  do {
+    if (iter->size) {
+      size_t l = 0;
+      size_t r = iter->size - 1;
+      do {
+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
+	size_t i = (l + r) >> 1;
+	const char *iname = iter->types[i]->name;
+	if (iname) {
+	  int compare = strcmp(name, iname);
+	  if (compare == 0) {
+	    return iter->types[i];
+	  } else if (compare < 0) {
+	    if (i) {
+	      r = i - 1;
+	    } else {
+	      break;
+	    }
+	  } else if (compare > 0) {
+	    l = i + 1;
+	  }
+	} else {
+	  break; /* should never happen */
+	}
+      } while (l <= r);
+    }
+    iter = iter->next;
+  } while (iter != end);
+  return 0;
+}
+
+/*
+  Search for a swig_type_info structure for either a mangled name or a human readable name.
+  It first searches the mangled names of the types, which is a O(log #types)
+  If a type is not found it then searches the human readable names, which is O(#types).
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+                     swig_module_info *end,
+		     const char *name) {
+  /* STEP 1: Search the name field using binary search */
+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+  if (ret) {
+    return ret;
+  } else {
+    /* STEP 2: If the type hasn't been found, do a complete search
+       of the str field (the human readable name) */
+    swig_module_info *iter = start;
+    do {
+      size_t i = 0;
+      for (; i < iter->size; ++i) {
+	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+	  return iter->types[i];
+      }
+      iter = iter->next;
+    } while (iter != end);
+  }
+
+  /* neither found a match */
+  return 0;
+}
+
+/*
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+
+/*
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = (unsigned char)((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = (unsigned char)((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (unsigned char)(d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (unsigned char)(d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/*
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/*  Errors in SWIG */
+#define  SWIG_UnknownError    	   -1
+#define  SWIG_IOError        	   -2
+#define  SWIG_RuntimeError   	   -3
+#define  SWIG_IndexError     	   -4
+#define  SWIG_TypeError      	   -5
+#define  SWIG_DivisionByZero 	   -6
+#define  SWIG_OverflowError  	   -7
+#define  SWIG_SyntaxError    	   -8
+#define  SWIG_ValueError     	   -9
+#define  SWIG_SystemError    	   -10
+#define  SWIG_AttributeError 	   -11
+#define  SWIG_MemoryError    	   -12
+#define  SWIG_NullReferenceError   -13
+
+
+
+      #include <ruby.h>
+
+      #if defined(RB_METHOD_DEFINITION_DECL)
+      # define RUBY_VALUE_METHOD_FUNC(func) (func)
+      # define RUBY_INT_METHOD_FUNC(func) (func)
+      # define RUBY_VOID_METHOD_FUNC(func) (func)
+      # define RUBY_VOIDP_METHOD_FUNC(func) (func)
+      #else
+      # define RUBY_VALUE_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
+      # define RUBY_INT_METHOD_FUNC(func) ((int (*)(ANYARGS))(func))
+      # define RUBY_VOID_METHOD_FUNC(func) ((void (*)(ANYARGS))(func))
+      # define RUBY_VOIDP_METHOD_FUNC(func) ((void *(*)(ANYARGS))(func))
+      #endif
+
+
+/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
+ * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
+ * issue for now by disabling this.
+ * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
+ */
+#ifdef rb_intern
+# undef rb_intern
+#endif
+
+/* Remove global macros defined in Ruby's win32.h */
+#ifdef write
+# undef write
+#endif
+#ifdef read
+# undef read
+#endif
+#ifdef bind
+# undef bind
+#endif
+#ifdef close
+# undef close
+#endif
+#ifdef connect
+# undef connect
+#endif
+
+
+/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
+#ifndef NUM2LL
+#define NUM2LL(x) NUM2LONG((x))
+#endif
+#ifndef LL2NUM
+#define LL2NUM(x) INT2NUM((long) (x))
+#endif
+#ifndef ULL2NUM
+#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
+#endif
+
+/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
+#ifndef NUM2ULL
+#ifdef HAVE_LONG_LONG
+#define NUM2ULL(x) rb_num2ull((x))
+#else
+#define NUM2ULL(x) NUM2ULONG(x)
+#endif
+#endif
+
+/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
+/* Define these for older versions so we can just write code the new way */
+#ifndef RSTRING_LEN
+# define RSTRING_LEN(x) RSTRING(x)->len
+#endif
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(x) RSTRING(x)->ptr
+#endif
+#ifndef RSTRING_END
+# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
+#endif
+#ifndef RARRAY_LEN
+# define RARRAY_LEN(x) RARRAY(x)->len
+#endif
+#ifndef RARRAY_PTR
+# define RARRAY_PTR(x) RARRAY(x)->ptr
+#endif
+#ifndef RFLOAT_VALUE
+# define RFLOAT_VALUE(x) RFLOAT(x)->value
+#endif
+#ifndef DOUBLE2NUM
+# define DOUBLE2NUM(x) rb_float_new(x)
+#endif
+#ifndef RHASH_TBL
+# define RHASH_TBL(x) (RHASH(x)->tbl)
+#endif
+#ifndef RHASH_ITER_LEV
+# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
+#endif
+#ifndef RHASH_IFNONE
+# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
+#endif
+#ifndef RHASH_SIZE
+# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
+#endif
+#ifndef RHASH_EMPTY_P
+# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
+#endif
+#ifndef RSTRUCT_LEN
+# define RSTRUCT_LEN(x) RSTRUCT(x)->len
+#endif
+#ifndef RSTRUCT_PTR
+# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
+#endif
+
+
+
+/*
+ * Need to be very careful about how these macros are defined, especially
+ * when compiling C++ code or C code with an ANSI C compiler.
+ *
+ * VALUEFUNC(f) is a macro used to typecast a C function that implements
+ * a Ruby method so that it can be passed as an argument to API functions
+ * like rb_define_method() and rb_define_singleton_method().
+ *
+ * VOIDFUNC(f) is a macro used to typecast a C function that implements
+ * either the "mark" or "free" stuff for a Ruby Data object, so that it
+ * can be passed as an argument to API functions like Data_Wrap_Struct()
+ * and Data_Make_Struct().
+ */
+ 
+#ifdef __cplusplus
+#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
+#    define PROTECTFUNC(f) ((VALUE (*)()) f)
+#    define VALUEFUNC(f) ((VALUE (*)()) f)
+#    define VOIDFUNC(f)  ((void (*)()) f)
+#  else
+#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
+#      define PROTECTFUNC(f) ((VALUE (*)()) f)
+#      define VALUEFUNC(f) ((VALUE (*)()) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    else /* These definitions should work for Ruby 1.7+ */
+#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
+#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    endif
+#  endif
+#else
+#  define VALUEFUNC(f) (f)
+#  define VOIDFUNC(f) (f)
+#endif
+
+/* Don't use for expressions have side effect */
+#ifndef RB_STRING_VALUE
+#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
+#endif
+#ifndef StringValue
+#define StringValue(s) RB_STRING_VALUE(s)
+#endif
+#ifndef StringValuePtr
+#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
+#endif
+#ifndef StringValueLen
+#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
+#endif
+#ifndef SafeStringValue
+#define SafeStringValue(v) do {\
+    StringValue(v);\
+    rb_check_safe_str(v);\
+} while (0)
+#endif
+
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
+#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
+#endif
+
+static VALUE _mSWIG = Qnil;
+
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+
+/* Define some additional error types */
+#define SWIG_ObjectPreviouslyDeletedError  -100
+
+
+/* Define custom exceptions for errors that do not map to existing Ruby
+   exceptions.  Note this only works for C++ since a global cannot be
+   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/
+
+SWIGINTERN VALUE 
+getNullReferenceError(void) {
+  static int init = 0;
+  static VALUE rb_eNullReferenceError ;
+  if (!init) {
+    init = 1;
+    rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
+  }
+  return rb_eNullReferenceError;
+} 
+
+SWIGINTERN VALUE 
+getObjectPreviouslyDeletedError(void) {
+  static int init = 0;
+  static VALUE rb_eObjectPreviouslyDeleted ;
+  if (!init) {
+    init = 1;
+    rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
+  }
+  return rb_eObjectPreviouslyDeleted;
+} 
+
+
+SWIGINTERN VALUE
+SWIG_Ruby_ErrorType(int SWIG_code) {
+  VALUE type;
+  switch (SWIG_code) {
+  case SWIG_MemoryError:
+    type = rb_eNoMemError;
+    break;
+  case SWIG_IOError:
+    type = rb_eIOError;
+    break;
+  case SWIG_RuntimeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_IndexError:
+    type = rb_eIndexError;
+    break;
+  case SWIG_TypeError:
+    type = rb_eTypeError;
+    break;
+  case SWIG_DivisionByZero:
+    type = rb_eZeroDivError;
+    break;
+  case SWIG_OverflowError:
+    type = rb_eRangeError;
+    break;
+  case SWIG_SyntaxError:
+    type = rb_eSyntaxError;
+    break;
+  case SWIG_ValueError:
+    type = rb_eArgError;
+    break;
+  case SWIG_SystemError:
+    type = rb_eFatal;
+    break;
+  case SWIG_AttributeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_NullReferenceError:
+    type = getNullReferenceError();
+    break;
+  case SWIG_ObjectPreviouslyDeletedError:
+    type = getObjectPreviouslyDeletedError();
+    break;
+  case SWIG_UnknownError:
+    type = rb_eRuntimeError;
+    break;
+  default:
+    type = rb_eRuntimeError;
+  }
+  return type;
+}
+
+
+/* This function is called when a user inputs a wrong argument to
+   a method.
+ */
+SWIGINTERN 
+const char* Ruby_Format_TypeError( const char* msg,
+				   const char* type, 
+				   const char* name, 
+				   const int argn,
+				   VALUE input )
+{
+  char buf[128];
+  VALUE str;
+  VALUE asStr;
+  if ( msg && *msg )
+    {
+      str = rb_str_new2(msg);
+    }
+  else
+    {
+      str = rb_str_new(NULL, 0);
+    }
+
+  str = rb_str_cat2( str, "Expected argument " );
+  sprintf( buf, "%d of type ", argn-1 );
+  str = rb_str_cat2( str, buf );
+  str = rb_str_cat2( str, type );
+  str = rb_str_cat2( str, ", but got " );
+  str = rb_str_cat2( str, rb_obj_classname(input) );
+  str = rb_str_cat2( str, " " );
+  asStr = rb_inspect(input);
+  if ( RSTRING_LEN(asStr) > 30 )
+    {
+      str = rb_str_cat( str, StringValuePtr(asStr), 30 );
+      str = rb_str_cat2( str, "..." );
+    }
+  else
+    {
+      str = rb_str_append( str, asStr );
+    }
+
+  if ( name )
+    {
+      str = rb_str_cat2( str, "\n\tin SWIG method '" );
+      str = rb_str_cat2( str, name );
+      str = rb_str_cat2( str, "'" );
+    }
+
+  return StringValuePtr( str );
+}
+
+/* This function is called when an overloaded method fails */
+SWIGINTERN 
+void Ruby_Format_OverloadedError(
+				 const int argc,
+				 const int maxargs,
+				 const char* method, 
+				 const char* prototypes 
+				 )
+{
+  const char* msg = "Wrong # of arguments";
+  if ( argc <= maxargs ) msg = "Wrong arguments";
+  rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
+	   "Possible C/C++ prototypes are:\n%s",
+	   msg, method, prototypes);
+}
+
+/* -----------------------------------------------------------------------------
+ * rubytracking.swg
+ *
+ * This file contains support for tracking mappings from 
+ * Ruby objects to C++ objects.  This functionality is needed
+ * to implement mark functions for Ruby's mark and sweep
+ * garbage collector.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(ST_DATA_T_DEFINED)
+/* Needs to be explicitly included for Ruby 1.8 and earlier */
+#include <st.h>
+#endif
+
+/* Ruby 1.8 actually assumes the first case. */
+#if SIZEOF_VOIDP == SIZEOF_LONG
+#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
+#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
+#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
+#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
+#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
+#else
+#  error sizeof(void*) is not the same as long or long long
+#endif
+
+/* Global hash table to store Trackings from C/C++
+   structs to Ruby Objects. 
+*/
+static st_table* swig_ruby_trackings = NULL;
+
+static VALUE swig_ruby_trackings_count(ID id, VALUE *var) {
+  return SWIG2NUM(swig_ruby_trackings->num_entries);
+}
+
+
+/* Setup a hash table to store Trackings */
+SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
+  /* Create a hash table to store Trackings from C++
+     objects to Ruby objects. */
+
+  /* Try to see if some other .so has already created a 
+     tracking hash table, which we keep hidden in an instance var
+     in the SWIG module.
+     This is done to allow multiple DSOs to share the same
+     tracking table.
+  */
+  VALUE trackings_value = Qnil;
+  /* change the variable name so that we can mix modules
+     compiled with older SWIG's - this used to be called "@__trackings__" */
+  ID trackings_id = rb_intern( "@__safetrackings__" );
+  VALUE verbose = rb_gv_get("VERBOSE");
+  rb_gv_set("VERBOSE", Qfalse);
+  trackings_value = rb_ivar_get( _mSWIG, trackings_id );
+  rb_gv_set("VERBOSE", verbose);
+
+  /* The trick here is that we have to store the hash table
+  pointer in a Ruby variable. We do not want Ruby's GC to
+  treat this pointer as a Ruby object, so we convert it to
+  a Ruby numeric value. */
+  if (trackings_value == Qnil) {
+    /* No, it hasn't.  Create one ourselves */
+    swig_ruby_trackings = st_init_numtable();
+    rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
+  } else {
+    swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
+  }
+
+        rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", RUBY_VALUE_METHOD_FUNC(swig_ruby_trackings_count), RUBY_VOID_METHOD_FUNC((rb_gvar_setter_t*)NULL))
+;
+}
+
+/* Add a Tracking from a C/C++ struct to a Ruby object */
+SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
+  /* Store the mapping to the global hash table. */
+  st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
+}
+
+/* Get the Ruby object that owns the specified C/C++ struct */
+SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
+  /* Now lookup the value stored in the global hash table */
+  VALUE value;
+
+  if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
+    return value;
+  } else {
+    return Qnil;
+  }
+}
+
+/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
+   is very important to remove objects once they are destroyed
+   since the same memory address may be reused later to create
+   a new object. */
+SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
+  /* Delete the object from the hash table */
+  st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
+}
+
+/* This is a helper method that unlinks a Ruby object from its
+   underlying C++ object.  This is needed if the lifetime of the
+   Ruby object is longer than the C++ object */
+SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
+  VALUE object = SWIG_RubyInstanceFor(ptr);
+
+  if (object != Qnil) {
+    if (TYPE(object) != T_DATA)
+      abort();
+    DATA_PTR(object) = 0;
+  }
+}
+
+/* This is a helper method that iterates over all the trackings
+   passing the C++ object pointer and its related Ruby object
+   to the passed callback function. */
+
+/* Proxy method to abstract the internal trackings datatype */
+      static int swig_ruby_internal_iterate_callback(st_data_t ptr, st_data_t obj, st_data_t meth) {
+        ((void(*)(void*, VALUE))meth)((void*)ptr, (VALUE)obj);
+
+  return ST_CONTINUE;
+}
+
+SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
+  st_foreach(swig_ruby_trackings, RUBY_INT_METHOD_FUNC(swig_ruby_internal_iterate_callback), (st_data_t)meth);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Ruby API portion that goes into the runtime
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGINTERN VALUE
+SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
+  if (NIL_P(target)) {
+    target = o;
+  } else {
+    if (TYPE(target) != T_ARRAY) {
+      VALUE o2 = target;
+      target = rb_ary_new();
+      rb_ary_push(target, o2);
+    }
+    rb_ary_push(target, o);
+  }
+  return target;
+}
+
+/* For ruby1.8.4 and earlier. */
+#ifndef RUBY_INIT_STACK
+   RUBY_EXTERN void Init_stack(VALUE* addr);
+#  define RUBY_INIT_STACK \
+   VALUE variable_in_this_stack_frame; \
+   Init_stack(&variable_in_this_stack_frame);
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* -----------------------------------------------------------------------------
+ * rubyrun.swg
+ *
+ * This file contains the runtime support for Ruby modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
+#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
+#define swig_owntype                                    swig_ruby_owntype
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) 		SWIG_Ruby_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
+#define SWIG_Error(code, msg)            		rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
+#define SWIG_fail                        		goto fail				 
+
+
+/* Ruby-specific SWIG API */
+
+#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
+#define SWIG_define_class(ty)                        	SWIG_Ruby_define_class(ty)
+#define SWIG_NewClassInstance(value, ty)             	SWIG_Ruby_NewClassInstance(value, ty)
+#define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
+#define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  
+
+#include "assert.h"
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  VALUE klass;
+  VALUE mImpl;
+  void  (*mark)(void *);
+  void  (*destroy)(void *);
+  int trackObjects;
+} swig_class;
+
+
+/* Global pointer used to keep some internal SWIG stuff */
+static VALUE _cSWIG_Pointer = Qnil;
+static VALUE swig_runtime_data_type_pointer = Qnil;
+
+/* Global IDs used to keep some internal SWIG stuff */
+static ID swig_arity_id = 0;
+static ID swig_call_id  = 0;
+
+/*
+  If your swig extension is to be run within an embedded ruby and has
+  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
+  This will reset ruby's stack frame on each entry point from the main 
+  program the first time a virtual director function is invoked (in a 
+  non-recursive way).
+  If this is not done, you run the risk of Ruby trashing the stack.
+*/
+
+#ifdef RUBY_EMBEDDED
+
+#  define SWIG_INIT_STACK                            \
+      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
+      ++swig_virtual_calls;
+#  define SWIG_RELEASE_STACK --swig_virtual_calls;
+#  define Ruby_DirectorTypeMismatchException(x) \
+          rb_raise( rb_eTypeError, "%s", x ); return c_result;
+
+      static unsigned int swig_virtual_calls = 0;
+
+#else  /* normal non-embedded extension */
+
+#  define SWIG_INIT_STACK
+#  define SWIG_RELEASE_STACK
+#  define Ruby_DirectorTypeMismatchException(x) \
+          throw Swig::DirectorTypeMismatchException( x );
+
+#endif  /* RUBY_EMBEDDED */
+
+
+SWIGRUNTIME VALUE 
+getExceptionClass(void) {
+  static int init = 0;
+  static VALUE rubyExceptionClass ;
+  if (!init) {
+    init = 1;
+    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
+  }
+  return rubyExceptionClass;
+} 
+
+/* This code checks to see if the Ruby object being raised as part
+   of an exception inherits from the Ruby class Exception.  If so,
+   the object is simply returned.  If not, then a new Ruby exception
+   object is created and that will be returned to Ruby.*/
+SWIGRUNTIME VALUE
+SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
+  VALUE exceptionClass = getExceptionClass();
+  if (rb_obj_is_kind_of(obj, exceptionClass)) {
+    return obj;
+  }  else {
+    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
+  }
+}
+
+/* Initialize Ruby runtime support */
+SWIGRUNTIME void
+SWIG_Ruby_InitRuntime(void)
+{
+  if (_mSWIG == Qnil) {
+    _mSWIG = rb_define_module("SWIG");
+    swig_call_id  = rb_intern("call");
+    swig_arity_id = rb_intern("arity");
+  }
+}
+
+/* Define Ruby class for C type */
+SWIGRUNTIME void
+SWIG_Ruby_define_class(swig_type_info *type)
+{
+  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+  sprintf(klass_name, "TYPE%s", type->name);
+  if (NIL_P(_cSWIG_Pointer)) {
+    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
+    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
+  }
+  rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
+  free((void *) klass_name);
+}
+
+/* Create a new pointer object */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
+{
+  int own =  flags & SWIG_POINTER_OWN; 
+  int track;
+  char *klass_name;
+  swig_class *sklass;
+  VALUE klass;
+  VALUE obj;
+  
+  if (!ptr)
+    return Qnil;
+  
+  if (type->clientdata) {
+    sklass = (swig_class *) type->clientdata;
+		
+    /* Are we tracking this class and have we already returned this Ruby object? */
+    track = sklass->trackObjects;
+    if (track) {
+      obj = SWIG_RubyInstanceFor(ptr);
+      
+      /* Check the object's type and make sure it has the correct type.
+        It might not in cases where methods do things like 
+        downcast methods. */
+      if (obj != Qnil) {
+        VALUE value = rb_iv_get(obj, "@__swigtype__");
+        const char* type_name = RSTRING_PTR(value);
+				
+        if (strcmp(type->name, type_name) == 0) {
+          return obj;
+        }
+      }
+    }
+
+    /* Create a new Ruby object */
+    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
+			   ( own ? VOIDFUNC(sklass->destroy) : 
+			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
+			     ), ptr);
+
+    /* If tracking is on for this class then track this object. */
+    if (track) {
+      SWIG_RubyAddTracking(ptr, obj);
+    }
+  } else {
+    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+    sprintf(klass_name, "TYPE%s", type->name);
+    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
+    free((void *) klass_name);
+    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
+  }
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  
+  return obj;
+}
+
+/* Create a new class instance (always owned) */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
+{
+  VALUE obj;
+  swig_class *sklass = (swig_class *) type->clientdata;
+  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  return obj;
+}
+
+/* Get type mangle from class name */
+SWIGRUNTIMEINLINE char *
+SWIG_Ruby_MangleStr(VALUE obj)
+{
+  VALUE stype = rb_iv_get(obj, "@__swigtype__");
+  return StringValuePtr(stype);
+}
+
+/* Acquire a pointer value */
+typedef struct {
+  void (*datafree)(void *);
+  int own;
+} swig_ruby_owntype;
+
+SWIGRUNTIME swig_ruby_owntype
+SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
+  swig_ruby_owntype oldown = {0, 0};
+  if (obj) {
+    oldown.datafree = RDATA(obj)->dfree;
+    RDATA(obj)->dfree = own.datafree;
+  }
+  return oldown;
+}
+
+/* Convert a pointer value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
+{
+  char *c;
+  swig_cast_info *tc;
+  void *vptr = 0;
+
+  /* Grab the pointer */
+  if (NIL_P(obj)) {
+    if (ptr)
+      *ptr = 0;
+    return SWIG_OK;
+  } else {
+    if (TYPE(obj) != T_DATA) {
+      return SWIG_ERROR;
+    }
+    Data_Get_Struct(obj, void, vptr);
+  }
+  
+  if (own) {
+    own->datafree = RDATA(obj)->dfree;
+    own->own = 0;
+  }
+    
+  /* Check to see if the input object is giving up ownership
+     of the underlying C struct or C++ object.  If so then we
+     need to reset the destructor since the Ruby object no 
+     longer owns the underlying C++ object.*/ 
+  if (flags & SWIG_POINTER_DISOWN) {
+    /* Is tracking on for this class? */
+    int track = 0;
+    if (ty && ty->clientdata) {
+      swig_class *sklass = (swig_class *) ty->clientdata;
+      track = sklass->trackObjects;
+    }
+		
+    if (track) {
+      /* We are tracking objects for this class.  Thus we change the destructor
+       * to SWIG_RubyRemoveTracking.  This allows us to
+       * remove the mapping from the C++ to Ruby object
+       * when the Ruby object is garbage collected.  If we don't
+       * do this, then it is possible we will return a reference 
+       * to a Ruby object that no longer exists thereby crashing Ruby. */
+      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
+    } else {    
+      RDATA(obj)->dfree = 0;
+    }
+  }
+
+  /* Do type-checking if type info was provided */
+  if (ty) {
+    if (ty->clientdata) {
+      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
+        if (vptr == 0) {
+          /* The object has already been deleted */
+          return SWIG_ObjectPreviouslyDeletedError;
+        }
+      }
+    }
+    if ((c = SWIG_MangleStr(obj)) == NULL) {
+      return SWIG_ERROR;
+    }
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) {
+      return SWIG_ERROR;
+    } else {
+      if (ptr) {
+        if (tc->type == ty) {
+          *ptr = vptr;
+        } else {
+          int newmemory = 0;
+          *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
+          if (newmemory == SWIG_CAST_NEW_MEMORY) {
+            assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+            if (own)
+              own->own = own->own | SWIG_CAST_NEW_MEMORY;
+          }
+        }
+      }
+    }
+  } else {
+    if (ptr)
+      *ptr = vptr;
+  }
+  
+  return SWIG_OK;
+}
+
+/* Check convert */
+SWIGRUNTIMEINLINE int
+SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
+{
+  char *c = SWIG_MangleStr(obj);
+  if (!c) return 0;
+  return SWIG_TypeCheck(c,ty) != 0;
+}
+
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r, ptr, sz);
+  strcpy(r, type->name);
+  return rb_str_new2(result);
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c;
+
+  if (TYPE(obj) != T_STRING) goto type_error;
+  c = StringValuePtr(obj);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') goto type_error;
+  c++;
+  c = SWIG_UnpackData(c, ptr, sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) goto type_error;
+  }
+  return SWIG_OK;
+
+ type_error:
+  return SWIG_ERROR;
+}
+
+SWIGRUNTIME swig_module_info *
+SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
+{
+  VALUE pointer;
+  swig_module_info *ret = 0;
+  VALUE verbose = rb_gv_get("VERBOSE");
+
+ /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
+  rb_gv_set("VERBOSE", Qfalse);
+  
+  /* first check if pointer already created */
+  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  if (pointer != Qnil) {
+    Data_Get_Struct(pointer, swig_module_info, ret);
+  }
+
+  /* reinstate warnings */
+  rb_gv_set("VERBOSE", verbose);
+  return ret;
+}
+
+SWIGRUNTIME void 
+SWIG_Ruby_SetModule(swig_module_info *pointer)
+{
+  /* register a new class */
+  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
+  /* create and store the structure pointer to a global variable */
+  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
+  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
+}
+
+/* This function can be used to check whether a proc or method or similarly
+   callable function has been passed.  Usually used in a %typecheck, like:
+
+   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
+        $result = SWIG_Ruby_isCallable( $input );
+   }
+ */
+SWIGINTERN
+int SWIG_Ruby_isCallable( VALUE proc )
+{
+  if ( rb_respond_to( proc, swig_call_id ) )
+    return 1;
+  return 0;
+}
+
+/* This function can be used to check the arity (number of arguments)
+   a proc or method can take.  Usually used in a %typecheck.
+   Valid arities will be that equal to minimal or those < 0
+   which indicate a variable number of parameters at the end.
+ */
+SWIGINTERN
+int SWIG_Ruby_arity( VALUE proc, int minimal )
+{
+  if ( rb_respond_to( proc, swig_arity_id ) )
+    {
+      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
+      int arity = NUM2INT(num);
+      if ( arity < 0 && (arity+1) < -minimal ) return 1;
+      if ( arity == minimal ) return 1;
+      return 1;
+    }
+  return 0;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
+
+
+
+  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) 
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_p_FXAccelTable swig_types[0]
+#define SWIGTYPE_p_FXApp swig_types[1]
+#define SWIGTYPE_p_FXArrowButton swig_types[2]
+#define SWIGTYPE_p_FXBitmap swig_types[3]
+#define SWIGTYPE_p_FXBitmapFrame swig_types[4]
+#define SWIGTYPE_p_FXButton swig_types[5]
+#define SWIGTYPE_p_FXCURCursor swig_types[6]
+#define SWIGTYPE_p_FXCheckButton swig_types[7]
+#define SWIGTYPE_p_FXColorBar swig_types[8]
+#define SWIGTYPE_p_FXColorRing swig_types[9]
+#define SWIGTYPE_p_FXColorWell swig_types[10]
+#define SWIGTYPE_p_FXColorWheel swig_types[11]
+#define SWIGTYPE_p_FXComposite swig_types[12]
+#define SWIGTYPE_p_FXCursor swig_types[13]
+#define SWIGTYPE_p_FXDataTarget swig_types[14]
+#define SWIGTYPE_p_FXDebugTarget swig_types[15]
+#define SWIGTYPE_p_FXDelegator swig_types[16]
+#define SWIGTYPE_p_FXDial swig_types[17]
+#define SWIGTYPE_p_FXDict swig_types[18]
+#define SWIGTYPE_p_FXDocument swig_types[19]
+#define SWIGTYPE_p_FXDrawable swig_types[20]
+#define SWIGTYPE_p_FXFileDict swig_types[21]
+#define SWIGTYPE_p_FXFileStream swig_types[22]
+#define SWIGTYPE_p_FXFont swig_types[23]
+#define SWIGTYPE_p_FXFrame swig_types[24]
+#define SWIGTYPE_p_FXGIFCursor swig_types[25]
+#define SWIGTYPE_p_FXGradientBar swig_types[26]
+#define SWIGTYPE_p_FXHeader swig_types[27]
+#define SWIGTYPE_p_FXHeaderItem swig_types[28]
+#define SWIGTYPE_p_FXHorizontalSeparator swig_types[29]
+#define SWIGTYPE_p_FXIcon swig_types[30]
+#define SWIGTYPE_p_FXIconDict swig_types[31]
+#define SWIGTYPE_p_FXId swig_types[32]
+#define SWIGTYPE_p_FXImageFrame swig_types[33]
+#define SWIGTYPE_p_FXKnob swig_types[34]
+#define SWIGTYPE_p_FXLabel swig_types[35]
+#define SWIGTYPE_p_FXMainWindow swig_types[36]
+#define SWIGTYPE_p_FXMemoryStream swig_types[37]
+#define SWIGTYPE_p_FXMenuButton swig_types[38]
+#define SWIGTYPE_p_FXObject swig_types[39]
+#define SWIGTYPE_p_FXOption swig_types[40]
+#define SWIGTYPE_p_FXOptionMenu swig_types[41]
+#define SWIGTYPE_p_FXPicker swig_types[42]
+#define SWIGTYPE_p_FXPopup swig_types[43]
+#define SWIGTYPE_p_FXProgressBar swig_types[44]
+#define SWIGTYPE_p_FXRadioButton swig_types[45]
+#define SWIGTYPE_p_FXRealSlider swig_types[46]
+#define SWIGTYPE_p_FXRecentFiles swig_types[47]
+#define SWIGTYPE_p_FXRegion swig_types[48]
+#define SWIGTYPE_p_FXRegistry swig_types[49]
+#define SWIGTYPE_p_FXRootWindow swig_types[50]
+#define SWIGTYPE_p_FXRuler swig_types[51]
+#define SWIGTYPE_p_FXSeparator swig_types[52]
+#define SWIGTYPE_p_FXSettings swig_types[53]
+#define SWIGTYPE_p_FXShell swig_types[54]
+#define SWIGTYPE_p_FXSlider swig_types[55]
+#define SWIGTYPE_p_FXSplashWindow swig_types[56]
+#define SWIGTYPE_p_FXStatusLine swig_types[57]
+#define SWIGTYPE_p_FXStream swig_types[58]
+#define SWIGTYPE_p_FXStringDict swig_types[59]
+#define SWIGTYPE_p_FXTabBar swig_types[60]
+#define SWIGTYPE_p_FXTabItem swig_types[61]
+#define SWIGTYPE_p_FXTextField swig_types[62]
+#define SWIGTYPE_p_FXToggleButton swig_types[63]
+#define SWIGTYPE_p_FXToolBarTab swig_types[64]
+#define SWIGTYPE_p_FXTopWindow swig_types[65]
+#define SWIGTYPE_p_FXTranslator swig_types[66]
+#define SWIGTYPE_p_FXTriStateButton swig_types[67]
+#define SWIGTYPE_p_FXVerticalSeparator swig_types[68]
+#define SWIGTYPE_p_FXVisual swig_types[69]
+#define SWIGTYPE_p_FXWindow swig_types[70]
+#define SWIGTYPE_p_char swig_types[71]
+#define SWIGTYPE_p_double swig_types[72]
+#define SWIGTYPE_p_float swig_types[73]
+#define SWIGTYPE_p_int swig_types[74]
+#define SWIGTYPE_p_long swig_types[75]
+#define SWIGTYPE_p_short swig_types[76]
+#define SWIGTYPE_p_unsigned_char swig_types[77]
+#define SWIGTYPE_p_unsigned_int swig_types[78]
+#define SWIGTYPE_p_unsigned_long swig_types[79]
+#define SWIGTYPE_p_unsigned_short swig_types[80]
+static swig_type_info *swig_types[82];
+static swig_module_info swig_module = {swig_types, 81, 0, 0, 0, 0};
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
+
+/* -------- TYPES TABLE (END) -------- */
+
+#define SWIG_init    Init_label
+#define SWIG_name    "Label"
+
+
+
+#define SWIG_RUBY_THREAD_BEGIN_BLOCK
+#define SWIG_RUBY_THREAD_END_BLOCK
+
+
+#define SWIGVERSION 0x030012 
+#define SWIG_VERSION SWIGVERSION
+
+
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
+
+
+#include <stdexcept>
+
+
+#include "FXRbCommon.h"
+
+
+inline FXColor to_FXColor(VALUE obj){
+  if(TYPE(obj)==T_STRING){
+    return fxcolorfromname(StringValuePtr(obj));
+    }
+  else if(TYPE(obj)==T_SYMBOL){
+    return fxcolorfromname(rb_id2name(SYM2ID(obj)));
+    }
+  else{
+    return NUM2ULONG(obj);
+    }
+  }
+
+
+inline FXString to_FXString(VALUE obj){
+  if(!NIL_P(obj)){
+    Check_Type(obj,T_STRING);
+    return FXString(StringValuePtr(obj));
+    }
+  else{
+    return FXString::null;
+    }
+  }
+
+
+inline FXbool to_FXbool(VALUE obj){
+  if (obj == Qtrue || obj == Qfalse){
+    return (obj == Qtrue) ? TRUE : FALSE;
+    }
+  else{
+    return static_cast<FXbool>(NUM2UINT(obj));
+    }
+  }
+
+
+static swig_type_info* FXEventTypeInfo=0;
+
+inline void* to_FXEvent(VALUE obj){
+  void* ptr;
+  if(!FXEventTypeInfo){
+    FXEventTypeInfo=SWIG_TypeQuery("FXEvent *");
+    FXASSERT(FXEventTypeInfo!=0);
+    }
+  SWIG_ConvertPtr(obj,&ptr,FXEventTypeInfo,1);
+  return ptr;
+  }
+
+
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
+
+
+  #define SWIG_From_long   LONG2NUM 
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_int  (int value)
+{    
+  return SWIG_From_long  (value);
+}
+
+SWIGINTERN FXLabel *new_FXLabel(FXComposite *p,FXString const &text,FXIcon *ic=0,FXuint opts=LABEL_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbLabel(p,text,ic,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_long  (unsigned long value)
+{
+  return ULONG2NUM(value); 
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_int  (unsigned int value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_bool  (bool value)
+{
+  return value ? Qtrue : Qfalse;
+}
+
+
+SWIGINTERN swig_type_info*
+SWIG_pchar_descriptor(void)
+{
+  static int init = 0;
+  static swig_type_info* info = 0;
+  if (!init) {
+    info = SWIG_TypeQuery("_p_char");
+    init = 1;
+  }
+  return info;
+}
+
+
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
+{
+  if (TYPE(obj) == T_STRING) {
+    char *cstr = StringValuePtr(obj); 
+    size_t size = RSTRING_LEN(obj) + 1;
+    if (cptr)  {
+      if (alloc) {
+	if (*alloc == SWIG_NEWOBJ) {
+	  *cptr = reinterpret_cast< char* >(memcpy(new char[size], cstr, sizeof(char)*(size)));
+	} else {
+	  *cptr = cstr;
+	  *alloc = SWIG_OLDOBJ;
+	}
+      }
+    }
+    if (psize) *psize = size;
+    return SWIG_OK;
+  } else {
+    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+    if (pchar_descriptor) {
+      void* vptr = 0;
+      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
+	if (cptr) *cptr = (char *)vptr;
+	if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
+	if (alloc) *alloc = SWIG_OLDOBJ;
+	return SWIG_OK;
+      }
+    }
+  }  
+  return SWIG_TypeError;
+}
+
+
+
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+  if (carray) {
+    if (size > LONG_MAX) {
+      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+      return pchar_descriptor ? 
+	SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : Qnil;
+    } else {
+      return rb_str_new(carray, static_cast< long >(size));
+    }
+  } else {
+    return Qnil;
+  }
+}
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtr(const char *cptr)
+{ 
+  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
+}
+
+
+static swig_type_info *FXLabel_dynamic_cast(void **ptr) {
+    FXLabel **ppLabel = reinterpret_cast<FXLabel **>(ptr);
+    FXButton *pButton=dynamic_cast<FXButton*>(*ppLabel);
+    if(pButton){
+      *ptr=reinterpret_cast<void*>(pButton);
+      return SWIG_TypeQuery("FXButton *");
+      }
+    FXCheckButton *pCheckButton=dynamic_cast<FXCheckButton*>(*ppLabel);
+    if(pCheckButton){
+      *ptr=reinterpret_cast<void*>(pCheckButton);
+      return SWIG_TypeQuery("FXCheckButton *");
+      }
+    FXMenuButton *pMenuButton=dynamic_cast<FXMenuButton*>(*ppLabel);
+    if(pMenuButton){
+      *ptr=reinterpret_cast<void*>(pMenuButton);
+      return SWIG_TypeQuery("FXMenuButton *");
+      }
+    FXOption *pOption=dynamic_cast<FXOption*>(*ppLabel);
+    if(pOption){
+      *ptr=reinterpret_cast<void*>(pOption);
+      return SWIG_TypeQuery("FXOption *");
+      }
+    FXOptionMenu *pOptionMenu=dynamic_cast<FXOptionMenu*>(*ppLabel);
+    if(pOptionMenu){
+      *ptr=reinterpret_cast<void*>(pOptionMenu);
+      return SWIG_TypeQuery("FXOptionMenu *");
+      }
+    FXRadioButton *pRadioButton=dynamic_cast<FXRadioButton*>(*ppLabel);
+    if(pRadioButton){
+      *ptr=reinterpret_cast<void*>(pRadioButton);
+      return SWIG_TypeQuery("FXRadioButton *");
+      }
+    FXTabItem *pTabItem=dynamic_cast<FXTabItem*>(*ppLabel);
+    if(pTabItem){
+      *ptr=reinterpret_cast<void*>(pTabItem);
+      return SWIG_TypeQuery("FXTabItem *");
+      }
+    FXToggleButton *pToggleButton=dynamic_cast<FXToggleButton*>(*ppLabel);
+    if(pToggleButton){
+      *ptr=reinterpret_cast<void*>(pToggleButton);
+      return SWIG_TypeQuery("FXToggleButton *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXButton *new_FXButton(FXComposite *p,FXString const &text,FXIcon *ic=0,FXObject *tgt=0,FXSelector sel=0,FXuint opts=BUTTON_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbButton(p,text,ic,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+
+static swig_type_info *FXButton_dynamic_cast(void **ptr) {
+    FXButton **ppButton = reinterpret_cast<FXButton **>(ptr);
+    FXMDIDeleteButton *pMDIDeleteButton=dynamic_cast<FXMDIDeleteButton*>(*ppButton);
+    if(pMDIDeleteButton){
+      *ptr=reinterpret_cast<void*>(pMDIDeleteButton);
+      return SWIG_TypeQuery("FXMDIDeleteButton *");
+      }
+    FXMDIMaximizeButton *pMDIMaximizeButton=dynamic_cast<FXMDIMaximizeButton*>(*ppButton);
+    if(pMDIMaximizeButton){
+      *ptr=reinterpret_cast<void*>(pMDIMaximizeButton);
+      return SWIG_TypeQuery("FXMDIMaximizeButton *");
+      }
+    FXMDIMinimizeButton *pMDIMinimizeButton=dynamic_cast<FXMDIMinimizeButton*>(*ppButton);
+    if(pMDIMinimizeButton){
+      *ptr=reinterpret_cast<void*>(pMDIMinimizeButton);
+      return SWIG_TypeQuery("FXMDIMinimizeButton *");
+      }
+    FXMDIRestoreButton *pMDIRestoreButton=dynamic_cast<FXMDIRestoreButton*>(*ppButton);
+    if(pMDIRestoreButton){
+      *ptr=reinterpret_cast<void*>(pMDIRestoreButton);
+      return SWIG_TypeQuery("FXMDIRestoreButton *");
+      }
+    FXPicker *pPicker=dynamic_cast<FXPicker*>(*ppButton);
+    if(pPicker){
+      *ptr=reinterpret_cast<void*>(pPicker);
+      return SWIG_TypeQuery("FXPicker *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXCheckButton *new_FXCheckButton(FXComposite *p,FXString const &text,FXObject *tgt=0,FXSelector sel=0,FXuint opts=CHECKBUTTON_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbCheckButton(p,text,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN FXbool FXCheckButton_getCheck(FXCheckButton const *self){
+      rb_warning("FXCheckButton#getCheck is deprecated; use checked?, unchecked? or maybe?");
+      return self->getCheck();
+      }
+SWIGINTERN FXuchar FXCheckButton_getCheckState(FXCheckButton const *self){ return self->getCheck(); }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_char  (unsigned char value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+SWIGINTERN FXMenuButton *new_FXMenuButton(FXComposite *p,FXString const &text,FXIcon *ic=0,FXPopup *pup=0,FXuint opts=JUSTIFY_NORMAL|ICON_BEFORE_TEXT|MENUBUTTON_DOWN,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbMenuButton(p,text,ic,pup,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+
+static swig_type_info *FXMenuButton_dynamic_cast(void **ptr) {
+    FXMenuButton **ppMenuButton = reinterpret_cast<FXMenuButton **>(ptr);
+    FXMDIWindowButton *pMDIWindowButton=dynamic_cast<FXMDIWindowButton*>(*ppMenuButton);
+    if(pMDIWindowButton){
+      *ptr=reinterpret_cast<void*>(pMDIWindowButton);
+      return SWIG_TypeQuery("FXMDIWindowButton *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXOption *new_FXOption(FXComposite *p,FXString const &text,FXIcon *ic=0,FXObject *tgt=0,FXSelector sel=0,FXuint opts=JUSTIFY_NORMAL|ICON_BEFORE_TEXT,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbOption(p,text,ic,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN FXOptionMenu *new_FXOptionMenu(FXComposite *p,FXPopup *pup=0,FXuint opts=JUSTIFY_NORMAL|ICON_BEFORE_TEXT,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbOptionMenu(p,pup,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN FXRadioButton *new_FXRadioButton(FXComposite *p,FXString const &text,FXObject *tgt=0,FXSelector sel=0,FXuint opts=RADIOBUTTON_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbRadioButton(p,text,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN FXbool FXRadioButton_getCheck(FXRadioButton const *self){
+      rb_warning("FXRadioButton#getCheck is deprecated; use checked?, unchecked? or maybe?");
+      return self->getCheck();
+      }
+SWIGINTERN FXuchar FXRadioButton_getCheckState(FXRadioButton const *self){ return self->getCheck(); }
+SWIGINTERN FXTabItem *new_FXTabItem(FXTabBar *p,FXString const &text,FXIcon *ic=0,FXuint opts=TAB_TOP_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbTabItem(p,text,ic,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN FXToggleButton *new_FXToggleButton(FXComposite *p,FXString const &text1,FXString const &text2,FXIcon *icon1=0,FXIcon *icon2=0,FXObject *tgt=0,FXSelector sel=0,FXuint opts=TOGGLEBUTTON_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbToggleButton(p,text1,text2,icon1,icon2,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+
+static swig_type_info *FXToggleButton_dynamic_cast(void **ptr) {
+    FXToggleButton **ppToggleButton = reinterpret_cast<FXToggleButton **>(ptr);
+    FXTriStateButton *pTriStateButton=dynamic_cast<FXTriStateButton*>(*ppToggleButton);
+    if(pTriStateButton){
+      *ptr=reinterpret_cast<void*>(pTriStateButton);
+      return SWIG_TypeQuery("FXTriStateButton *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXTriStateButton *new_FXTriStateButton(FXComposite *p,FXString const &text1,FXString const &text2,FXString const &text3,FXIcon *icon1=0,FXIcon *icon2=0,FXIcon *icon3=0,FXObject *tgt=0,FXSelector sel=0,FXuint opts=TOGGLEBUTTON_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbTriStateButton(p,text1,text2,text3,icon1,icon2,icon3,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+    }
+SWIGINTERN FXPicker *new_FXPicker(FXComposite *p,FXString const &text,FXIcon *ic=0,FXObject *tgt=0,FXSelector sel=0,FXuint opts=BUTTON_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbPicker(p,text,ic,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+static swig_class SwigClassFXLabel;
+
+SWIGINTERN VALUE
+_wrap_FXLabel_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_onHotKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","onHotKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_onHotKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","onHotKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_onCmdSetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","onCmdSetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_onCmdGetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","onCmdGetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_onCmdSetIconValue(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *tmp4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","onCmdSetIconValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIconValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    tmp4 = FXRbConvertPtr(argv[2], FXRbTypeQuery("FXIcon *"));
+    arg4 = (void *) &tmp4;
+  }
+  result = (long)(arg1)->onCmdSetIconValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_onCmdGetIconValue(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","onCmdGetIconValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIconValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIconValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_onCmdSetHelp(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","onCmdSetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_onCmdGetHelp(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","onCmdGetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_onCmdSetTip(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","onCmdSetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_onCmdGetTip(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","onCmdGetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXLabel_allocate(VALUE self)
+#else
+_wrap_FXLabel_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXLabel);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXLabel(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXuint arg4 = (FXuint) LABEL_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) DEFAULT_PAD ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXLabel *result = 0 ;
+  
+  if ((argc < 2) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXLabel", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","FXLabel", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXLabel *)new_FXLabel(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_setText(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","setText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_getText(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel const *","getText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  result = ((FXLabel const *)arg1)->getText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_setIcon(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","setIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  (arg1)->setIcon(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_getIcon(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel const *","getIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  result = (FXIcon *)((FXLabel const *)arg1)->getIcon();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_setFont(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  (arg1)->setFont(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_getFont(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  result = (FXFont *)((FXLabel const *)arg1)->getFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_getTextColor(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel const *","getTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  result = (FXColor)((FXLabel const *)arg1)->getTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_setTextColor(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","setTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_setJustify(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","setJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setJustify(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_getJustify(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel const *","getJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  result = (FXuint)((FXLabel const *)arg1)->getJustify();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_setIconPosition(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","setIconPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setIconPosition(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_getIconPosition(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel const *","getIconPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  result = (FXuint)((FXLabel const *)arg1)->getIconPosition();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  result = (FXString *) &((FXLabel const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_setTipText(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_getTipText(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  result = (FXString *) &((FXLabel const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_save(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXLabel_save((FXLabel const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_load(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXLabel_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_create(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  FXLabel_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_detach(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  FXLabel_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_destroy(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  FXLabel_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_resize(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXLabel_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  result = (FXint)FXLabel_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  result = (FXint)FXLabel_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXLabel_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXLabel_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  result = (bool)FXLabel_canFocus((FXLabel const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  FXLabel_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  FXLabel_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXLabel_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXLabel_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_enable(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  FXLabel_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_disable(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  FXLabel_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  FXLabel_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_lower(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  FXLabel_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_move(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXLabel_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_position(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXLabel_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_layout(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  FXLabel_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_recalc(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  FXLabel_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_reparent(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXLabel_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_show(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  FXLabel_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_hide(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  FXLabel_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  result = (bool)FXLabel_isComposite((FXLabel const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_contains(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXLabel_contains((FXLabel const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  result = (bool)FXLabel_doesSaveUnder((FXLabel const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXLabel_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_tr(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXLabel_tr((FXLabel const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  FXLabel_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  FXLabel_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXLabel_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXLabel_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXLabel_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXLabel_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXLabel, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXLabel_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXLabel, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXLabel_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXLabel, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXLabel_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXLabel_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXLabel *arg1 = (FXLabel *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXLabel, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXLabel *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXLabel * >(argp1);
+  FXLabel_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXButton;
+
+SWIGINTERN VALUE
+_wrap_FXButton_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_onUpdate(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","onUpdate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdate", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdate(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_onEnter(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","onEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_onLeave(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","onLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_onFocusIn(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","onFocusIn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusIn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusIn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_onFocusOut(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","onFocusOut", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusOut", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusOut(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_onHotKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","onHotKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_onHotKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","onHotKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_onCheck(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","onCheck", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCheck", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCheck(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_onUncheck(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","onUncheck", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUncheck", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUncheck(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXint) NUM2INT(argv[2]);
+    arg4 = static_cast<void*>(&value4);
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXButton_allocate(VALUE self)
+#else
+_wrap_FXButton_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXButton);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXButton(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXObject *arg4 = (FXObject *) 0 ;
+  FXSelector arg5 = (FXSelector) 0 ;
+  FXuint arg6 = (FXuint) BUTTON_NORMAL ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) 0 ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  FXint arg13 = (FXint) DEFAULT_PAD ;
+  FXint arg14 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXButton *result = 0 ;
+  
+  if ((argc < 2) || (argc > 14)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXButton", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","FXButton", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 3) {
+    res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXObject *","FXButton", 4, argv[3] )); 
+    }
+    arg4 = reinterpret_cast< FXObject * >(argp4);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2UINT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  if (argc > 13) {
+    arg14 = NUM2INT(argv[13]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXButton *)new_FXButton(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_setState(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","setState", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setState(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_getState(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton const *","getState", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  result = (FXuint)((FXButton const *)arg1)->getState();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_setButtonStyle(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","setButtonStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setButtonStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_getButtonStyle(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton const *","getButtonStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  result = (FXuint)((FXButton const *)arg1)->getButtonStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_save(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXButton_save((FXButton const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_load(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXButton_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_create(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  FXButton_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_detach(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  FXButton_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_destroy(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  FXButton_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_resize(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXButton_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  result = (FXint)FXButton_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  result = (FXint)FXButton_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXButton_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXButton_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  result = (bool)FXButton_canFocus((FXButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  FXButton_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  FXButton_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXButton_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXButton_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_enable(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  FXButton_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_disable(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  FXButton_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  FXButton_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_lower(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  FXButton_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_move(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXButton_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_position(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXButton_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_layout(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  FXButton_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_recalc(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  FXButton_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_reparent(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXButton_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_show(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  FXButton_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_hide(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  FXButton_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  result = (bool)FXButton_isComposite((FXButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_contains(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXButton_contains((FXButton const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  result = (bool)FXButton_doesSaveUnder((FXButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXButton_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_tr(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXButton_tr((FXButton const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  FXButton_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  FXButton_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXButton_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXButton_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXButton_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXButton_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXButton_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXButton_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXButton_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXButton_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXButton *arg1 = (FXButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXButton *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXButton * >(argp1);
+  FXButton_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXCheckButton;
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_onUpdate(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","onUpdate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdate", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdate(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_onEnter(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","onEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_onLeave(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","onLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_onFocusIn(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","onFocusIn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusIn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusIn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_onFocusOut(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","onFocusOut", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusOut", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusOut(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_onHotKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","onHotKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_onHotKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","onHotKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_onCheck(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","onCheck", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCheck", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCheck(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_onUncheck(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","onUncheck", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUncheck", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUncheck(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_onUnknown(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","onUnknown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUnknown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUnknown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXint) NUM2INT(argv[2]);
+    arg4 = static_cast<void*>(&value4);
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXCheckButton_allocate(VALUE self)
+#else
+_wrap_FXCheckButton_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXCheckButton);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXCheckButton(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXString *arg2 = 0 ;
+  FXObject *arg3 = (FXObject *) 0 ;
+  FXSelector arg4 = (FXSelector) 0 ;
+  FXuint arg5 = (FXuint) CHECKBUTTON_NORMAL ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  FXint arg13 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXCheckButton *result = 0 ;
+  
+  if ((argc < 2) || (argc > 13)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXCheckButton", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXObject *","FXCheckButton", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXObject * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXCheckButton *)new_FXCheckButton(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_setCheck(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","setCheck", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setCheck(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_getCheck(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton const *","getCheck", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  result = (FXbool)FXCheckButton_getCheck((FXCheckButton const *)arg1);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_getCheckState(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuchar result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton const *","getCheckState", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  result = (FXuchar)FXCheckButton_getCheckState((FXCheckButton const *)arg1);
+  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_setCheckButtonStyle(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","setCheckButtonStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setCheckButtonStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_getCheckButtonStyle(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton const *","getCheckButtonStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  result = (FXuint)((FXCheckButton const *)arg1)->getCheckButtonStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_getBoxColor(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton const *","getBoxColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  result = (FXColor)((FXCheckButton const *)arg1)->getBoxColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_setBoxColor(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","setBoxColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setBoxColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_getCheckColor(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton const *","getCheckColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  result = (FXColor)((FXCheckButton const *)arg1)->getCheckColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_setCheckColor(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","setCheckColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setCheckColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_save(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXCheckButton_save((FXCheckButton const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_load(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXCheckButton_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_create(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  FXCheckButton_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_detach(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  FXCheckButton_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_destroy(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  FXCheckButton_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_resize(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXCheckButton_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  result = (FXint)FXCheckButton_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  result = (FXint)FXCheckButton_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXCheckButton_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXCheckButton_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  result = (bool)FXCheckButton_canFocus((FXCheckButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  FXCheckButton_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  FXCheckButton_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXCheckButton_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXCheckButton_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_enable(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  FXCheckButton_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_disable(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  FXCheckButton_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  FXCheckButton_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_lower(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  FXCheckButton_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_move(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXCheckButton_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_position(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXCheckButton_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_layout(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  FXCheckButton_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_recalc(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  FXCheckButton_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_reparent(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXCheckButton_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_show(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  FXCheckButton_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_hide(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  FXCheckButton_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  result = (bool)FXCheckButton_isComposite((FXCheckButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_contains(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXCheckButton_contains((FXCheckButton const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  result = (bool)FXCheckButton_doesSaveUnder((FXCheckButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXCheckButton_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_tr(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXCheckButton_tr((FXCheckButton const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  FXCheckButton_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  FXCheckButton_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXCheckButton_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXCheckButton_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXCheckButton_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXCheckButton_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXCheckButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXCheckButton_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXCheckButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXCheckButton_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXCheckButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXCheckButton_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCheckButton_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXCheckButton *arg1 = (FXCheckButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCheckButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCheckButton *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCheckButton * >(argp1);
+  FXCheckButton_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMenuButton;
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_onUpdate(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","onUpdate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdate", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdate(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_onEnter(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","onEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_onLeave(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","onLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_onFocusIn(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","onFocusIn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusIn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusIn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_onFocusOut(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","onFocusOut", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusOut", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusOut(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_onHotKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","onHotKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_onHotKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","onHotKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_onCmdPost(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","onCmdPost", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdPost", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onCmdPost(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_onCmdUnpost(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","onCmdUnpost", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdUnpost", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onCmdUnpost(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMenuButton_allocate(VALUE self)
+#else
+_wrap_FXMenuButton_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMenuButton);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMenuButton(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXPopup *arg4 = (FXPopup *) 0 ;
+  FXuint arg5 = (FXuint) JUSTIFY_NORMAL|ICON_BEFORE_TEXT|MENUBUTTON_DOWN ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  FXint arg13 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXMenuButton *result = 0 ;
+  
+  if ((argc < 2) || (argc > 13)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXMenuButton", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","FXMenuButton", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 3) {
+    res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_FXPopup, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXPopup *","FXMenuButton", 4, argv[3] )); 
+    }
+    arg4 = reinterpret_cast< FXPopup * >(argp4);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXMenuButton *)new_FXMenuButton(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_setMenu(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXPopup *arg2 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","setMenu", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXPopup *","setMenu", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXPopup * >(argp2);
+  (arg1)->setMenu(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_getMenu(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPopup *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton const *","getMenu", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  result = (FXPopup *)((FXMenuButton const *)arg1)->getMenu();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXPopup, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_setXOffset(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","setXOffset", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setXOffset(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_getXOffset(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton const *","getXOffset", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  result = (FXint)((FXMenuButton const *)arg1)->getXOffset();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_setYOffset(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","setYOffset", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setYOffset(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_getYOffset(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton const *","getYOffset", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  result = (FXint)((FXMenuButton const *)arg1)->getYOffset();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_setButtonStyle(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","setButtonStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setButtonStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_getButtonStyle(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton const *","getButtonStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  result = (FXuint)((FXMenuButton const *)arg1)->getButtonStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_setPopupStyle(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","setPopupStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setPopupStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_getPopupStyle(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton const *","getPopupStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  result = (FXuint)((FXMenuButton const *)arg1)->getPopupStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_setAttachment(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","setAttachment", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setAttachment(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_getAttachment(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton const *","getAttachment", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  result = (FXuint)((FXMenuButton const *)arg1)->getAttachment();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_save(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMenuButton_save((FXMenuButton const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_load(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMenuButton_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_create(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  FXMenuButton_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_detach(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  FXMenuButton_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_destroy(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  FXMenuButton_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_resize(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMenuButton_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  result = (FXint)FXMenuButton_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  result = (FXint)FXMenuButton_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMenuButton_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMenuButton_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  result = (bool)FXMenuButton_canFocus((FXMenuButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  FXMenuButton_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  FXMenuButton_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXMenuButton_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMenuButton_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_enable(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  FXMenuButton_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_disable(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  FXMenuButton_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  FXMenuButton_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_lower(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  FXMenuButton_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_move(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMenuButton_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_position(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXMenuButton_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_layout(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  FXMenuButton_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_recalc(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  FXMenuButton_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_reparent(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXMenuButton_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_show(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  FXMenuButton_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_hide(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  FXMenuButton_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  result = (bool)FXMenuButton_isComposite((FXMenuButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_contains(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXMenuButton_contains((FXMenuButton const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  result = (bool)FXMenuButton_doesSaveUnder((FXMenuButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXMenuButton_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_tr(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXMenuButton_tr((FXMenuButton const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  FXMenuButton_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  FXMenuButton_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXMenuButton_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXMenuButton_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXMenuButton_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMenuButton_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuButton_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuButton_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuButton_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuButton_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXMenuButton *arg1 = (FXMenuButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuButton *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuButton * >(argp1);
+  FXMenuButton_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXOption;
+
+SWIGINTERN VALUE
+_wrap_FXOption_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_onEnter(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","onEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_onLeave(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","onLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_onHotKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","onHotKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_onHotKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","onHotKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXOption_allocate(VALUE self)
+#else
+_wrap_FXOption_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXOption);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXOption(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXObject *arg4 = (FXObject *) 0 ;
+  FXSelector arg5 = (FXSelector) 0 ;
+  FXuint arg6 = (FXuint) JUSTIFY_NORMAL|ICON_BEFORE_TEXT ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) 0 ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  FXint arg13 = (FXint) DEFAULT_PAD ;
+  FXint arg14 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXOption *result = 0 ;
+  
+  if ((argc < 2) || (argc > 14)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXOption", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","FXOption", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 3) {
+    res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXObject *","FXOption", 4, argv[3] )); 
+    }
+    arg4 = reinterpret_cast< FXObject * >(argp4);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2UINT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  if (argc > 13) {
+    arg14 = NUM2INT(argv[13]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXOption *)new_FXOption(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_selBackColore___(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","setSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelBackColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_selBackColor(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption const *","getSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  result = (FXColor)((FXOption const *)arg1)->getSelBackColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_selTextColore___(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","setSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_selTextColor(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption const *","getSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  result = (FXColor)((FXOption const *)arg1)->getSelTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_save(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXOption_save((FXOption const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_load(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXOption_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_create(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  FXOption_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_detach(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  FXOption_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_destroy(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  FXOption_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_resize(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXOption_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  result = (FXint)FXOption_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  result = (FXint)FXOption_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXOption_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXOption_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  result = (bool)FXOption_canFocus((FXOption const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  FXOption_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  FXOption_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXOption_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXOption_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_enable(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  FXOption_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_disable(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  FXOption_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  FXOption_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_lower(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  FXOption_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_move(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXOption_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_position(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXOption_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_layout(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  FXOption_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_recalc(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  FXOption_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_reparent(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXOption_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_show(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  FXOption_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_hide(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  FXOption_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  result = (bool)FXOption_isComposite((FXOption const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_contains(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXOption_contains((FXOption const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  result = (bool)FXOption_doesSaveUnder((FXOption const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXOption_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_tr(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXOption_tr((FXOption const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  FXOption_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  FXOption_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXOption_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXOption_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXOption_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXOption_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXOption, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXOption_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXOption, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXOption_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXOption, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXOption_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOption_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXOption *arg1 = (FXOption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOption *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOption * >(argp1);
+  FXOption_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXOptionMenu;
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_onFocusIn(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","onFocusIn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusIn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusIn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_onFocusOut(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","onFocusOut", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusOut", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusOut(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_onCmdPost(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","onCmdPost", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdPost", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdPost(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_onCmdUnpost(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","onCmdUnpost", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdUnpost", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdUnpost", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdUnpost(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXint) NUM2INT(argv[2]);
+    arg4 = static_cast<void*>(&value4);
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXOptionMenu_allocate(VALUE self)
+#else
+_wrap_FXOptionMenu_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXOptionMenu);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXOptionMenu(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXPopup *arg2 = (FXPopup *) 0 ;
+  FXuint arg3 = (FXuint) JUSTIFY_NORMAL|ICON_BEFORE_TEXT ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) DEFAULT_PAD ;
+  FXint arg9 = (FXint) DEFAULT_PAD ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXOptionMenu *result = 0 ;
+  
+  if ((argc < 1) || (argc > 11)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXOptionMenu", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXPopup, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXPopup *","FXOptionMenu", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXPopup * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXOptionMenu *)new_FXOptionMenu(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_setCurrent(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXOption *arg2 = (FXOption *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","setCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXOption, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXOption *","setCurrent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXOption * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setCurrent(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_getCurrent(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXOption *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu const *","getCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  result = (FXOption *)((FXOptionMenu const *)arg1)->getCurrent();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXOption, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_setCurrentNo(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","setCurrentNo", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setCurrentNo(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_getCurrentNo(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu const *","getCurrentNo", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  result = (FXint)((FXOptionMenu const *)arg1)->getCurrentNo();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_getNumOptions(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu const *","getNumOptions", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  result = (FXint)((FXOptionMenu const *)arg1)->getNumOptions();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_setMenu(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXPopup *arg2 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","setMenu", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXPopup *","setMenu", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXPopup * >(argp2);
+  (arg1)->setMenu(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_getMenu(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPopup *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu const *","getMenu", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  result = (FXPopup *)((FXOptionMenu const *)arg1)->getMenu();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXPopup, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_isPopped(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu const *","isPopped", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  result = (FXbool)((FXOptionMenu const *)arg1)->isPopped();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_save(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXOptionMenu_save((FXOptionMenu const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_load(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXOptionMenu_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_create(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  FXOptionMenu_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_detach(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  FXOptionMenu_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_destroy(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  FXOptionMenu_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_resize(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXOptionMenu_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  result = (FXint)FXOptionMenu_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  result = (FXint)FXOptionMenu_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXOptionMenu_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXOptionMenu_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  result = (bool)FXOptionMenu_canFocus((FXOptionMenu const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  FXOptionMenu_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  FXOptionMenu_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXOptionMenu_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXOptionMenu_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_enable(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  FXOptionMenu_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_disable(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  FXOptionMenu_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  FXOptionMenu_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_lower(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  FXOptionMenu_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_move(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXOptionMenu_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_position(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXOptionMenu_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_layout(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  FXOptionMenu_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_recalc(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  FXOptionMenu_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_reparent(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXOptionMenu_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_show(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  FXOptionMenu_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_hide(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  FXOptionMenu_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  result = (bool)FXOptionMenu_isComposite((FXOptionMenu const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_contains(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXOptionMenu_contains((FXOptionMenu const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  result = (bool)FXOptionMenu_doesSaveUnder((FXOptionMenu const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXOptionMenu_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_tr(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXOptionMenu_tr((FXOptionMenu const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  FXOptionMenu_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  FXOptionMenu_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXOptionMenu_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXOptionMenu_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXOptionMenu_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXOptionMenu_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXOptionMenu, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXOptionMenu_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXOptionMenu, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXOptionMenu_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXOptionMenu, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXOptionMenu_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXOptionMenu_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXOptionMenu *arg1 = (FXOptionMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXOptionMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXOptionMenu *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXOptionMenu * >(argp1);
+  FXOptionMenu_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXRadioButton;
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_onUpdate(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","onUpdate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdate", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdate(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_onEnter(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","onEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_onLeave(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","onLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_onFocusIn(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","onFocusIn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusIn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusIn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_onFocusOut(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","onFocusOut", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusOut", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusOut(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_onHotKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","onHotKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_onHotKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","onHotKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onHotKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_onCheck(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","onCheck", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCheck", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCheck(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_onUncheck(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","onUncheck", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUncheck", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUncheck(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_onUnknown(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","onUnknown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUnknown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUnknown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXint) NUM2INT(argv[2]);
+    arg4 = static_cast<void*>(&value4);
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXRadioButton_allocate(VALUE self)
+#else
+_wrap_FXRadioButton_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXRadioButton);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRadioButton(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXString *arg2 = 0 ;
+  FXObject *arg3 = (FXObject *) 0 ;
+  FXSelector arg4 = (FXSelector) 0 ;
+  FXuint arg5 = (FXuint) RADIOBUTTON_NORMAL ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  FXint arg13 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXRadioButton *result = 0 ;
+  
+  if ((argc < 2) || (argc > 13)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXRadioButton", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXObject *","FXRadioButton", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXObject * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXRadioButton *)new_FXRadioButton(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_setCheck(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","setCheck", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setCheck(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_getCheck(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton const *","getCheck", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  result = (FXbool)FXRadioButton_getCheck((FXRadioButton const *)arg1);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_getCheckState(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuchar result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton const *","getCheckState", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  result = (FXuchar)FXRadioButton_getCheckState((FXRadioButton const *)arg1);
+  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_setRadioButtonStyle(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","setRadioButtonStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setRadioButtonStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_getRadioButtonStyle(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton const *","getRadioButtonStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  result = (FXuint)((FXRadioButton const *)arg1)->getRadioButtonStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_getRadioColor(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton const *","getRadioColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  result = (FXColor)((FXRadioButton const *)arg1)->getRadioColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_setRadioColor(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","setRadioColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setRadioColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_getDiskColor(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton const *","getDiskColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  result = (FXColor)((FXRadioButton const *)arg1)->getDiskColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_setDiskColor(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","setDiskColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setDiskColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_save(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXRadioButton_save((FXRadioButton const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_load(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXRadioButton_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_create(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  FXRadioButton_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_detach(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  FXRadioButton_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_destroy(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  FXRadioButton_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_resize(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXRadioButton_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  result = (FXint)FXRadioButton_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  result = (FXint)FXRadioButton_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXRadioButton_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXRadioButton_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  result = (bool)FXRadioButton_canFocus((FXRadioButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  FXRadioButton_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  FXRadioButton_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXRadioButton_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXRadioButton_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_enable(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  FXRadioButton_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_disable(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  FXRadioButton_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  FXRadioButton_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_lower(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  FXRadioButton_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_move(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXRadioButton_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_position(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXRadioButton_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_layout(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  FXRadioButton_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_recalc(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  FXRadioButton_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_reparent(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXRadioButton_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_show(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  FXRadioButton_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_hide(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  FXRadioButton_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  result = (bool)FXRadioButton_isComposite((FXRadioButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_contains(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXRadioButton_contains((FXRadioButton const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  result = (bool)FXRadioButton_doesSaveUnder((FXRadioButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXRadioButton_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_tr(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXRadioButton_tr((FXRadioButton const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  FXRadioButton_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  FXRadioButton_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXRadioButton_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXRadioButton_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXRadioButton_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXRadioButton_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRadioButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRadioButton_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRadioButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRadioButton_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRadioButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRadioButton_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRadioButton_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXRadioButton *arg1 = (FXRadioButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRadioButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRadioButton *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRadioButton * >(argp1);
+  FXRadioButton_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXTabItem;
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_onFocusIn(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","onFocusIn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusIn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusIn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_onFocusOut(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","onFocusOut", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusOut", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusOut(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_onHotKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","onHotKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_onHotKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","onHotKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXTabItem_allocate(VALUE self)
+#else
+_wrap_FXTabItem_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXTabItem);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXTabItem(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXuint arg4 = (FXuint) TAB_TOP_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) DEFAULT_PAD ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXTabItem *result = 0 ;
+  
+  if ((argc < 2) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","FXTabItem", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","FXTabItem", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    result = (FXTabItem *)new_FXTabItem(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_getTabOrientation(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem const *","getTabOrientation", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  result = (FXuint)((FXTabItem const *)arg1)->getTabOrientation();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_setTabOrientation(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","setTabOrientation", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setTabOrientation(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_save(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTabItem_save((FXTabItem const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_load(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTabItem_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_create(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  FXTabItem_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_detach(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  FXTabItem_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_destroy(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  FXTabItem_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_resize(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXTabItem_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  result = (FXint)FXTabItem_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  result = (FXint)FXTabItem_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXTabItem_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXTabItem_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  result = (bool)FXTabItem_canFocus((FXTabItem const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  FXTabItem_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  FXTabItem_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXTabItem_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXTabItem_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_enable(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  FXTabItem_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_disable(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  FXTabItem_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  FXTabItem_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_lower(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  FXTabItem_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_move(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXTabItem_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_position(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXTabItem_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_layout(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  FXTabItem_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_recalc(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  FXTabItem_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_reparent(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXTabItem_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_show(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  FXTabItem_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_hide(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  FXTabItem_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  result = (bool)FXTabItem_isComposite((FXTabItem const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_contains(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXTabItem_contains((FXTabItem const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  result = (bool)FXTabItem_doesSaveUnder((FXTabItem const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXTabItem_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_tr(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXTabItem_tr((FXTabItem const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  FXTabItem_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  FXTabItem_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXTabItem_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXTabItem_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXTabItem_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXTabItem_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTabItem, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTabItem_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTabItem, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTabItem_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTabItem, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTabItem_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabItem_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXTabItem *arg1 = (FXTabItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabItem *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabItem * >(argp1);
+  FXTabItem_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXToggleButton;
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_onUpdate(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","onUpdate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdate", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdate(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_onEnter(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","onEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_onLeave(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","onLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_onFocusIn(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","onFocusIn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusIn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusIn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_onFocusOut(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","onFocusOut", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusOut", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusOut(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_onHotKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","onHotKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_onHotKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","onHotKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onHotKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_onCheck(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","onCheck", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCheck", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCheck(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_onUncheck(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","onUncheck", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUncheck", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUncheck(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXint) NUM2INT(argv[2]);
+    arg4 = static_cast<void*>(&value4);
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXToggleButton_allocate(VALUE self)
+#else
+_wrap_FXToggleButton_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXToggleButton);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXToggleButton(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXString *arg2 = 0 ;
+  FXString *arg3 = 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  FXObject *arg6 = (FXObject *) 0 ;
+  FXSelector arg7 = (FXSelector) 0 ;
+  FXuint arg8 = (FXuint) TOGGLEBUTTON_NORMAL ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) 0 ;
+  FXint arg11 = (FXint) 0 ;
+  FXint arg12 = (FXint) 0 ;
+  FXint arg13 = (FXint) DEFAULT_PAD ;
+  FXint arg14 = (FXint) DEFAULT_PAD ;
+  FXint arg15 = (FXint) DEFAULT_PAD ;
+  FXint arg16 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  SwigValueWrapper< FXString > p3 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  void *argp6 = 0 ;
+  int res6 = 0 ;
+  FXToggleButton *result = 0 ;
+  
+  if ((argc < 3) || (argc > 16)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXToggleButton", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  p3 = to_FXString(argv[2]); arg3 = &p3;
+  if (argc > 3) {
+    res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","FXToggleButton", 4, argv[3] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 4) {
+    res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","FXToggleButton", 5, argv[4] )); 
+    }
+    arg5 = reinterpret_cast< FXIcon * >(argp5);
+  }
+  if (argc > 5) {
+    res6 = SWIG_ConvertPtr(argv[5], &argp6,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res6)) {
+      SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "FXObject *","FXToggleButton", 6, argv[5] )); 
+    }
+    arg6 = reinterpret_cast< FXObject * >(argp6);
+  }
+  if (argc > 6) {
+    arg7 = NUM2UINT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2UINT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  if (argc > 13) {
+    arg14 = NUM2INT(argv[13]);
+  }
+  if (argc > 14) {
+    arg15 = NUM2INT(argv[14]);
+  }
+  if (argc > 15) {
+    arg16 = NUM2INT(argv[15]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXToggleButton *)new_FXToggleButton(arg1,(FXString const &)*arg2,(FXString const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_setAltText(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","setAltText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setAltText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_getAltText(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton const *","getAltText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  result = ((FXToggleButton const *)arg1)->getAltText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_setAltIcon(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","setAltIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setAltIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  (arg1)->setAltIcon(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_getAltIcon(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton const *","getAltIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  result = (FXIcon *)((FXToggleButton const *)arg1)->getAltIcon();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_setState(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","setState", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setState(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_getState(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton const *","getState", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  result = (FXbool)((FXToggleButton const *)arg1)->getState();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_setAltHelpText(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","setAltHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setAltHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_getAltHelpText(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton const *","getAltHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  result = ((FXToggleButton const *)arg1)->getAltHelpText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_setAltTipText(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","setAltTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setAltTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_getAltTipText(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton const *","getAltTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  result = ((FXToggleButton const *)arg1)->getAltTipText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_setToggleStyle(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","setToggleStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setToggleStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_getToggleStyle(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton const *","getToggleStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  result = (FXuint)((FXToggleButton const *)arg1)->getToggleStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_save(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXToggleButton_save((FXToggleButton const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_load(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXToggleButton_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_create(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  FXToggleButton_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_detach(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  FXToggleButton_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_destroy(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  FXToggleButton_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_resize(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXToggleButton_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  result = (FXint)FXToggleButton_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  result = (FXint)FXToggleButton_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXToggleButton_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXToggleButton_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  result = (bool)FXToggleButton_canFocus((FXToggleButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  FXToggleButton_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  FXToggleButton_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXToggleButton_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXToggleButton_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_enable(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  FXToggleButton_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_disable(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  FXToggleButton_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  FXToggleButton_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_lower(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  FXToggleButton_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_move(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXToggleButton_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_position(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXToggleButton_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_layout(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  FXToggleButton_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_recalc(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  FXToggleButton_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_reparent(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXToggleButton_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_show(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  FXToggleButton_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_hide(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  FXToggleButton_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  result = (bool)FXToggleButton_isComposite((FXToggleButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_contains(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXToggleButton_contains((FXToggleButton const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  result = (bool)FXToggleButton_doesSaveUnder((FXToggleButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXToggleButton_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_tr(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXToggleButton_tr((FXToggleButton const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  FXToggleButton_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  FXToggleButton_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXToggleButton_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXToggleButton_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXToggleButton_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXToggleButton_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToggleButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXToggleButton_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToggleButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXToggleButton_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToggleButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXToggleButton_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToggleButton_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXToggleButton *arg1 = (FXToggleButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToggleButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToggleButton *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToggleButton * >(argp1);
+  FXToggleButton_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXTriStateButton;
+
+SWIGINTERN VALUE
+_wrap_FXTriStateButton_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXTriStateButton *arg1 = (FXTriStateButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTriStateButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTriStateButton *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTriStateButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTriStateButton_onUnknown(int argc, VALUE *argv, VALUE self) {
+  FXTriStateButton *arg1 = (FXTriStateButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTriStateButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTriStateButton *","onUnknown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTriStateButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUnknown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onUnknown", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onUnknown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTriStateButton_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXTriStateButton *arg1 = (FXTriStateButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTriStateButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTriStateButton *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTriStateButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onQueryHelp", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTriStateButton_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXTriStateButton *arg1 = (FXTriStateButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTriStateButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTriStateButton *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTriStateButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onQueryTip", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXTriStateButton_allocate(VALUE self)
+#else
+_wrap_FXTriStateButton_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXTriStateButton);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXTriStateButton(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXString *arg2 = 0 ;
+  FXString *arg3 = 0 ;
+  FXString *arg4 = 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  FXIcon *arg6 = (FXIcon *) 0 ;
+  FXIcon *arg7 = (FXIcon *) 0 ;
+  FXObject *arg8 = (FXObject *) 0 ;
+  FXSelector arg9 = (FXSelector) 0 ;
+  FXuint arg10 = (FXuint) TOGGLEBUTTON_NORMAL ;
+  FXint arg11 = (FXint) 0 ;
+  FXint arg12 = (FXint) 0 ;
+  FXint arg13 = (FXint) 0 ;
+  FXint arg14 = (FXint) 0 ;
+  FXint arg15 = (FXint) DEFAULT_PAD ;
+  FXint arg16 = (FXint) DEFAULT_PAD ;
+  FXint arg17 = (FXint) DEFAULT_PAD ;
+  FXint arg18 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  SwigValueWrapper< FXString > p3 ;
+  SwigValueWrapper< FXString > p4 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  void *argp6 = 0 ;
+  int res6 = 0 ;
+  void *argp7 = 0 ;
+  int res7 = 0 ;
+  void *argp8 = 0 ;
+  int res8 = 0 ;
+  FXTriStateButton *result = 0 ;
+  
+  if ((argc < 4) || (argc > 18)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXTriStateButton", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  p3 = to_FXString(argv[2]); arg3 = &p3;
+  p4 = to_FXString(argv[3]); arg4 = &p4;
+  if (argc > 4) {
+    res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","FXTriStateButton", 5, argv[4] )); 
+    }
+    arg5 = reinterpret_cast< FXIcon * >(argp5);
+  }
+  if (argc > 5) {
+    res6 = SWIG_ConvertPtr(argv[5], &argp6,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res6)) {
+      SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "FXIcon *","FXTriStateButton", 6, argv[5] )); 
+    }
+    arg6 = reinterpret_cast< FXIcon * >(argp6);
+  }
+  if (argc > 6) {
+    res7 = SWIG_ConvertPtr(argv[6], &argp7,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res7)) {
+      SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "FXIcon *","FXTriStateButton", 7, argv[6] )); 
+    }
+    arg7 = reinterpret_cast< FXIcon * >(argp7);
+  }
+  if (argc > 7) {
+    res8 = SWIG_ConvertPtr(argv[7], &argp8,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res8)) {
+      SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "FXObject *","FXTriStateButton", 8, argv[7] )); 
+    }
+    arg8 = reinterpret_cast< FXObject * >(argp8);
+  }
+  if (argc > 8) {
+    arg9 = NUM2UINT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2UINT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  if (argc > 13) {
+    arg14 = NUM2INT(argv[13]);
+  }
+  if (argc > 14) {
+    arg15 = NUM2INT(argv[14]);
+  }
+  if (argc > 15) {
+    arg16 = NUM2INT(argv[15]);
+  }
+  if (argc > 16) {
+    arg17 = NUM2INT(argv[16]);
+  }
+  if (argc > 17) {
+    arg18 = NUM2INT(argv[17]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXTriStateButton *)new_FXTriStateButton(arg1,(FXString const &)*arg2,(FXString const &)*arg3,(FXString const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTriStateButton_setMaybeText(int argc, VALUE *argv, VALUE self) {
+  FXTriStateButton *arg1 = (FXTriStateButton *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTriStateButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTriStateButton *","setMaybeText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTriStateButton * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setMaybeText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTriStateButton_getMaybeText(int argc, VALUE *argv, VALUE self) {
+  FXTriStateButton *arg1 = (FXTriStateButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTriStateButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTriStateButton const *","getMaybeText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTriStateButton * >(argp1);
+  result = ((FXTriStateButton const *)arg1)->getMaybeText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTriStateButton_setMaybeIcon(int argc, VALUE *argv, VALUE self) {
+  FXTriStateButton *arg1 = (FXTriStateButton *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTriStateButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTriStateButton *","setMaybeIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTriStateButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setMaybeIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  (arg1)->setMaybeIcon(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTriStateButton_getMaybeIcon(int argc, VALUE *argv, VALUE self) {
+  FXTriStateButton *arg1 = (FXTriStateButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTriStateButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTriStateButton const *","getMaybeIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTriStateButton * >(argp1);
+  result = (FXIcon *)((FXTriStateButton const *)arg1)->getMaybeIcon();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTriStateButton_setMaybeHelpText(int argc, VALUE *argv, VALUE self) {
+  FXTriStateButton *arg1 = (FXTriStateButton *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTriStateButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTriStateButton *","setMaybeHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTriStateButton * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setMaybeHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTriStateButton_getMaybeHelpText(int argc, VALUE *argv, VALUE self) {
+  FXTriStateButton *arg1 = (FXTriStateButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTriStateButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTriStateButton const *","getMaybeHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTriStateButton * >(argp1);
+  result = ((FXTriStateButton const *)arg1)->getMaybeHelpText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTriStateButton_setMaybeTipText(int argc, VALUE *argv, VALUE self) {
+  FXTriStateButton *arg1 = (FXTriStateButton *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTriStateButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTriStateButton *","setMaybeTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTriStateButton * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setMaybeTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTriStateButton_getMaybeTipText(int argc, VALUE *argv, VALUE self) {
+  FXTriStateButton *arg1 = (FXTriStateButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTriStateButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTriStateButton const *","getMaybeTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTriStateButton * >(argp1);
+  result = ((FXTriStateButton const *)arg1)->getMaybeTipText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXPicker;
+
+SWIGINTERN VALUE
+_wrap_FXPicker_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_onEnter(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","onEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_onLeave(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","onLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXPicker_allocate(VALUE self)
+#else
+_wrap_FXPicker_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXPicker);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXPicker(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXObject *arg4 = (FXObject *) 0 ;
+  FXSelector arg5 = (FXSelector) 0 ;
+  FXuint arg6 = (FXuint) BUTTON_NORMAL ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) 0 ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  FXint arg13 = (FXint) DEFAULT_PAD ;
+  FXint arg14 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXPicker *result = 0 ;
+  
+  if ((argc < 2) || (argc > 14)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXPicker", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","FXPicker", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 3) {
+    res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXObject *","FXPicker", 4, argv[3] )); 
+    }
+    arg4 = reinterpret_cast< FXObject * >(argp4);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2UINT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  if (argc > 13) {
+    arg14 = NUM2INT(argv[13]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXPicker *)new_FXPicker(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_save(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXPicker_save((FXPicker const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_load(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXPicker_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_create(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  FXPicker_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_detach(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  FXPicker_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_destroy(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  FXPicker_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_resize(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXPicker_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  result = (FXint)FXPicker_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  result = (FXint)FXPicker_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXPicker_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXPicker_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  result = (bool)FXPicker_canFocus((FXPicker const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  FXPicker_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  FXPicker_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXPicker_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXPicker_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_enable(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  FXPicker_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_disable(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  FXPicker_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  FXPicker_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_lower(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  FXPicker_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_move(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXPicker_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_position(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXPicker_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_layout(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  FXPicker_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_recalc(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  FXPicker_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_reparent(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXPicker_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_show(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  FXPicker_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_hide(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  FXPicker_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  result = (bool)FXPicker_isComposite((FXPicker const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_contains(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXPicker_contains((FXPicker const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  result = (bool)FXPicker_doesSaveUnder((FXPicker const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXPicker_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_tr(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXPicker_tr((FXPicker const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  FXPicker_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  FXPicker_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXPicker_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXPicker_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXPicker_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXPicker_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXPicker, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXPicker_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXPicker, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXPicker_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXPicker, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXPicker_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPicker_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXPicker *arg1 = (FXPicker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPicker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPicker *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPicker * >(argp1);
+  FXPicker_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_FXShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXShell *) x));
+}
+static void *_p_FXRootWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXRootWindow *) x));
+}
+static void *_p_FXPopupTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXTopWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXTriStateButtonTo_p_FXToggleButton(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXToggleButton *)  ((FXTriStateButton *) x));
+}
+static void *_p_FXOptionTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *) ((FXOption *) x));
+}
+static void *_p_FXCompositeTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXComposite *) x));
+}
+static void *_p_FXTextFieldTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXMenuButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *) ((FXMenuButton *) x));
+}
+static void *_p_FXCheckButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *) ((FXCheckButton *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXRadioButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *) ((FXRadioButton *) x));
+}
+static void *_p_FXToggleButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *) ((FXToggleButton *) x));
+}
+static void *_p_FXTriStateButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *)(FXToggleButton *) ((FXTriStateButton *) x));
+}
+static void *_p_FXShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXPopupTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXRootWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXRulerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXStatusLineTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXTabItemTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *) ((FXTabItem *) x));
+}
+static void *_p_FXKnobTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXGradientBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXColorWheelTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXImageFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXLabelTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXLabel *) x));
+}
+static void *_p_FXPickerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *)(FXButton *) ((FXPicker *) x));
+}
+static void *_p_FXProgressBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXOptionMenuTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *) ((FXOptionMenu *) x));
+}
+static void *_p_FXHeaderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXColorWellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDialTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *) ((FXButton *) x));
+}
+static void *_p_FXColorBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXColorRingTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXOptionTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXOption *) x));
+}
+static void *_p_FXSettingsTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXSettings *) x));
+}
+static void *_p_FXAccelTableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXAccelTable *) x));
+}
+static void *_p_FXCompositeTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXRegistryTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *)(FXSettings *) ((FXRegistry *) x));
+}
+static void *_p_FXTextFieldTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXIconDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXIconDict *) x));
+}
+static void *_p_FXCheckButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXCheckButton *) x));
+}
+static void *_p_FXMenuButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXMenuButton *) x));
+}
+static void *_p_FXRadioButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXRadioButton *) x));
+}
+static void *_p_FXToggleButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXToggleButton *) x));
+}
+static void *_p_FXTriStateButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *)(FXToggleButton *) ((FXTriStateButton *) x));
+}
+static void *_p_FXShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXPopupTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXRecentFilesTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXRecentFiles *) x));
+}
+static void *_p_FXDocumentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDocument *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXRulerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXStatusLineTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXTabItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXTabItem *) x));
+}
+static void *_p_FXKnobTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXStringDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXStringDict *) x));
+}
+static void *_p_FXColorWheelTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXGradientBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXFontTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXFont *) x));
+}
+static void *_p_FXFileDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXFileDict *) x));
+}
+static void *_p_FXImageFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXLabelTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXLabel *) x));
+}
+static void *_p_FXDataTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDataTarget *) x));
+}
+static void *_p_FXDebugTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDebugTarget *) x));
+}
+static void *_p_FXPickerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *)(FXButton *) ((FXPicker *) x));
+}
+static void *_p_FXDelegatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDelegator *) x));
+}
+static void *_p_FXDrawableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXDrawable *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXCursor *) x));
+}
+static void *_p_FXProgressBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXOptionMenuTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXOptionMenu *) x));
+}
+static void *_p_FXTranslatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXTranslator *) x));
+}
+static void *_p_FXDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDict *) x));
+}
+static void *_p_FXHeaderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXColorWellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXHeaderItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXHeaderItem *) x));
+}
+static void *_p_FXDialTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXIdTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXId *) x));
+}
+static void *_p_FXFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FXSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXRealSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXVisualTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXVisual *) x));
+}
+static void *_p_FXButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXButton *) x));
+}
+static void *_p_FXColorRingTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXColorBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXAppTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXApp *) x));
+}
+static void *_p_FXOptionTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *)  ((FXOption *) x));
+}
+static void *_p_FXButtonTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *)  ((FXButton *) x));
+}
+static void *_p_FXTabItemTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *)  ((FXTabItem *) x));
+}
+static void *_p_FXPickerTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *) (FXButton *) ((FXPicker *) x));
+}
+static void *_p_FXCheckButtonTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *)  ((FXCheckButton *) x));
+}
+static void *_p_FXMenuButtonTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *)  ((FXMenuButton *) x));
+}
+static void *_p_FXRadioButtonTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *)  ((FXRadioButton *) x));
+}
+static void *_p_FXToggleButtonTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *)  ((FXToggleButton *) x));
+}
+static void *_p_FXTriStateButtonTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *) (FXToggleButton *) ((FXTriStateButton *) x));
+}
+static void *_p_FXOptionMenuTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *)  ((FXOptionMenu *) x));
+}
+static void *_p_FXOptionTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *) ((FXOption *) x));
+}
+static void *_p_FXCompositeTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXTextFieldTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXMenuButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *) ((FXMenuButton *) x));
+}
+static void *_p_FXCheckButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *) ((FXCheckButton *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXRadioButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *) ((FXRadioButton *) x));
+}
+static void *_p_FXToggleButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *) ((FXToggleButton *) x));
+}
+static void *_p_FXTriStateButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *)(FXToggleButton *) ((FXTriStateButton *) x));
+}
+static void *_p_FXShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXPopupTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *)  ((FXWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXRulerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXStatusLineTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXTabItemTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *) ((FXTabItem *) x));
+}
+static void *_p_FXKnobTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXGradientBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXColorWheelTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXImageFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXLabelTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXLabel *) x));
+}
+static void *_p_FXPickerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *)(FXButton *) ((FXPicker *) x));
+}
+static void *_p_FXProgressBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXOptionMenuTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *) ((FXOptionMenu *) x));
+}
+static void *_p_FXHeaderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXColorWellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDialTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *) ((FXButton *) x));
+}
+static void *_p_FXColorBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXColorRingTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXFileStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXFileStream *) x));
+}
+static void *_p_FXMemoryStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXMemoryStream *) x));
+}
+static void *_p_FXOptionTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXOption *) x));
+}
+static void *_p_FXCompositeTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXTextFieldTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXCheckButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXCheckButton *) x));
+}
+static void *_p_FXMenuButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXMenuButton *) x));
+}
+static void *_p_FXRadioButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXRadioButton *) x));
+}
+static void *_p_FXToggleButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXToggleButton *) x));
+}
+static void *_p_FXTriStateButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *)(FXToggleButton *) ((FXTriStateButton *) x));
+}
+static void *_p_FXShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXPopupTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXRulerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXStatusLineTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXTabItemTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXTabItem *) x));
+}
+static void *_p_FXKnobTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXColorWheelTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXGradientBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXFontTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXFont *) x));
+}
+static void *_p_FXImageFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXLabelTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXLabel *) x));
+}
+static void *_p_FXPickerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *)(FXButton *) ((FXPicker *) x));
+}
+static void *_p_FXDrawableTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXDrawable *) x));
+}
+static void *_p_FXCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXProgressBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXOptionMenuTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXOptionMenu *) x));
+}
+static void *_p_FXHeaderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXColorWellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDialTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXVisualTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXVisual *) x));
+}
+static void *_p_FXButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXButton *) x));
+}
+static void *_p_FXColorRingTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXColorBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXToolBarTab *) x));
+}
+static void *_p_FXColorRingTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXColorRing *) x));
+}
+static void *_p_FXColorBarTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXColorBar *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXBitmapFrame *) x));
+}
+static void *_p_FXPickerTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *)(FXButton *) ((FXPicker *) x));
+}
+static void *_p_FXDialTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXDial *) x));
+}
+static void *_p_FXRulerTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXRuler *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXArrowButton *) x));
+}
+static void *_p_FXLabelTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXLabel *) x));
+}
+static void *_p_FXCheckButtonTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *) ((FXCheckButton *) x));
+}
+static void *_p_FXMenuButtonTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *) ((FXMenuButton *) x));
+}
+static void *_p_FXRadioButtonTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *) ((FXRadioButton *) x));
+}
+static void *_p_FXToggleButtonTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *) ((FXToggleButton *) x));
+}
+static void *_p_FXTriStateButtonTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *)(FXToggleButton *) ((FXTriStateButton *) x));
+}
+static void *_p_FXColorWheelTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXColorWheel *) x));
+}
+static void *_p_FXProgressBarTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXProgressBar *) x));
+}
+static void *_p_FXColorWellTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXColorWell *) x));
+}
+static void *_p_FXGradientBarTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXGradientBar *) x));
+}
+static void *_p_FXStatusLineTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXStatusLine *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXSeparator *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXButtonTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *) ((FXButton *) x));
+}
+static void *_p_FXTextFieldTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXTextField *) x));
+}
+static void *_p_FXTabItemTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *) ((FXTabItem *) x));
+}
+static void *_p_FXHeaderTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXHeader *) x));
+}
+static void *_p_FXOptionTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *) ((FXOption *) x));
+}
+static void *_p_FXImageFrameTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXImageFrame *) x));
+}
+static void *_p_FXOptionMenuTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *) ((FXOptionMenu *) x));
+}
+static void *_p_FXKnobTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXKnob *) x));
+}
+static void *_p_FXSliderTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXSlider *) x));
+}
+static void *_p_FXRealSliderTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXRealSlider *) x));
+}
+static void *_p_FXPickerTo_p_FXButton(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXButton *)  ((FXPicker *) x));
+}
+static swig_type_info _swigt__p_FXBitmap = {"_p_FXBitmap", "FXBitmap *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXButton = {"_p_FXButton", "FXButton *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXCheckButton = {"_p_FXCheckButton", "FXCheckButton *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXComposite = {"_p_FXComposite", "FXComposite *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXShell = {"_p_FXShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRootWindow = {"_p_FXRootWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTopWindow = {"_p_FXTopWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMainWindow = {"_p_FXMainWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplashWindow = {"_p_FXSplashWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDrawable = {"_p_FXDrawable", "FXDrawable *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDial = {"_p_FXDial", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTextField = {"_p_FXTextField", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXArrowButton = {"_p_FXArrowButton", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRuler = {"_p_FXRuler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalSeparator = {"_p_FXVerticalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalSeparator = {"_p_FXHorizontalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSeparator = {"_p_FXSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusLine = {"_p_FXStatusLine", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGradientBar = {"_p_FXGradientBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWheel = {"_p_FXColorWheel", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXBitmapFrame = {"_p_FXBitmapFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImageFrame = {"_p_FXImageFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXKnob = {"_p_FXKnob", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXProgressBar = {"_p_FXProgressBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHeader = {"_p_FXHeader", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWell = {"_p_FXColorWell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarTab = {"_p_FXToolBarTab", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSlider = {"_p_FXSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRealSlider = {"_p_FXRealSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorRing = {"_p_FXColorRing", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorBar = {"_p_FXColorBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFont = {"_p_FXFont", "FXFont *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFrame = {"_p_FXFrame", "FXFrame *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXIcon = {"_p_FXIcon", "FXIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXId = {"_p_FXId", "FXId *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXCURCursor = {"_p_FXCURCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCursor = {"_p_FXCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGIFCursor = {"_p_FXGIFCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVisual = {"_p_FXVisual", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXLabel = {"_p_FXLabel", "FXLabel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMenuButton = {"_p_FXMenuButton", "FXMenuButton *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXObject = {"_p_FXObject", "FXObject *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDict = {"_p_FXDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSettings = {"_p_FXSettings", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXAccelTable = {"_p_FXAccelTable", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRegistry = {"_p_FXRegistry", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXIconDict = {"_p_FXIconDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRecentFiles = {"_p_FXRecentFiles", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDocument = {"_p_FXDocument", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStringDict = {"_p_FXStringDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileDict = {"_p_FXFileDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDataTarget = {"_p_FXDataTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDebugTarget = {"_p_FXDebugTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDelegator = {"_p_FXDelegator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTranslator = {"_p_FXTranslator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXApp = {"_p_FXApp", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHeaderItem = {"_p_FXHeaderItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXOption = {"_p_FXOption", "FXOption *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXOptionMenu = {"_p_FXOptionMenu", "FXOptionMenu *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXPicker = {"_p_FXPicker", "FXPicker *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXPopup = {"_p_FXPopup", "FXPopup *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRadioButton = {"_p_FXRadioButton", "FXRadioButton *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRegion = {"_p_FXRegion", "FXRegion *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXStream = {"_p_FXStream", "FXStream *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFileStream = {"_p_FXFileStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMemoryStream = {"_p_FXMemoryStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTabBar = {"_p_FXTabBar", "FXTabBar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXTabItem = {"_p_FXTabItem", "FXTabItem *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXToggleButton = {"_p_FXToggleButton", "FXToggleButton *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXTriStateButton = {"_p_FXTriStateButton", "FXTriStateButton *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXWindow = {"_p_FXWindow", "FXWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_char = {"_p_char", "char *|FXchar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "double *|FXdouble *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_float = {"_p_float", "float *|FXfloat *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "FXint *|int *|FXInputHandle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_long = {"_p_long", "long *|FXTime *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_short = {"_p_short", "short *|FXshort *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "FXuchar *|unsigned char *|FXbool *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "FXwchar *|FXDragType *|unsigned int *|FXuint *|FXColor *|FXSelector *|FXHotKey *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|FXuval *|FXPixel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|FXushort *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_FXAccelTable,
+  &_swigt__p_FXApp,
+  &_swigt__p_FXArrowButton,
+  &_swigt__p_FXBitmap,
+  &_swigt__p_FXBitmapFrame,
+  &_swigt__p_FXButton,
+  &_swigt__p_FXCURCursor,
+  &_swigt__p_FXCheckButton,
+  &_swigt__p_FXColorBar,
+  &_swigt__p_FXColorRing,
+  &_swigt__p_FXColorWell,
+  &_swigt__p_FXColorWheel,
+  &_swigt__p_FXComposite,
+  &_swigt__p_FXCursor,
+  &_swigt__p_FXDataTarget,
+  &_swigt__p_FXDebugTarget,
+  &_swigt__p_FXDelegator,
+  &_swigt__p_FXDial,
+  &_swigt__p_FXDict,
+  &_swigt__p_FXDocument,
+  &_swigt__p_FXDrawable,
+  &_swigt__p_FXFileDict,
+  &_swigt__p_FXFileStream,
+  &_swigt__p_FXFont,
+  &_swigt__p_FXFrame,
+  &_swigt__p_FXGIFCursor,
+  &_swigt__p_FXGradientBar,
+  &_swigt__p_FXHeader,
+  &_swigt__p_FXHeaderItem,
+  &_swigt__p_FXHorizontalSeparator,
+  &_swigt__p_FXIcon,
+  &_swigt__p_FXIconDict,
+  &_swigt__p_FXId,
+  &_swigt__p_FXImageFrame,
+  &_swigt__p_FXKnob,
+  &_swigt__p_FXLabel,
+  &_swigt__p_FXMainWindow,
+  &_swigt__p_FXMemoryStream,
+  &_swigt__p_FXMenuButton,
+  &_swigt__p_FXObject,
+  &_swigt__p_FXOption,
+  &_swigt__p_FXOptionMenu,
+  &_swigt__p_FXPicker,
+  &_swigt__p_FXPopup,
+  &_swigt__p_FXProgressBar,
+  &_swigt__p_FXRadioButton,
+  &_swigt__p_FXRealSlider,
+  &_swigt__p_FXRecentFiles,
+  &_swigt__p_FXRegion,
+  &_swigt__p_FXRegistry,
+  &_swigt__p_FXRootWindow,
+  &_swigt__p_FXRuler,
+  &_swigt__p_FXSeparator,
+  &_swigt__p_FXSettings,
+  &_swigt__p_FXShell,
+  &_swigt__p_FXSlider,
+  &_swigt__p_FXSplashWindow,
+  &_swigt__p_FXStatusLine,
+  &_swigt__p_FXStream,
+  &_swigt__p_FXStringDict,
+  &_swigt__p_FXTabBar,
+  &_swigt__p_FXTabItem,
+  &_swigt__p_FXTextField,
+  &_swigt__p_FXToggleButton,
+  &_swigt__p_FXToolBarTab,
+  &_swigt__p_FXTopWindow,
+  &_swigt__p_FXTranslator,
+  &_swigt__p_FXTriStateButton,
+  &_swigt__p_FXVerticalSeparator,
+  &_swigt__p_FXVisual,
+  &_swigt__p_FXWindow,
+  &_swigt__p_char,
+  &_swigt__p_double,
+  &_swigt__p_float,
+  &_swigt__p_int,
+  &_swigt__p_long,
+  &_swigt__p_short,
+  &_swigt__p_unsigned_char,
+  &_swigt__p_unsigned_int,
+  &_swigt__p_unsigned_long,
+  &_swigt__p_unsigned_short,
+};
+
+static swig_cast_info _swigc__p_FXBitmap[] = {  {&_swigt__p_FXBitmap, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXButton[] = {  {&_swigt__p_FXButton, 0, 0, 0},  {&_swigt__p_FXPicker, _p_FXPickerTo_p_FXButton, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCheckButton[] = {  {&_swigt__p_FXCheckButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShell[] = {{&_swigt__p_FXShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRootWindow[] = {{&_swigt__p_FXRootWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTopWindow[] = {{&_swigt__p_FXTopWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMainWindow[] = {{&_swigt__p_FXMainWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplashWindow[] = {{&_swigt__p_FXSplashWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComposite[] = {  {&_swigt__p_FXComposite, 0, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXComposite, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDial[] = {{&_swigt__p_FXDial, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTextField[] = {{&_swigt__p_FXTextField, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXArrowButton[] = {{&_swigt__p_FXArrowButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRuler[] = {{&_swigt__p_FXRuler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalSeparator[] = {{&_swigt__p_FXVerticalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalSeparator[] = {{&_swigt__p_FXHorizontalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSeparator[] = {{&_swigt__p_FXSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusLine[] = {{&_swigt__p_FXStatusLine, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGradientBar[] = {{&_swigt__p_FXGradientBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWheel[] = {{&_swigt__p_FXColorWheel, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBitmapFrame[] = {{&_swigt__p_FXBitmapFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageFrame[] = {{&_swigt__p_FXImageFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXKnob[] = {{&_swigt__p_FXKnob, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXProgressBar[] = {{&_swigt__p_FXProgressBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeader[] = {{&_swigt__p_FXHeader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWell[] = {{&_swigt__p_FXColorWell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarTab[] = {{&_swigt__p_FXToolBarTab, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSlider[] = {{&_swigt__p_FXSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSlider[] = {{&_swigt__p_FXRealSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorRing[] = {{&_swigt__p_FXColorRing, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorBar[] = {{&_swigt__p_FXColorBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDrawable[] = {  {&_swigt__p_FXOption, _p_FXOptionTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTriStateButton, _p_FXTriStateButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToggleButton, _p_FXToggleButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRadioButton, _p_FXRadioButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMenuButton, _p_FXMenuButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXCheckButton, _p_FXCheckButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabItem, _p_FXTabItemTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXLabel, _p_FXLabelTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPicker, _p_FXPickerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXOptionMenu, _p_FXOptionMenuTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDrawable, 0, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXButton, _p_FXButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXDrawable, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFont[] = {  {&_swigt__p_FXFont, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFrame[] = {  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXFrame, 0, 0},  {&_swigt__p_FXFrame, 0, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXFrame, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXFrame, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXFrame, 0, 0},  {&_swigt__p_FXPicker, _p_FXPickerTo_p_FXFrame, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXFrame, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXFrame, 0, 0},  {&_swigt__p_FXCheckButton, _p_FXCheckButtonTo_p_FXFrame, 0, 0},  {&_swigt__p_FXMenuButton, _p_FXMenuButtonTo_p_FXFrame, 0, 0},  {&_swigt__p_FXRadioButton, _p_FXRadioButtonTo_p_FXFrame, 0, 0},  {&_swigt__p_FXTriStateButton, _p_FXTriStateButtonTo_p_FXFrame, 0, 0},  {&_swigt__p_FXToggleButton, _p_FXToggleButtonTo_p_FXFrame, 0, 0},  {&_swigt__p_FXLabel, _p_FXLabelTo_p_FXFrame, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXFrame, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXFrame, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXFrame, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXFrame, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXFrame, 0, 0},  {&_swigt__p_FXButton, _p_FXButtonTo_p_FXFrame, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXFrame, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXFrame, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXFrame, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXFrame, 0, 0},  {&_swigt__p_FXTabItem, _p_FXTabItemTo_p_FXFrame, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXFrame, 0, 0},  {&_swigt__p_FXOption, _p_FXOptionTo_p_FXFrame, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXFrame, 0, 0},  {&_swigt__p_FXOptionMenu, _p_FXOptionMenuTo_p_FXFrame, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXFrame, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXFrame, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXFrame, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXFrame, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIcon[] = {  {&_swigt__p_FXIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCURCursor[] = {{&_swigt__p_FXCURCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCursor[] = {{&_swigt__p_FXCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGIFCursor[] = {{&_swigt__p_FXGIFCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVisual[] = {{&_swigt__p_FXVisual, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXId[] = {  {&_swigt__p_FXOption, _p_FXOptionTo_p_FXId, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXId, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXId, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXId, 0, 0},  {&_swigt__p_FXId, 0, 0, 0},  {&_swigt__p_FXTriStateButton, _p_FXTriStateButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXToggleButton, _p_FXToggleButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXRadioButton, _p_FXRadioButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXCheckButton, _p_FXCheckButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXMenuButton, _p_FXMenuButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXId, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXId, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXId, 0, 0},  {&_swigt__p_FXTabItem, _p_FXTabItemTo_p_FXId, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXId, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXId, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXLabel, _p_FXLabelTo_p_FXId, 0, 0},  {&_swigt__p_FXPicker, _p_FXPickerTo_p_FXId, 0, 0},  {&_swigt__p_FXOptionMenu, _p_FXOptionMenuTo_p_FXId, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXId, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXId, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXId, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXId, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXId, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXId, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXButton, _p_FXButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXId, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXId, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXId, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXLabel[] = {  {&_swigt__p_FXOption, _p_FXOptionTo_p_FXLabel, 0, 0},  {&_swigt__p_FXLabel, 0, 0, 0},  {&_swigt__p_FXButton, _p_FXButtonTo_p_FXLabel, 0, 0},  {&_swigt__p_FXPicker, _p_FXPickerTo_p_FXLabel, 0, 0},  {&_swigt__p_FXTabItem, _p_FXTabItemTo_p_FXLabel, 0, 0},  {&_swigt__p_FXCheckButton, _p_FXCheckButtonTo_p_FXLabel, 0, 0},  {&_swigt__p_FXMenuButton, _p_FXMenuButtonTo_p_FXLabel, 0, 0},  {&_swigt__p_FXRadioButton, _p_FXRadioButtonTo_p_FXLabel, 0, 0},  {&_swigt__p_FXToggleButton, _p_FXToggleButtonTo_p_FXLabel, 0, 0},  {&_swigt__p_FXTriStateButton, _p_FXTriStateButtonTo_p_FXLabel, 0, 0},  {&_swigt__p_FXOptionMenu, _p_FXOptionMenuTo_p_FXLabel, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMenuButton[] = {  {&_swigt__p_FXMenuButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDict[] = {{&_swigt__p_FXDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSettings[] = {{&_swigt__p_FXSettings, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXAccelTable[] = {{&_swigt__p_FXAccelTable, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegistry[] = {{&_swigt__p_FXRegistry, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIconDict[] = {{&_swigt__p_FXIconDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRecentFiles[] = {{&_swigt__p_FXRecentFiles, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDocument[] = {{&_swigt__p_FXDocument, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStringDict[] = {{&_swigt__p_FXStringDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileDict[] = {{&_swigt__p_FXFileDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDataTarget[] = {{&_swigt__p_FXDataTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDebugTarget[] = {{&_swigt__p_FXDebugTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDelegator[] = {{&_swigt__p_FXDelegator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTranslator[] = {{&_swigt__p_FXTranslator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXApp[] = {{&_swigt__p_FXApp, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeaderItem[] = {{&_swigt__p_FXHeaderItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXObject[] = {  {&_swigt__p_FXDict, _p_FXDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXOption, _p_FXOptionTo_p_FXObject, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXObject, 0, 0},  {&_swigt__p_FXSettings, _p_FXSettingsTo_p_FXObject, 0, 0},  {&_swigt__p_FXAccelTable, _p_FXAccelTableTo_p_FXObject, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXObject, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXObject, 0, 0},  {&_swigt__p_FXRegistry, _p_FXRegistryTo_p_FXObject, 0, 0},  {&_swigt__p_FXId, _p_FXIdTo_p_FXObject, 0, 0},  {&_swigt__p_FXTriStateButton, _p_FXTriStateButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXToggleButton, _p_FXToggleButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXRadioButton, _p_FXRadioButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXMenuButton, _p_FXMenuButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXCheckButton, _p_FXCheckButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXIconDict, _p_FXIconDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXObject, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXObject, 0, 0},  {&_swigt__p_FXRecentFiles, _p_FXRecentFilesTo_p_FXObject, 0, 0},  {&_swigt__p_FXDocument, _p_FXDocumentTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabItem, _p_FXTabItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXObject, 0, 0, 0},  {&_swigt__p_FXStringDict, _p_FXStringDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXObject, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXLabel, _p_FXLabelTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileDict, _p_FXFileDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXPicker, _p_FXPickerTo_p_FXObject, 0, 0},  {&_swigt__p_FXDataTarget, _p_FXDataTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDebugTarget, _p_FXDebugTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXOptionMenu, _p_FXOptionMenuTo_p_FXObject, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXObject, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXObject, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXDelegator, _p_FXDelegatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXTranslator, _p_FXTranslatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXObject, 0, 0},  {&_swigt__p_FXApp, _p_FXAppTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeaderItem, _p_FXHeaderItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXObject, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXObject, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXButton, _p_FXButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXObject, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXOption[] = {  {&_swigt__p_FXOption, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXOptionMenu[] = {  {&_swigt__p_FXOptionMenu, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPicker[] = {  {&_swigt__p_FXPicker, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPopup[] = {  {&_swigt__p_FXPopup, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRadioButton[] = {  {&_swigt__p_FXRadioButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegion[] = {  {&_swigt__p_FXRegion, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileStream[] = {{&_swigt__p_FXFileStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMemoryStream[] = {{&_swigt__p_FXMemoryStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStream[] = {  {&_swigt__p_FXFileStream, _p_FXFileStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXMemoryStream, _p_FXMemoryStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabBar[] = {  {&_swigt__p_FXTabBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabItem[] = {  {&_swigt__p_FXTabItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToggleButton[] = {  {&_swigt__p_FXToggleButton, 0, 0, 0},  {&_swigt__p_FXTriStateButton, _p_FXTriStateButtonTo_p_FXToggleButton, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTriStateButton[] = {  {&_swigt__p_FXTriStateButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXWindow[] = {  {&_swigt__p_FXOption, _p_FXOptionTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXWindow, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTriStateButton, _p_FXTriStateButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToggleButton, _p_FXToggleButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRadioButton, _p_FXRadioButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMenuButton, _p_FXMenuButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXCheckButton, _p_FXCheckButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXWindow, 0, 0},  {&_swigt__p_FXWindow, 0, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTabItem, _p_FXTabItemTo_p_FXWindow, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXWindow, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXLabel, _p_FXLabelTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPicker, _p_FXPickerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXOptionMenu, _p_FXOptionMenuTo_p_FXWindow, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXWindow, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXButton, _p_FXButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXWindow, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
+
+static swig_cast_info *swig_cast_initial[] = {
+  _swigc__p_FXAccelTable,
+  _swigc__p_FXApp,
+  _swigc__p_FXArrowButton,
+  _swigc__p_FXBitmap,
+  _swigc__p_FXBitmapFrame,
+  _swigc__p_FXButton,
+  _swigc__p_FXCURCursor,
+  _swigc__p_FXCheckButton,
+  _swigc__p_FXColorBar,
+  _swigc__p_FXColorRing,
+  _swigc__p_FXColorWell,
+  _swigc__p_FXColorWheel,
+  _swigc__p_FXComposite,
+  _swigc__p_FXCursor,
+  _swigc__p_FXDataTarget,
+  _swigc__p_FXDebugTarget,
+  _swigc__p_FXDelegator,
+  _swigc__p_FXDial,
+  _swigc__p_FXDict,
+  _swigc__p_FXDocument,
+  _swigc__p_FXDrawable,
+  _swigc__p_FXFileDict,
+  _swigc__p_FXFileStream,
+  _swigc__p_FXFont,
+  _swigc__p_FXFrame,
+  _swigc__p_FXGIFCursor,
+  _swigc__p_FXGradientBar,
+  _swigc__p_FXHeader,
+  _swigc__p_FXHeaderItem,
+  _swigc__p_FXHorizontalSeparator,
+  _swigc__p_FXIcon,
+  _swigc__p_FXIconDict,
+  _swigc__p_FXId,
+  _swigc__p_FXImageFrame,
+  _swigc__p_FXKnob,
+  _swigc__p_FXLabel,
+  _swigc__p_FXMainWindow,
+  _swigc__p_FXMemoryStream,
+  _swigc__p_FXMenuButton,
+  _swigc__p_FXObject,
+  _swigc__p_FXOption,
+  _swigc__p_FXOptionMenu,
+  _swigc__p_FXPicker,
+  _swigc__p_FXPopup,
+  _swigc__p_FXProgressBar,
+  _swigc__p_FXRadioButton,
+  _swigc__p_FXRealSlider,
+  _swigc__p_FXRecentFiles,
+  _swigc__p_FXRegion,
+  _swigc__p_FXRegistry,
+  _swigc__p_FXRootWindow,
+  _swigc__p_FXRuler,
+  _swigc__p_FXSeparator,
+  _swigc__p_FXSettings,
+  _swigc__p_FXShell,
+  _swigc__p_FXSlider,
+  _swigc__p_FXSplashWindow,
+  _swigc__p_FXStatusLine,
+  _swigc__p_FXStream,
+  _swigc__p_FXStringDict,
+  _swigc__p_FXTabBar,
+  _swigc__p_FXTabItem,
+  _swigc__p_FXTextField,
+  _swigc__p_FXToggleButton,
+  _swigc__p_FXToolBarTab,
+  _swigc__p_FXTopWindow,
+  _swigc__p_FXTranslator,
+  _swigc__p_FXTriStateButton,
+  _swigc__p_FXVerticalSeparator,
+  _swigc__p_FXVisual,
+  _swigc__p_FXWindow,
+  _swigc__p_char,
+  _swigc__p_double,
+  _swigc__p_float,
+  _swigc__p_int,
+  _swigc__p_long,
+  _swigc__p_short,
+  _swigc__p_unsigned_char,
+  _swigc__p_unsigned_int,
+  _swigc__p_unsigned_long,
+  _swigc__p_unsigned_short,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned statically to an initial
+ * array. We just loop through that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded.
+ * There are three cases to handle:
+ *  1) If the cast->type has already been loaded AND the type we are adding
+ *     casting info to has not been loaded (it is in this module), THEN we
+ *     replace the cast->type pointer with the type pointer that has already
+ *     been loaded.
+ *  2) If BOTH types (the one we are adding casting info to, and the
+ *     cast->type) are loaded, THEN the cast info has already been loaded by
+ *     the previous module so we just ignore it.
+ *  3) Finally, if cast->type has not already been loaded, then we add that
+ *     swig_cast_info to the linked list (because the cast->type) pointer will
+ *     be correct.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* c-mode */
+#endif
+#endif
+
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+  size_t i;
+  swig_module_info *module_head, *iter;
+  int init;
+
+  /* check to see if the circular list has been setup, if not, set it up */
+  if (swig_module.next==0) {
+    /* Initialize the swig_module */
+    swig_module.type_initial = swig_type_initial;
+    swig_module.cast_initial = swig_cast_initial;
+    swig_module.next = &swig_module;
+    init = 1;
+  } else {
+    init = 0;
+  }
+
+  /* Try and load any already created modules */
+  module_head = SWIG_GetModule(clientdata);
+  if (!module_head) {
+    /* This is the first module loaded for this interpreter */
+    /* so set the swig module into the interpreter */
+    SWIG_SetModule(clientdata, &swig_module);
+  } else {
+    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+    iter=module_head;
+    do {
+      if (iter==&swig_module) {
+        /* Our module is already in the list, so there's nothing more to do. */
+        return;
+      }
+      iter=iter->next;
+    } while (iter!= module_head);
+
+    /* otherwise we must add our module into the list */
+    swig_module.next = module_head->next;
+    module_head->next = &swig_module;
+  }
+
+  /* When multiple interpreters are used, a module could have already been initialized in
+     a different interpreter, but not yet have a pointer in this interpreter.
+     In this case, we do not want to continue adding types... everything should be
+     set up already */
+  if (init == 0) return;
+
+  /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+  for (i = 0; i < swig_module.size; ++i) {
+    swig_type_info *type = 0;
+    swig_type_info *ret;
+    swig_cast_info *cast;
+
+#ifdef SWIGRUNTIME_DEBUG
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+
+    /* if there is another module already loaded */
+    if (swig_module.next != &swig_module) {
+      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
+    }
+    if (type) {
+      /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+      if (swig_module.type_initial[i]->clientdata) {
+	type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+      }
+    } else {
+      type = swig_module.type_initial[i];
+    }
+
+    /* Insert casting types */
+    cast = swig_module.cast_initial[i];
+    while (cast->type) {
+
+      /* Don't need to add information already in the list */
+      ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+      if (swig_module.next != &swig_module) {
+        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+      }
+      if (ret) {
+	if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+	  cast->type = ret;
+	  ret = 0;
+	} else {
+	  /* Check for casting already in the list */
+	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+	  if (!ocast) ret = 0;
+	}
+      }
+
+      if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+        if (type->cast) {
+          type->cast->prev = cast;
+          cast->next = type->cast;
+        }
+        type->cast = cast;
+      }
+      cast++;
+    }
+    /* Set entry in modules->types array equal to the type */
+    swig_module.types[i] = type;
+  }
+  swig_module.types[i] = 0;
+
+#ifdef SWIGRUNTIME_DEBUG
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+  for (i = 0; i < swig_module.size; ++i) {
+    int j = 0;
+    swig_cast_info *cast = swig_module.cast_initial[i];
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    while (cast->type) {
+      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+      cast++;
+      ++j;
+    }
+  printf("---- Total casts: %d\n",j);
+  }
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types.  It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+  size_t i;
+  swig_cast_info *equiv;
+  static int init_run = 0;
+
+  if (init_run) return;
+  init_run = 1;
+
+  for (i = 0; i < swig_module.size; i++) {
+    if (swig_module.types[i]->clientdata) {
+      equiv = swig_module.types[i]->cast;
+      while (equiv) {
+        if (!equiv->converter) {
+          if (equiv->type && !equiv->type->clientdata)
+            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+        }
+        equiv = equiv->next;
+      }
+    }
+  }
+}
+
+#ifdef __cplusplus
+#if 0
+{ /* c-mode */
+#endif
+}
+#endif
+
+/*
+
+*/
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void Init_label(void) {
+  size_t i;
+  
+  SWIG_InitRuntime();
+  
+  
+  SWIG_InitializeModule(0);
+  for (i = 0; i < swig_module.size; i++) {
+    SWIG_define_class(swig_module.types[i]);
+  }
+  
+  SWIG_RubyInitializeTrackings();
+  
+  
+  rb_define_const(mFox, "ICON_UNDER_TEXT", SWIG_From_int(static_cast< int >(ICON_UNDER_TEXT)));
+  rb_define_const(mFox, "ICON_AFTER_TEXT", SWIG_From_int(static_cast< int >(ICON_AFTER_TEXT)));
+  rb_define_const(mFox, "ICON_BEFORE_TEXT", SWIG_From_int(static_cast< int >(ICON_BEFORE_TEXT)));
+  rb_define_const(mFox, "ICON_ABOVE_TEXT", SWIG_From_int(static_cast< int >(ICON_ABOVE_TEXT)));
+  rb_define_const(mFox, "ICON_BELOW_TEXT", SWIG_From_int(static_cast< int >(ICON_BELOW_TEXT)));
+  rb_define_const(mFox, "TEXT_OVER_ICON", SWIG_From_int(static_cast< int >(TEXT_OVER_ICON)));
+  rb_define_const(mFox, "TEXT_AFTER_ICON", SWIG_From_int(static_cast< int >(TEXT_AFTER_ICON)));
+  rb_define_const(mFox, "TEXT_BEFORE_ICON", SWIG_From_int(static_cast< int >(TEXT_BEFORE_ICON)));
+  rb_define_const(mFox, "TEXT_ABOVE_ICON", SWIG_From_int(static_cast< int >(TEXT_ABOVE_ICON)));
+  rb_define_const(mFox, "TEXT_BELOW_ICON", SWIG_From_int(static_cast< int >(TEXT_BELOW_ICON)));
+  rb_define_const(mFox, "LABEL_NORMAL", SWIG_From_int(static_cast< int >(LABEL_NORMAL)));
+  
+  SwigClassFXLabel.klass = rb_define_class_under(mFox, "FXLabel", ((swig_class *) SWIGTYPE_p_FXFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXLabel, (void *) &SwigClassFXLabel);
+  rb_define_alloc_func(SwigClassFXLabel.klass, _wrap_FXLabel_allocate);
+  rb_define_method(SwigClassFXLabel.klass, "initialize", VALUEFUNC(_wrap_new_FXLabel), -1);
+  rb_define_method(SwigClassFXLabel.klass, "onPaint", VALUEFUNC(_wrap_FXLabel_onPaint), -1);
+  rb_define_method(SwigClassFXLabel.klass, "onHotKeyPress", VALUEFUNC(_wrap_FXLabel_onHotKeyPress), -1);
+  rb_define_method(SwigClassFXLabel.klass, "onHotKeyRelease", VALUEFUNC(_wrap_FXLabel_onHotKeyRelease), -1);
+  rb_define_method(SwigClassFXLabel.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXLabel_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXLabel.klass, "onCmdSetStringValue", VALUEFUNC(_wrap_FXLabel_onCmdSetStringValue), -1);
+  rb_define_method(SwigClassFXLabel.klass, "onCmdGetStringValue", VALUEFUNC(_wrap_FXLabel_onCmdGetStringValue), -1);
+  rb_define_method(SwigClassFXLabel.klass, "onCmdSetIconValue", VALUEFUNC(_wrap_FXLabel_onCmdSetIconValue), -1);
+  rb_define_method(SwigClassFXLabel.klass, "onCmdGetIconValue", VALUEFUNC(_wrap_FXLabel_onCmdGetIconValue), -1);
+  rb_define_method(SwigClassFXLabel.klass, "onCmdSetHelp", VALUEFUNC(_wrap_FXLabel_onCmdSetHelp), -1);
+  rb_define_method(SwigClassFXLabel.klass, "onCmdGetHelp", VALUEFUNC(_wrap_FXLabel_onCmdGetHelp), -1);
+  rb_define_method(SwigClassFXLabel.klass, "onCmdSetTip", VALUEFUNC(_wrap_FXLabel_onCmdSetTip), -1);
+  rb_define_method(SwigClassFXLabel.klass, "onCmdGetTip", VALUEFUNC(_wrap_FXLabel_onCmdGetTip), -1);
+  rb_define_method(SwigClassFXLabel.klass, "onQueryHelp", VALUEFUNC(_wrap_FXLabel_onQueryHelp), -1);
+  rb_define_method(SwigClassFXLabel.klass, "onQueryTip", VALUEFUNC(_wrap_FXLabel_onQueryTip), -1);
+  rb_define_method(SwigClassFXLabel.klass, "setText", VALUEFUNC(_wrap_FXLabel_setText), -1);
+  rb_define_method(SwigClassFXLabel.klass, "getText", VALUEFUNC(_wrap_FXLabel_getText), -1);
+  rb_define_method(SwigClassFXLabel.klass, "setIcon", VALUEFUNC(_wrap_FXLabel_setIcon), -1);
+  rb_define_method(SwigClassFXLabel.klass, "getIcon", VALUEFUNC(_wrap_FXLabel_getIcon), -1);
+  rb_define_method(SwigClassFXLabel.klass, "setFont", VALUEFUNC(_wrap_FXLabel_setFont), -1);
+  rb_define_method(SwigClassFXLabel.klass, "getFont", VALUEFUNC(_wrap_FXLabel_getFont), -1);
+  rb_define_method(SwigClassFXLabel.klass, "getTextColor", VALUEFUNC(_wrap_FXLabel_getTextColor), -1);
+  rb_define_method(SwigClassFXLabel.klass, "setTextColor", VALUEFUNC(_wrap_FXLabel_setTextColor), -1);
+  rb_define_method(SwigClassFXLabel.klass, "setJustify", VALUEFUNC(_wrap_FXLabel_setJustify), -1);
+  rb_define_method(SwigClassFXLabel.klass, "getJustify", VALUEFUNC(_wrap_FXLabel_getJustify), -1);
+  rb_define_method(SwigClassFXLabel.klass, "setIconPosition", VALUEFUNC(_wrap_FXLabel_setIconPosition), -1);
+  rb_define_method(SwigClassFXLabel.klass, "getIconPosition", VALUEFUNC(_wrap_FXLabel_getIconPosition), -1);
+  rb_define_method(SwigClassFXLabel.klass, "setHelpText", VALUEFUNC(_wrap_FXLabel_setHelpText), -1);
+  rb_define_method(SwigClassFXLabel.klass, "getHelpText", VALUEFUNC(_wrap_FXLabel_getHelpText), -1);
+  rb_define_method(SwigClassFXLabel.klass, "setTipText", VALUEFUNC(_wrap_FXLabel_setTipText), -1);
+  rb_define_method(SwigClassFXLabel.klass, "getTipText", VALUEFUNC(_wrap_FXLabel_getTipText), -1);
+  rb_define_method(SwigClassFXLabel.klass, "save", VALUEFUNC(_wrap_FXLabel_save), -1);
+  rb_define_method(SwigClassFXLabel.klass, "load", VALUEFUNC(_wrap_FXLabel_load), -1);
+  rb_define_method(SwigClassFXLabel.klass, "create", VALUEFUNC(_wrap_FXLabel_create), -1);
+  rb_define_method(SwigClassFXLabel.klass, "detach", VALUEFUNC(_wrap_FXLabel_detach), -1);
+  rb_define_method(SwigClassFXLabel.klass, "destroy", VALUEFUNC(_wrap_FXLabel_destroy), -1);
+  rb_define_method(SwigClassFXLabel.klass, "resize", VALUEFUNC(_wrap_FXLabel_resize), -1);
+  rb_define_method(SwigClassFXLabel.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXLabel_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXLabel.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXLabel_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXLabel.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXLabel_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXLabel.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXLabel_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXLabel.klass, "canFocus", VALUEFUNC(_wrap_FXLabel_canFocus), -1);
+  rb_define_method(SwigClassFXLabel.klass, "setFocus", VALUEFUNC(_wrap_FXLabel_setFocus), -1);
+  rb_define_method(SwigClassFXLabel.klass, "killFocus", VALUEFUNC(_wrap_FXLabel_killFocus), -1);
+  rb_define_method(SwigClassFXLabel.klass, "changeFocus", VALUEFUNC(_wrap_FXLabel_changeFocus), -1);
+  rb_define_method(SwigClassFXLabel.klass, "setDefault", VALUEFUNC(_wrap_FXLabel_setDefault), -1);
+  rb_define_method(SwigClassFXLabel.klass, "enable", VALUEFUNC(_wrap_FXLabel_enable), -1);
+  rb_define_method(SwigClassFXLabel.klass, "disable", VALUEFUNC(_wrap_FXLabel_disable), -1);
+  rb_define_method(SwigClassFXLabel.klass, "raiseWindow", VALUEFUNC(_wrap_FXLabel_raiseWindow), -1);
+  rb_define_method(SwigClassFXLabel.klass, "lower", VALUEFUNC(_wrap_FXLabel_lower), -1);
+  rb_define_method(SwigClassFXLabel.klass, "move", VALUEFUNC(_wrap_FXLabel_move), -1);
+  rb_define_method(SwigClassFXLabel.klass, "position", VALUEFUNC(_wrap_FXLabel_position), -1);
+  rb_define_method(SwigClassFXLabel.klass, "layout", VALUEFUNC(_wrap_FXLabel_layout), -1);
+  rb_define_method(SwigClassFXLabel.klass, "recalc", VALUEFUNC(_wrap_FXLabel_recalc), -1);
+  rb_define_method(SwigClassFXLabel.klass, "reparent", VALUEFUNC(_wrap_FXLabel_reparent), -1);
+  rb_define_method(SwigClassFXLabel.klass, "show", VALUEFUNC(_wrap_FXLabel_show), -1);
+  rb_define_method(SwigClassFXLabel.klass, "hide", VALUEFUNC(_wrap_FXLabel_hide), -1);
+  rb_define_method(SwigClassFXLabel.klass, "isComposite", VALUEFUNC(_wrap_FXLabel_isComposite), -1);
+  rb_define_method(SwigClassFXLabel.klass, "contains", VALUEFUNC(_wrap_FXLabel_contains), -1);
+  rb_define_method(SwigClassFXLabel.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXLabel_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXLabel.klass, "setBackColor", VALUEFUNC(_wrap_FXLabel_setBackColor), -1);
+  rb_define_method(SwigClassFXLabel.klass, "tr", VALUEFUNC(_wrap_FXLabel_tr), -1);
+  rb_define_method(SwigClassFXLabel.klass, "dropEnable", VALUEFUNC(_wrap_FXLabel_dropEnable), -1);
+  rb_define_method(SwigClassFXLabel.klass, "dropDisable", VALUEFUNC(_wrap_FXLabel_dropDisable), -1);
+  rb_define_method(SwigClassFXLabel.klass, "setShape", VALUEFUNC(_wrap_FXLabel_setShape), -1);
+  rb_define_method(SwigClassFXLabel.klass, "clearShape", VALUEFUNC(_wrap_FXLabel_clearShape), -1);
+  SwigClassFXLabel.mark = (void (*)(void *)) FXRbLabel::markfunc;
+  SwigClassFXLabel.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXLabel.trackObjects = 0;
+  
+  SWIGTYPE_p_FXLabel->dcast = (swig_dycast_func) FXLabel_dynamic_cast;
+  
+  rb_define_const(mFox, "STATE_UP", SWIG_From_int(static_cast< int >(STATE_UP)));
+  rb_define_const(mFox, "STATE_DOWN", SWIG_From_int(static_cast< int >(STATE_DOWN)));
+  rb_define_const(mFox, "STATE_ENGAGED", SWIG_From_int(static_cast< int >(STATE_ENGAGED)));
+  rb_define_const(mFox, "STATE_UNCHECKED", SWIG_From_int(static_cast< int >(STATE_UNCHECKED)));
+  rb_define_const(mFox, "STATE_CHECKED", SWIG_From_int(static_cast< int >(STATE_CHECKED)));
+  rb_define_const(mFox, "BUTTON_AUTOGRAY", SWIG_From_int(static_cast< int >(BUTTON_AUTOGRAY)));
+  rb_define_const(mFox, "BUTTON_AUTOHIDE", SWIG_From_int(static_cast< int >(BUTTON_AUTOHIDE)));
+  rb_define_const(mFox, "BUTTON_TOOLBAR", SWIG_From_int(static_cast< int >(BUTTON_TOOLBAR)));
+  rb_define_const(mFox, "BUTTON_DEFAULT", SWIG_From_int(static_cast< int >(BUTTON_DEFAULT)));
+  rb_define_const(mFox, "BUTTON_INITIAL", SWIG_From_int(static_cast< int >(BUTTON_INITIAL)));
+  rb_define_const(mFox, "BUTTON_NORMAL", SWIG_From_int(static_cast< int >(BUTTON_NORMAL)));
+  
+  SwigClassFXButton.klass = rb_define_class_under(mFox, "FXButton", ((swig_class *) SWIGTYPE_p_FXLabel->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXButton, (void *) &SwigClassFXButton);
+  rb_define_alloc_func(SwigClassFXButton.klass, _wrap_FXButton_allocate);
+  rb_define_method(SwigClassFXButton.klass, "initialize", VALUEFUNC(_wrap_new_FXButton), -1);
+  rb_define_method(SwigClassFXButton.klass, "onPaint", VALUEFUNC(_wrap_FXButton_onPaint), -1);
+  rb_define_method(SwigClassFXButton.klass, "onUpdate", VALUEFUNC(_wrap_FXButton_onUpdate), -1);
+  rb_define_method(SwigClassFXButton.klass, "onEnter", VALUEFUNC(_wrap_FXButton_onEnter), -1);
+  rb_define_method(SwigClassFXButton.klass, "onLeave", VALUEFUNC(_wrap_FXButton_onLeave), -1);
+  rb_define_method(SwigClassFXButton.klass, "onFocusIn", VALUEFUNC(_wrap_FXButton_onFocusIn), -1);
+  rb_define_method(SwigClassFXButton.klass, "onFocusOut", VALUEFUNC(_wrap_FXButton_onFocusOut), -1);
+  rb_define_method(SwigClassFXButton.klass, "onUngrabbed", VALUEFUNC(_wrap_FXButton_onUngrabbed), -1);
+  rb_define_method(SwigClassFXButton.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXButton_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXButton.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXButton_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXButton.klass, "onKeyPress", VALUEFUNC(_wrap_FXButton_onKeyPress), -1);
+  rb_define_method(SwigClassFXButton.klass, "onKeyRelease", VALUEFUNC(_wrap_FXButton_onKeyRelease), -1);
+  rb_define_method(SwigClassFXButton.klass, "onHotKeyPress", VALUEFUNC(_wrap_FXButton_onHotKeyPress), -1);
+  rb_define_method(SwigClassFXButton.klass, "onHotKeyRelease", VALUEFUNC(_wrap_FXButton_onHotKeyRelease), -1);
+  rb_define_method(SwigClassFXButton.klass, "onCheck", VALUEFUNC(_wrap_FXButton_onCheck), -1);
+  rb_define_method(SwigClassFXButton.klass, "onUncheck", VALUEFUNC(_wrap_FXButton_onUncheck), -1);
+  rb_define_method(SwigClassFXButton.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXButton_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXButton.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXButton_onCmdSetIntValue), -1);
+  rb_define_method(SwigClassFXButton.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXButton_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXButton.klass, "setState", VALUEFUNC(_wrap_FXButton_setState), -1);
+  rb_define_method(SwigClassFXButton.klass, "getState", VALUEFUNC(_wrap_FXButton_getState), -1);
+  rb_define_method(SwigClassFXButton.klass, "setButtonStyle", VALUEFUNC(_wrap_FXButton_setButtonStyle), -1);
+  rb_define_method(SwigClassFXButton.klass, "getButtonStyle", VALUEFUNC(_wrap_FXButton_getButtonStyle), -1);
+  rb_define_method(SwigClassFXButton.klass, "save", VALUEFUNC(_wrap_FXButton_save), -1);
+  rb_define_method(SwigClassFXButton.klass, "load", VALUEFUNC(_wrap_FXButton_load), -1);
+  rb_define_method(SwigClassFXButton.klass, "create", VALUEFUNC(_wrap_FXButton_create), -1);
+  rb_define_method(SwigClassFXButton.klass, "detach", VALUEFUNC(_wrap_FXButton_detach), -1);
+  rb_define_method(SwigClassFXButton.klass, "destroy", VALUEFUNC(_wrap_FXButton_destroy), -1);
+  rb_define_method(SwigClassFXButton.klass, "resize", VALUEFUNC(_wrap_FXButton_resize), -1);
+  rb_define_method(SwigClassFXButton.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXButton_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXButton.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXButton_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXButton.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXButton_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXButton.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXButton_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXButton.klass, "canFocus", VALUEFUNC(_wrap_FXButton_canFocus), -1);
+  rb_define_method(SwigClassFXButton.klass, "setFocus", VALUEFUNC(_wrap_FXButton_setFocus), -1);
+  rb_define_method(SwigClassFXButton.klass, "killFocus", VALUEFUNC(_wrap_FXButton_killFocus), -1);
+  rb_define_method(SwigClassFXButton.klass, "changeFocus", VALUEFUNC(_wrap_FXButton_changeFocus), -1);
+  rb_define_method(SwigClassFXButton.klass, "setDefault", VALUEFUNC(_wrap_FXButton_setDefault), -1);
+  rb_define_method(SwigClassFXButton.klass, "enable", VALUEFUNC(_wrap_FXButton_enable), -1);
+  rb_define_method(SwigClassFXButton.klass, "disable", VALUEFUNC(_wrap_FXButton_disable), -1);
+  rb_define_method(SwigClassFXButton.klass, "raiseWindow", VALUEFUNC(_wrap_FXButton_raiseWindow), -1);
+  rb_define_method(SwigClassFXButton.klass, "lower", VALUEFUNC(_wrap_FXButton_lower), -1);
+  rb_define_method(SwigClassFXButton.klass, "move", VALUEFUNC(_wrap_FXButton_move), -1);
+  rb_define_method(SwigClassFXButton.klass, "position", VALUEFUNC(_wrap_FXButton_position), -1);
+  rb_define_method(SwigClassFXButton.klass, "layout", VALUEFUNC(_wrap_FXButton_layout), -1);
+  rb_define_method(SwigClassFXButton.klass, "recalc", VALUEFUNC(_wrap_FXButton_recalc), -1);
+  rb_define_method(SwigClassFXButton.klass, "reparent", VALUEFUNC(_wrap_FXButton_reparent), -1);
+  rb_define_method(SwigClassFXButton.klass, "show", VALUEFUNC(_wrap_FXButton_show), -1);
+  rb_define_method(SwigClassFXButton.klass, "hide", VALUEFUNC(_wrap_FXButton_hide), -1);
+  rb_define_method(SwigClassFXButton.klass, "isComposite", VALUEFUNC(_wrap_FXButton_isComposite), -1);
+  rb_define_method(SwigClassFXButton.klass, "contains", VALUEFUNC(_wrap_FXButton_contains), -1);
+  rb_define_method(SwigClassFXButton.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXButton_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXButton.klass, "setBackColor", VALUEFUNC(_wrap_FXButton_setBackColor), -1);
+  rb_define_method(SwigClassFXButton.klass, "tr", VALUEFUNC(_wrap_FXButton_tr), -1);
+  rb_define_method(SwigClassFXButton.klass, "dropEnable", VALUEFUNC(_wrap_FXButton_dropEnable), -1);
+  rb_define_method(SwigClassFXButton.klass, "dropDisable", VALUEFUNC(_wrap_FXButton_dropDisable), -1);
+  rb_define_method(SwigClassFXButton.klass, "setShape", VALUEFUNC(_wrap_FXButton_setShape), -1);
+  rb_define_method(SwigClassFXButton.klass, "clearShape", VALUEFUNC(_wrap_FXButton_clearShape), -1);
+  SwigClassFXButton.mark = (void (*)(void *)) FXRbButton::markfunc;
+  SwigClassFXButton.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXButton.trackObjects = 0;
+  
+  SWIGTYPE_p_FXButton->dcast = (swig_dycast_func) FXButton_dynamic_cast;
+  
+  rb_define_const(mFox, "CHECKBUTTON_AUTOGRAY", SWIG_From_int(static_cast< int >(CHECKBUTTON_AUTOGRAY)));
+  rb_define_const(mFox, "CHECKBUTTON_AUTOHIDE", SWIG_From_int(static_cast< int >(CHECKBUTTON_AUTOHIDE)));
+  rb_define_const(mFox, "CHECKBUTTON_PLUS", SWIG_From_int(static_cast< int >(CHECKBUTTON_PLUS)));
+  rb_define_const(mFox, "CHECKBUTTON_NORMAL", SWIG_From_int(static_cast< int >(CHECKBUTTON_NORMAL)));
+  
+  SwigClassFXCheckButton.klass = rb_define_class_under(mFox, "FXCheckButton", ((swig_class *) SWIGTYPE_p_FXLabel->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXCheckButton, (void *) &SwigClassFXCheckButton);
+  rb_define_alloc_func(SwigClassFXCheckButton.klass, _wrap_FXCheckButton_allocate);
+  rb_define_method(SwigClassFXCheckButton.klass, "initialize", VALUEFUNC(_wrap_new_FXCheckButton), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "onPaint", VALUEFUNC(_wrap_FXCheckButton_onPaint), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "onUpdate", VALUEFUNC(_wrap_FXCheckButton_onUpdate), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "onEnter", VALUEFUNC(_wrap_FXCheckButton_onEnter), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "onLeave", VALUEFUNC(_wrap_FXCheckButton_onLeave), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "onFocusIn", VALUEFUNC(_wrap_FXCheckButton_onFocusIn), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "onFocusOut", VALUEFUNC(_wrap_FXCheckButton_onFocusOut), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "onUngrabbed", VALUEFUNC(_wrap_FXCheckButton_onUngrabbed), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXCheckButton_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXCheckButton_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "onKeyPress", VALUEFUNC(_wrap_FXCheckButton_onKeyPress), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "onKeyRelease", VALUEFUNC(_wrap_FXCheckButton_onKeyRelease), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "onHotKeyPress", VALUEFUNC(_wrap_FXCheckButton_onHotKeyPress), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "onHotKeyRelease", VALUEFUNC(_wrap_FXCheckButton_onHotKeyRelease), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "onCheck", VALUEFUNC(_wrap_FXCheckButton_onCheck), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "onUncheck", VALUEFUNC(_wrap_FXCheckButton_onUncheck), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "onUnknown", VALUEFUNC(_wrap_FXCheckButton_onUnknown), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXCheckButton_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXCheckButton_onCmdSetIntValue), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXCheckButton_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "setCheck", VALUEFUNC(_wrap_FXCheckButton_setCheck), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "getCheck", VALUEFUNC(_wrap_FXCheckButton_getCheck), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "getCheckState", VALUEFUNC(_wrap_FXCheckButton_getCheckState), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "setCheckButtonStyle", VALUEFUNC(_wrap_FXCheckButton_setCheckButtonStyle), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "getCheckButtonStyle", VALUEFUNC(_wrap_FXCheckButton_getCheckButtonStyle), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "getBoxColor", VALUEFUNC(_wrap_FXCheckButton_getBoxColor), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "setBoxColor", VALUEFUNC(_wrap_FXCheckButton_setBoxColor), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "getCheckColor", VALUEFUNC(_wrap_FXCheckButton_getCheckColor), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "setCheckColor", VALUEFUNC(_wrap_FXCheckButton_setCheckColor), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "save", VALUEFUNC(_wrap_FXCheckButton_save), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "load", VALUEFUNC(_wrap_FXCheckButton_load), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "create", VALUEFUNC(_wrap_FXCheckButton_create), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "detach", VALUEFUNC(_wrap_FXCheckButton_detach), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "destroy", VALUEFUNC(_wrap_FXCheckButton_destroy), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "resize", VALUEFUNC(_wrap_FXCheckButton_resize), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXCheckButton_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXCheckButton_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXCheckButton_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXCheckButton_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "canFocus", VALUEFUNC(_wrap_FXCheckButton_canFocus), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "setFocus", VALUEFUNC(_wrap_FXCheckButton_setFocus), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "killFocus", VALUEFUNC(_wrap_FXCheckButton_killFocus), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "changeFocus", VALUEFUNC(_wrap_FXCheckButton_changeFocus), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "setDefault", VALUEFUNC(_wrap_FXCheckButton_setDefault), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "enable", VALUEFUNC(_wrap_FXCheckButton_enable), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "disable", VALUEFUNC(_wrap_FXCheckButton_disable), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "raiseWindow", VALUEFUNC(_wrap_FXCheckButton_raiseWindow), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "lower", VALUEFUNC(_wrap_FXCheckButton_lower), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "move", VALUEFUNC(_wrap_FXCheckButton_move), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "position", VALUEFUNC(_wrap_FXCheckButton_position), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "layout", VALUEFUNC(_wrap_FXCheckButton_layout), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "recalc", VALUEFUNC(_wrap_FXCheckButton_recalc), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "reparent", VALUEFUNC(_wrap_FXCheckButton_reparent), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "show", VALUEFUNC(_wrap_FXCheckButton_show), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "hide", VALUEFUNC(_wrap_FXCheckButton_hide), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "isComposite", VALUEFUNC(_wrap_FXCheckButton_isComposite), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "contains", VALUEFUNC(_wrap_FXCheckButton_contains), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXCheckButton_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "setBackColor", VALUEFUNC(_wrap_FXCheckButton_setBackColor), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "tr", VALUEFUNC(_wrap_FXCheckButton_tr), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "dropEnable", VALUEFUNC(_wrap_FXCheckButton_dropEnable), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "dropDisable", VALUEFUNC(_wrap_FXCheckButton_dropDisable), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "setShape", VALUEFUNC(_wrap_FXCheckButton_setShape), -1);
+  rb_define_method(SwigClassFXCheckButton.klass, "clearShape", VALUEFUNC(_wrap_FXCheckButton_clearShape), -1);
+  SwigClassFXCheckButton.mark = (void (*)(void *)) FXRbCheckButton::markfunc;
+  SwigClassFXCheckButton.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXCheckButton.trackObjects = 0;
+  rb_define_const(mFox, "MENUBUTTON_AUTOGRAY", SWIG_From_int(static_cast< int >(MENUBUTTON_AUTOGRAY)));
+  rb_define_const(mFox, "MENUBUTTON_AUTOHIDE", SWIG_From_int(static_cast< int >(MENUBUTTON_AUTOHIDE)));
+  rb_define_const(mFox, "MENUBUTTON_TOOLBAR", SWIG_From_int(static_cast< int >(MENUBUTTON_TOOLBAR)));
+  rb_define_const(mFox, "MENUBUTTON_DOWN", SWIG_From_int(static_cast< int >(MENUBUTTON_DOWN)));
+  rb_define_const(mFox, "MENUBUTTON_UP", SWIG_From_int(static_cast< int >(MENUBUTTON_UP)));
+  rb_define_const(mFox, "MENUBUTTON_LEFT", SWIG_From_int(static_cast< int >(MENUBUTTON_LEFT)));
+  rb_define_const(mFox, "MENUBUTTON_RIGHT", SWIG_From_int(static_cast< int >(MENUBUTTON_RIGHT)));
+  rb_define_const(mFox, "MENUBUTTON_NOARROWS", SWIG_From_int(static_cast< int >(MENUBUTTON_NOARROWS)));
+  rb_define_const(mFox, "MENUBUTTON_ATTACH_LEFT", SWIG_From_int(static_cast< int >(MENUBUTTON_ATTACH_LEFT)));
+  rb_define_const(mFox, "MENUBUTTON_ATTACH_TOP", SWIG_From_int(static_cast< int >(MENUBUTTON_ATTACH_TOP)));
+  rb_define_const(mFox, "MENUBUTTON_ATTACH_RIGHT", SWIG_From_int(static_cast< int >(MENUBUTTON_ATTACH_RIGHT)));
+  rb_define_const(mFox, "MENUBUTTON_ATTACH_BOTTOM", SWIG_From_int(static_cast< int >(MENUBUTTON_ATTACH_BOTTOM)));
+  rb_define_const(mFox, "MENUBUTTON_ATTACH_CENTER", SWIG_From_int(static_cast< int >(MENUBUTTON_ATTACH_CENTER)));
+  rb_define_const(mFox, "MENUBUTTON_ATTACH_BOTH", SWIG_From_int(static_cast< int >(MENUBUTTON_ATTACH_BOTH)));
+  
+  SwigClassFXMenuButton.klass = rb_define_class_under(mFox, "FXMenuButton", ((swig_class *) SWIGTYPE_p_FXLabel->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMenuButton, (void *) &SwigClassFXMenuButton);
+  rb_define_alloc_func(SwigClassFXMenuButton.klass, _wrap_FXMenuButton_allocate);
+  rb_define_method(SwigClassFXMenuButton.klass, "initialize", VALUEFUNC(_wrap_new_FXMenuButton), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "onPaint", VALUEFUNC(_wrap_FXMenuButton_onPaint), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "onUpdate", VALUEFUNC(_wrap_FXMenuButton_onUpdate), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "onEnter", VALUEFUNC(_wrap_FXMenuButton_onEnter), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "onLeave", VALUEFUNC(_wrap_FXMenuButton_onLeave), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "onFocusIn", VALUEFUNC(_wrap_FXMenuButton_onFocusIn), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "onFocusOut", VALUEFUNC(_wrap_FXMenuButton_onFocusOut), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "onUngrabbed", VALUEFUNC(_wrap_FXMenuButton_onUngrabbed), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "onMotion", VALUEFUNC(_wrap_FXMenuButton_onMotion), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXMenuButton_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXMenuButton_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "onKeyPress", VALUEFUNC(_wrap_FXMenuButton_onKeyPress), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "onKeyRelease", VALUEFUNC(_wrap_FXMenuButton_onKeyRelease), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "onHotKeyPress", VALUEFUNC(_wrap_FXMenuButton_onHotKeyPress), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "onHotKeyRelease", VALUEFUNC(_wrap_FXMenuButton_onHotKeyRelease), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "onCmdPost", VALUEFUNC(_wrap_FXMenuButton_onCmdPost), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "onCmdUnpost", VALUEFUNC(_wrap_FXMenuButton_onCmdUnpost), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "setMenu", VALUEFUNC(_wrap_FXMenuButton_setMenu), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "getMenu", VALUEFUNC(_wrap_FXMenuButton_getMenu), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "setXOffset", VALUEFUNC(_wrap_FXMenuButton_setXOffset), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "getXOffset", VALUEFUNC(_wrap_FXMenuButton_getXOffset), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "setYOffset", VALUEFUNC(_wrap_FXMenuButton_setYOffset), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "getYOffset", VALUEFUNC(_wrap_FXMenuButton_getYOffset), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "setButtonStyle", VALUEFUNC(_wrap_FXMenuButton_setButtonStyle), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "getButtonStyle", VALUEFUNC(_wrap_FXMenuButton_getButtonStyle), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "setPopupStyle", VALUEFUNC(_wrap_FXMenuButton_setPopupStyle), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "getPopupStyle", VALUEFUNC(_wrap_FXMenuButton_getPopupStyle), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "setAttachment", VALUEFUNC(_wrap_FXMenuButton_setAttachment), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "getAttachment", VALUEFUNC(_wrap_FXMenuButton_getAttachment), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "save", VALUEFUNC(_wrap_FXMenuButton_save), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "load", VALUEFUNC(_wrap_FXMenuButton_load), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "create", VALUEFUNC(_wrap_FXMenuButton_create), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "detach", VALUEFUNC(_wrap_FXMenuButton_detach), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "destroy", VALUEFUNC(_wrap_FXMenuButton_destroy), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "resize", VALUEFUNC(_wrap_FXMenuButton_resize), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXMenuButton_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXMenuButton_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXMenuButton_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXMenuButton_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "canFocus", VALUEFUNC(_wrap_FXMenuButton_canFocus), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "setFocus", VALUEFUNC(_wrap_FXMenuButton_setFocus), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "killFocus", VALUEFUNC(_wrap_FXMenuButton_killFocus), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "changeFocus", VALUEFUNC(_wrap_FXMenuButton_changeFocus), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "setDefault", VALUEFUNC(_wrap_FXMenuButton_setDefault), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "enable", VALUEFUNC(_wrap_FXMenuButton_enable), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "disable", VALUEFUNC(_wrap_FXMenuButton_disable), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "raiseWindow", VALUEFUNC(_wrap_FXMenuButton_raiseWindow), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "lower", VALUEFUNC(_wrap_FXMenuButton_lower), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "move", VALUEFUNC(_wrap_FXMenuButton_move), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "position", VALUEFUNC(_wrap_FXMenuButton_position), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "layout", VALUEFUNC(_wrap_FXMenuButton_layout), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "recalc", VALUEFUNC(_wrap_FXMenuButton_recalc), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "reparent", VALUEFUNC(_wrap_FXMenuButton_reparent), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "show", VALUEFUNC(_wrap_FXMenuButton_show), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "hide", VALUEFUNC(_wrap_FXMenuButton_hide), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "isComposite", VALUEFUNC(_wrap_FXMenuButton_isComposite), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "contains", VALUEFUNC(_wrap_FXMenuButton_contains), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXMenuButton_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "setBackColor", VALUEFUNC(_wrap_FXMenuButton_setBackColor), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "tr", VALUEFUNC(_wrap_FXMenuButton_tr), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "dropEnable", VALUEFUNC(_wrap_FXMenuButton_dropEnable), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "dropDisable", VALUEFUNC(_wrap_FXMenuButton_dropDisable), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "setShape", VALUEFUNC(_wrap_FXMenuButton_setShape), -1);
+  rb_define_method(SwigClassFXMenuButton.klass, "clearShape", VALUEFUNC(_wrap_FXMenuButton_clearShape), -1);
+  SwigClassFXMenuButton.mark = (void (*)(void *)) FXRbMenuButton::markfunc;
+  SwigClassFXMenuButton.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXMenuButton.trackObjects = 0;
+  
+  SWIGTYPE_p_FXMenuButton->dcast = (swig_dycast_func) FXMenuButton_dynamic_cast;
+  
+  
+  SwigClassFXOption.klass = rb_define_class_under(mFox, "FXOption", ((swig_class *) SWIGTYPE_p_FXLabel->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXOption, (void *) &SwigClassFXOption);
+  rb_define_alloc_func(SwigClassFXOption.klass, _wrap_FXOption_allocate);
+  rb_define_method(SwigClassFXOption.klass, "initialize", VALUEFUNC(_wrap_new_FXOption), -1);
+  rb_define_method(SwigClassFXOption.klass, "onPaint", VALUEFUNC(_wrap_FXOption_onPaint), -1);
+  rb_define_method(SwigClassFXOption.klass, "onEnter", VALUEFUNC(_wrap_FXOption_onEnter), -1);
+  rb_define_method(SwigClassFXOption.klass, "onLeave", VALUEFUNC(_wrap_FXOption_onLeave), -1);
+  rb_define_method(SwigClassFXOption.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXOption_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXOption.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXOption_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXOption.klass, "onKeyPress", VALUEFUNC(_wrap_FXOption_onKeyPress), -1);
+  rb_define_method(SwigClassFXOption.klass, "onKeyRelease", VALUEFUNC(_wrap_FXOption_onKeyRelease), -1);
+  rb_define_method(SwigClassFXOption.klass, "onHotKeyPress", VALUEFUNC(_wrap_FXOption_onHotKeyPress), -1);
+  rb_define_method(SwigClassFXOption.klass, "onHotKeyRelease", VALUEFUNC(_wrap_FXOption_onHotKeyRelease), -1);
+  rb_define_method(SwigClassFXOption.klass, "selBackColor=", VALUEFUNC(_wrap_FXOption_selBackColore___), -1);
+  rb_define_method(SwigClassFXOption.klass, "selBackColor", VALUEFUNC(_wrap_FXOption_selBackColor), -1);
+  rb_define_method(SwigClassFXOption.klass, "selTextColor=", VALUEFUNC(_wrap_FXOption_selTextColore___), -1);
+  rb_define_method(SwigClassFXOption.klass, "selTextColor", VALUEFUNC(_wrap_FXOption_selTextColor), -1);
+  rb_define_method(SwigClassFXOption.klass, "save", VALUEFUNC(_wrap_FXOption_save), -1);
+  rb_define_method(SwigClassFXOption.klass, "load", VALUEFUNC(_wrap_FXOption_load), -1);
+  rb_define_method(SwigClassFXOption.klass, "create", VALUEFUNC(_wrap_FXOption_create), -1);
+  rb_define_method(SwigClassFXOption.klass, "detach", VALUEFUNC(_wrap_FXOption_detach), -1);
+  rb_define_method(SwigClassFXOption.klass, "destroy", VALUEFUNC(_wrap_FXOption_destroy), -1);
+  rb_define_method(SwigClassFXOption.klass, "resize", VALUEFUNC(_wrap_FXOption_resize), -1);
+  rb_define_method(SwigClassFXOption.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXOption_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXOption.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXOption_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXOption.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXOption_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXOption.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXOption_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXOption.klass, "canFocus", VALUEFUNC(_wrap_FXOption_canFocus), -1);
+  rb_define_method(SwigClassFXOption.klass, "setFocus", VALUEFUNC(_wrap_FXOption_setFocus), -1);
+  rb_define_method(SwigClassFXOption.klass, "killFocus", VALUEFUNC(_wrap_FXOption_killFocus), -1);
+  rb_define_method(SwigClassFXOption.klass, "changeFocus", VALUEFUNC(_wrap_FXOption_changeFocus), -1);
+  rb_define_method(SwigClassFXOption.klass, "setDefault", VALUEFUNC(_wrap_FXOption_setDefault), -1);
+  rb_define_method(SwigClassFXOption.klass, "enable", VALUEFUNC(_wrap_FXOption_enable), -1);
+  rb_define_method(SwigClassFXOption.klass, "disable", VALUEFUNC(_wrap_FXOption_disable), -1);
+  rb_define_method(SwigClassFXOption.klass, "raiseWindow", VALUEFUNC(_wrap_FXOption_raiseWindow), -1);
+  rb_define_method(SwigClassFXOption.klass, "lower", VALUEFUNC(_wrap_FXOption_lower), -1);
+  rb_define_method(SwigClassFXOption.klass, "move", VALUEFUNC(_wrap_FXOption_move), -1);
+  rb_define_method(SwigClassFXOption.klass, "position", VALUEFUNC(_wrap_FXOption_position), -1);
+  rb_define_method(SwigClassFXOption.klass, "layout", VALUEFUNC(_wrap_FXOption_layout), -1);
+  rb_define_method(SwigClassFXOption.klass, "recalc", VALUEFUNC(_wrap_FXOption_recalc), -1);
+  rb_define_method(SwigClassFXOption.klass, "reparent", VALUEFUNC(_wrap_FXOption_reparent), -1);
+  rb_define_method(SwigClassFXOption.klass, "show", VALUEFUNC(_wrap_FXOption_show), -1);
+  rb_define_method(SwigClassFXOption.klass, "hide", VALUEFUNC(_wrap_FXOption_hide), -1);
+  rb_define_method(SwigClassFXOption.klass, "isComposite", VALUEFUNC(_wrap_FXOption_isComposite), -1);
+  rb_define_method(SwigClassFXOption.klass, "contains", VALUEFUNC(_wrap_FXOption_contains), -1);
+  rb_define_method(SwigClassFXOption.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXOption_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXOption.klass, "setBackColor", VALUEFUNC(_wrap_FXOption_setBackColor), -1);
+  rb_define_method(SwigClassFXOption.klass, "tr", VALUEFUNC(_wrap_FXOption_tr), -1);
+  rb_define_method(SwigClassFXOption.klass, "dropEnable", VALUEFUNC(_wrap_FXOption_dropEnable), -1);
+  rb_define_method(SwigClassFXOption.klass, "dropDisable", VALUEFUNC(_wrap_FXOption_dropDisable), -1);
+  rb_define_method(SwigClassFXOption.klass, "setShape", VALUEFUNC(_wrap_FXOption_setShape), -1);
+  rb_define_method(SwigClassFXOption.klass, "clearShape", VALUEFUNC(_wrap_FXOption_clearShape), -1);
+  SwigClassFXOption.mark = (void (*)(void *)) FXRbOption::markfunc;
+  SwigClassFXOption.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXOption.trackObjects = 0;
+  
+  SwigClassFXOptionMenu.klass = rb_define_class_under(mFox, "FXOptionMenu", ((swig_class *) SWIGTYPE_p_FXLabel->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXOptionMenu, (void *) &SwigClassFXOptionMenu);
+  rb_define_alloc_func(SwigClassFXOptionMenu.klass, _wrap_FXOptionMenu_allocate);
+  rb_define_method(SwigClassFXOptionMenu.klass, "initialize", VALUEFUNC(_wrap_new_FXOptionMenu), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "onPaint", VALUEFUNC(_wrap_FXOptionMenu_onPaint), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXOptionMenu_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXOptionMenu_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "onFocusIn", VALUEFUNC(_wrap_FXOptionMenu_onFocusIn), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "onFocusOut", VALUEFUNC(_wrap_FXOptionMenu_onFocusOut), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "onMotion", VALUEFUNC(_wrap_FXOptionMenu_onMotion), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "onKeyPress", VALUEFUNC(_wrap_FXOptionMenu_onKeyPress), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "onKeyRelease", VALUEFUNC(_wrap_FXOptionMenu_onKeyRelease), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "onCmdPost", VALUEFUNC(_wrap_FXOptionMenu_onCmdPost), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "onCmdUnpost", VALUEFUNC(_wrap_FXOptionMenu_onCmdUnpost), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "onQueryHelp", VALUEFUNC(_wrap_FXOptionMenu_onQueryHelp), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "onQueryTip", VALUEFUNC(_wrap_FXOptionMenu_onQueryTip), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXOptionMenu_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXOptionMenu_onCmdSetIntValue), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXOptionMenu_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "setCurrent", VALUEFUNC(_wrap_FXOptionMenu_setCurrent), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "getCurrent", VALUEFUNC(_wrap_FXOptionMenu_getCurrent), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "setCurrentNo", VALUEFUNC(_wrap_FXOptionMenu_setCurrentNo), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "getCurrentNo", VALUEFUNC(_wrap_FXOptionMenu_getCurrentNo), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "getNumOptions", VALUEFUNC(_wrap_FXOptionMenu_getNumOptions), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "setMenu", VALUEFUNC(_wrap_FXOptionMenu_setMenu), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "getMenu", VALUEFUNC(_wrap_FXOptionMenu_getMenu), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "isPopped", VALUEFUNC(_wrap_FXOptionMenu_isPopped), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "save", VALUEFUNC(_wrap_FXOptionMenu_save), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "load", VALUEFUNC(_wrap_FXOptionMenu_load), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "create", VALUEFUNC(_wrap_FXOptionMenu_create), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "detach", VALUEFUNC(_wrap_FXOptionMenu_detach), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "destroy", VALUEFUNC(_wrap_FXOptionMenu_destroy), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "resize", VALUEFUNC(_wrap_FXOptionMenu_resize), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXOptionMenu_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXOptionMenu_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXOptionMenu_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXOptionMenu_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "canFocus", VALUEFUNC(_wrap_FXOptionMenu_canFocus), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "setFocus", VALUEFUNC(_wrap_FXOptionMenu_setFocus), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "killFocus", VALUEFUNC(_wrap_FXOptionMenu_killFocus), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "changeFocus", VALUEFUNC(_wrap_FXOptionMenu_changeFocus), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "setDefault", VALUEFUNC(_wrap_FXOptionMenu_setDefault), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "enable", VALUEFUNC(_wrap_FXOptionMenu_enable), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "disable", VALUEFUNC(_wrap_FXOptionMenu_disable), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "raiseWindow", VALUEFUNC(_wrap_FXOptionMenu_raiseWindow), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "lower", VALUEFUNC(_wrap_FXOptionMenu_lower), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "move", VALUEFUNC(_wrap_FXOptionMenu_move), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "position", VALUEFUNC(_wrap_FXOptionMenu_position), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "layout", VALUEFUNC(_wrap_FXOptionMenu_layout), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "recalc", VALUEFUNC(_wrap_FXOptionMenu_recalc), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "reparent", VALUEFUNC(_wrap_FXOptionMenu_reparent), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "show", VALUEFUNC(_wrap_FXOptionMenu_show), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "hide", VALUEFUNC(_wrap_FXOptionMenu_hide), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "isComposite", VALUEFUNC(_wrap_FXOptionMenu_isComposite), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "contains", VALUEFUNC(_wrap_FXOptionMenu_contains), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXOptionMenu_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "setBackColor", VALUEFUNC(_wrap_FXOptionMenu_setBackColor), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "tr", VALUEFUNC(_wrap_FXOptionMenu_tr), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "dropEnable", VALUEFUNC(_wrap_FXOptionMenu_dropEnable), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "dropDisable", VALUEFUNC(_wrap_FXOptionMenu_dropDisable), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "setShape", VALUEFUNC(_wrap_FXOptionMenu_setShape), -1);
+  rb_define_method(SwigClassFXOptionMenu.klass, "clearShape", VALUEFUNC(_wrap_FXOptionMenu_clearShape), -1);
+  SwigClassFXOptionMenu.mark = (void (*)(void *)) FXRbOptionMenu::markfunc;
+  SwigClassFXOptionMenu.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXOptionMenu.trackObjects = 0;
+  rb_define_const(mFox, "RADIOBUTTON_AUTOGRAY", SWIG_From_int(static_cast< int >(RADIOBUTTON_AUTOGRAY)));
+  rb_define_const(mFox, "RADIOBUTTON_AUTOHIDE", SWIG_From_int(static_cast< int >(RADIOBUTTON_AUTOHIDE)));
+  rb_define_const(mFox, "RADIOBUTTON_NORMAL", SWIG_From_int(static_cast< int >(RADIOBUTTON_NORMAL)));
+  
+  SwigClassFXRadioButton.klass = rb_define_class_under(mFox, "FXRadioButton", ((swig_class *) SWIGTYPE_p_FXLabel->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXRadioButton, (void *) &SwigClassFXRadioButton);
+  rb_define_alloc_func(SwigClassFXRadioButton.klass, _wrap_FXRadioButton_allocate);
+  rb_define_method(SwigClassFXRadioButton.klass, "initialize", VALUEFUNC(_wrap_new_FXRadioButton), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "onPaint", VALUEFUNC(_wrap_FXRadioButton_onPaint), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "onUpdate", VALUEFUNC(_wrap_FXRadioButton_onUpdate), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "onEnter", VALUEFUNC(_wrap_FXRadioButton_onEnter), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "onLeave", VALUEFUNC(_wrap_FXRadioButton_onLeave), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "onFocusIn", VALUEFUNC(_wrap_FXRadioButton_onFocusIn), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "onFocusOut", VALUEFUNC(_wrap_FXRadioButton_onFocusOut), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "onUngrabbed", VALUEFUNC(_wrap_FXRadioButton_onUngrabbed), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXRadioButton_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXRadioButton_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "onKeyPress", VALUEFUNC(_wrap_FXRadioButton_onKeyPress), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "onKeyRelease", VALUEFUNC(_wrap_FXRadioButton_onKeyRelease), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "onHotKeyPress", VALUEFUNC(_wrap_FXRadioButton_onHotKeyPress), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "onHotKeyRelease", VALUEFUNC(_wrap_FXRadioButton_onHotKeyRelease), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "onCheck", VALUEFUNC(_wrap_FXRadioButton_onCheck), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "onUncheck", VALUEFUNC(_wrap_FXRadioButton_onUncheck), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "onUnknown", VALUEFUNC(_wrap_FXRadioButton_onUnknown), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXRadioButton_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXRadioButton_onCmdSetIntValue), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXRadioButton_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "setCheck", VALUEFUNC(_wrap_FXRadioButton_setCheck), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "getCheck", VALUEFUNC(_wrap_FXRadioButton_getCheck), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "getCheckState", VALUEFUNC(_wrap_FXRadioButton_getCheckState), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "setRadioButtonStyle", VALUEFUNC(_wrap_FXRadioButton_setRadioButtonStyle), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "getRadioButtonStyle", VALUEFUNC(_wrap_FXRadioButton_getRadioButtonStyle), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "getRadioColor", VALUEFUNC(_wrap_FXRadioButton_getRadioColor), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "setRadioColor", VALUEFUNC(_wrap_FXRadioButton_setRadioColor), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "getDiskColor", VALUEFUNC(_wrap_FXRadioButton_getDiskColor), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "setDiskColor", VALUEFUNC(_wrap_FXRadioButton_setDiskColor), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "save", VALUEFUNC(_wrap_FXRadioButton_save), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "load", VALUEFUNC(_wrap_FXRadioButton_load), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "create", VALUEFUNC(_wrap_FXRadioButton_create), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "detach", VALUEFUNC(_wrap_FXRadioButton_detach), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "destroy", VALUEFUNC(_wrap_FXRadioButton_destroy), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "resize", VALUEFUNC(_wrap_FXRadioButton_resize), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXRadioButton_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXRadioButton_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXRadioButton_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXRadioButton_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "canFocus", VALUEFUNC(_wrap_FXRadioButton_canFocus), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "setFocus", VALUEFUNC(_wrap_FXRadioButton_setFocus), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "killFocus", VALUEFUNC(_wrap_FXRadioButton_killFocus), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "changeFocus", VALUEFUNC(_wrap_FXRadioButton_changeFocus), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "setDefault", VALUEFUNC(_wrap_FXRadioButton_setDefault), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "enable", VALUEFUNC(_wrap_FXRadioButton_enable), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "disable", VALUEFUNC(_wrap_FXRadioButton_disable), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "raiseWindow", VALUEFUNC(_wrap_FXRadioButton_raiseWindow), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "lower", VALUEFUNC(_wrap_FXRadioButton_lower), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "move", VALUEFUNC(_wrap_FXRadioButton_move), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "position", VALUEFUNC(_wrap_FXRadioButton_position), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "layout", VALUEFUNC(_wrap_FXRadioButton_layout), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "recalc", VALUEFUNC(_wrap_FXRadioButton_recalc), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "reparent", VALUEFUNC(_wrap_FXRadioButton_reparent), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "show", VALUEFUNC(_wrap_FXRadioButton_show), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "hide", VALUEFUNC(_wrap_FXRadioButton_hide), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "isComposite", VALUEFUNC(_wrap_FXRadioButton_isComposite), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "contains", VALUEFUNC(_wrap_FXRadioButton_contains), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXRadioButton_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "setBackColor", VALUEFUNC(_wrap_FXRadioButton_setBackColor), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "tr", VALUEFUNC(_wrap_FXRadioButton_tr), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "dropEnable", VALUEFUNC(_wrap_FXRadioButton_dropEnable), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "dropDisable", VALUEFUNC(_wrap_FXRadioButton_dropDisable), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "setShape", VALUEFUNC(_wrap_FXRadioButton_setShape), -1);
+  rb_define_method(SwigClassFXRadioButton.klass, "clearShape", VALUEFUNC(_wrap_FXRadioButton_clearShape), -1);
+  SwigClassFXRadioButton.mark = (void (*)(void *)) FXRbRadioButton::markfunc;
+  SwigClassFXRadioButton.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXRadioButton.trackObjects = 0;
+  rb_define_const(mFox, "TAB_TOP", SWIG_From_int(static_cast< int >(TAB_TOP)));
+  rb_define_const(mFox, "TAB_LEFT", SWIG_From_int(static_cast< int >(TAB_LEFT)));
+  rb_define_const(mFox, "TAB_RIGHT", SWIG_From_int(static_cast< int >(TAB_RIGHT)));
+  rb_define_const(mFox, "TAB_BOTTOM", SWIG_From_int(static_cast< int >(TAB_BOTTOM)));
+  rb_define_const(mFox, "TAB_TOP_NORMAL", SWIG_From_int(static_cast< int >(TAB_TOP_NORMAL)));
+  rb_define_const(mFox, "TAB_BOTTOM_NORMAL", SWIG_From_int(static_cast< int >(TAB_BOTTOM_NORMAL)));
+  rb_define_const(mFox, "TAB_LEFT_NORMAL", SWIG_From_int(static_cast< int >(TAB_LEFT_NORMAL)));
+  rb_define_const(mFox, "TAB_RIGHT_NORMAL", SWIG_From_int(static_cast< int >(TAB_RIGHT_NORMAL)));
+  
+  SwigClassFXTabItem.klass = rb_define_class_under(mFox, "FXTabItem", ((swig_class *) SWIGTYPE_p_FXLabel->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXTabItem, (void *) &SwigClassFXTabItem);
+  rb_define_alloc_func(SwigClassFXTabItem.klass, _wrap_FXTabItem_allocate);
+  rb_define_method(SwigClassFXTabItem.klass, "initialize", VALUEFUNC(_wrap_new_FXTabItem), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "onPaint", VALUEFUNC(_wrap_FXTabItem_onPaint), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "onFocusIn", VALUEFUNC(_wrap_FXTabItem_onFocusIn), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "onFocusOut", VALUEFUNC(_wrap_FXTabItem_onFocusOut), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "onUngrabbed", VALUEFUNC(_wrap_FXTabItem_onUngrabbed), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXTabItem_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXTabItem_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "onKeyPress", VALUEFUNC(_wrap_FXTabItem_onKeyPress), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "onKeyRelease", VALUEFUNC(_wrap_FXTabItem_onKeyRelease), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "onHotKeyPress", VALUEFUNC(_wrap_FXTabItem_onHotKeyPress), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "onHotKeyRelease", VALUEFUNC(_wrap_FXTabItem_onHotKeyRelease), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "getTabOrientation", VALUEFUNC(_wrap_FXTabItem_getTabOrientation), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "setTabOrientation", VALUEFUNC(_wrap_FXTabItem_setTabOrientation), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "save", VALUEFUNC(_wrap_FXTabItem_save), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "load", VALUEFUNC(_wrap_FXTabItem_load), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "create", VALUEFUNC(_wrap_FXTabItem_create), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "detach", VALUEFUNC(_wrap_FXTabItem_detach), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "destroy", VALUEFUNC(_wrap_FXTabItem_destroy), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "resize", VALUEFUNC(_wrap_FXTabItem_resize), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXTabItem_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXTabItem_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXTabItem_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXTabItem_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "canFocus", VALUEFUNC(_wrap_FXTabItem_canFocus), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "setFocus", VALUEFUNC(_wrap_FXTabItem_setFocus), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "killFocus", VALUEFUNC(_wrap_FXTabItem_killFocus), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "changeFocus", VALUEFUNC(_wrap_FXTabItem_changeFocus), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "setDefault", VALUEFUNC(_wrap_FXTabItem_setDefault), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "enable", VALUEFUNC(_wrap_FXTabItem_enable), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "disable", VALUEFUNC(_wrap_FXTabItem_disable), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "raiseWindow", VALUEFUNC(_wrap_FXTabItem_raiseWindow), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "lower", VALUEFUNC(_wrap_FXTabItem_lower), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "move", VALUEFUNC(_wrap_FXTabItem_move), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "position", VALUEFUNC(_wrap_FXTabItem_position), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "layout", VALUEFUNC(_wrap_FXTabItem_layout), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "recalc", VALUEFUNC(_wrap_FXTabItem_recalc), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "reparent", VALUEFUNC(_wrap_FXTabItem_reparent), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "show", VALUEFUNC(_wrap_FXTabItem_show), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "hide", VALUEFUNC(_wrap_FXTabItem_hide), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "isComposite", VALUEFUNC(_wrap_FXTabItem_isComposite), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "contains", VALUEFUNC(_wrap_FXTabItem_contains), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXTabItem_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "setBackColor", VALUEFUNC(_wrap_FXTabItem_setBackColor), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "tr", VALUEFUNC(_wrap_FXTabItem_tr), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "dropEnable", VALUEFUNC(_wrap_FXTabItem_dropEnable), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "dropDisable", VALUEFUNC(_wrap_FXTabItem_dropDisable), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "setShape", VALUEFUNC(_wrap_FXTabItem_setShape), -1);
+  rb_define_method(SwigClassFXTabItem.klass, "clearShape", VALUEFUNC(_wrap_FXTabItem_clearShape), -1);
+  SwigClassFXTabItem.mark = (void (*)(void *)) FXRbTabItem::markfunc;
+  SwigClassFXTabItem.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXTabItem.trackObjects = 0;
+  rb_define_const(mFox, "TOGGLEBUTTON_AUTOGRAY", SWIG_From_int(static_cast< int >(TOGGLEBUTTON_AUTOGRAY)));
+  rb_define_const(mFox, "TOGGLEBUTTON_AUTOHIDE", SWIG_From_int(static_cast< int >(TOGGLEBUTTON_AUTOHIDE)));
+  rb_define_const(mFox, "TOGGLEBUTTON_TOOLBAR", SWIG_From_int(static_cast< int >(TOGGLEBUTTON_TOOLBAR)));
+  rb_define_const(mFox, "TOGGLEBUTTON_KEEPSTATE", SWIG_From_int(static_cast< int >(TOGGLEBUTTON_KEEPSTATE)));
+  rb_define_const(mFox, "TOGGLEBUTTON_NORMAL", SWIG_From_int(static_cast< int >(TOGGLEBUTTON_NORMAL)));
+  
+  SwigClassFXToggleButton.klass = rb_define_class_under(mFox, "FXToggleButton", ((swig_class *) SWIGTYPE_p_FXLabel->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXToggleButton, (void *) &SwigClassFXToggleButton);
+  rb_define_alloc_func(SwigClassFXToggleButton.klass, _wrap_FXToggleButton_allocate);
+  rb_define_method(SwigClassFXToggleButton.klass, "initialize", VALUEFUNC(_wrap_new_FXToggleButton), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "onPaint", VALUEFUNC(_wrap_FXToggleButton_onPaint), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "onUpdate", VALUEFUNC(_wrap_FXToggleButton_onUpdate), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "onEnter", VALUEFUNC(_wrap_FXToggleButton_onEnter), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "onLeave", VALUEFUNC(_wrap_FXToggleButton_onLeave), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "onFocusIn", VALUEFUNC(_wrap_FXToggleButton_onFocusIn), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "onFocusOut", VALUEFUNC(_wrap_FXToggleButton_onFocusOut), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "onUngrabbed", VALUEFUNC(_wrap_FXToggleButton_onUngrabbed), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXToggleButton_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXToggleButton_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "onKeyPress", VALUEFUNC(_wrap_FXToggleButton_onKeyPress), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "onKeyRelease", VALUEFUNC(_wrap_FXToggleButton_onKeyRelease), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "onHotKeyPress", VALUEFUNC(_wrap_FXToggleButton_onHotKeyPress), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "onHotKeyRelease", VALUEFUNC(_wrap_FXToggleButton_onHotKeyRelease), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "onCheck", VALUEFUNC(_wrap_FXToggleButton_onCheck), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "onUncheck", VALUEFUNC(_wrap_FXToggleButton_onUncheck), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "onQueryHelp", VALUEFUNC(_wrap_FXToggleButton_onQueryHelp), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "onQueryTip", VALUEFUNC(_wrap_FXToggleButton_onQueryTip), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXToggleButton_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXToggleButton_onCmdSetIntValue), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXToggleButton_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "setAltText", VALUEFUNC(_wrap_FXToggleButton_setAltText), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "getAltText", VALUEFUNC(_wrap_FXToggleButton_getAltText), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "setAltIcon", VALUEFUNC(_wrap_FXToggleButton_setAltIcon), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "getAltIcon", VALUEFUNC(_wrap_FXToggleButton_getAltIcon), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "setState", VALUEFUNC(_wrap_FXToggleButton_setState), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "getState", VALUEFUNC(_wrap_FXToggleButton_getState), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "setAltHelpText", VALUEFUNC(_wrap_FXToggleButton_setAltHelpText), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "getAltHelpText", VALUEFUNC(_wrap_FXToggleButton_getAltHelpText), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "setAltTipText", VALUEFUNC(_wrap_FXToggleButton_setAltTipText), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "getAltTipText", VALUEFUNC(_wrap_FXToggleButton_getAltTipText), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "setToggleStyle", VALUEFUNC(_wrap_FXToggleButton_setToggleStyle), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "getToggleStyle", VALUEFUNC(_wrap_FXToggleButton_getToggleStyle), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "save", VALUEFUNC(_wrap_FXToggleButton_save), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "load", VALUEFUNC(_wrap_FXToggleButton_load), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "create", VALUEFUNC(_wrap_FXToggleButton_create), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "detach", VALUEFUNC(_wrap_FXToggleButton_detach), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "destroy", VALUEFUNC(_wrap_FXToggleButton_destroy), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "resize", VALUEFUNC(_wrap_FXToggleButton_resize), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXToggleButton_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXToggleButton_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXToggleButton_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXToggleButton_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "canFocus", VALUEFUNC(_wrap_FXToggleButton_canFocus), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "setFocus", VALUEFUNC(_wrap_FXToggleButton_setFocus), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "killFocus", VALUEFUNC(_wrap_FXToggleButton_killFocus), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "changeFocus", VALUEFUNC(_wrap_FXToggleButton_changeFocus), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "setDefault", VALUEFUNC(_wrap_FXToggleButton_setDefault), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "enable", VALUEFUNC(_wrap_FXToggleButton_enable), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "disable", VALUEFUNC(_wrap_FXToggleButton_disable), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "raiseWindow", VALUEFUNC(_wrap_FXToggleButton_raiseWindow), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "lower", VALUEFUNC(_wrap_FXToggleButton_lower), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "move", VALUEFUNC(_wrap_FXToggleButton_move), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "position", VALUEFUNC(_wrap_FXToggleButton_position), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "layout", VALUEFUNC(_wrap_FXToggleButton_layout), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "recalc", VALUEFUNC(_wrap_FXToggleButton_recalc), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "reparent", VALUEFUNC(_wrap_FXToggleButton_reparent), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "show", VALUEFUNC(_wrap_FXToggleButton_show), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "hide", VALUEFUNC(_wrap_FXToggleButton_hide), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "isComposite", VALUEFUNC(_wrap_FXToggleButton_isComposite), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "contains", VALUEFUNC(_wrap_FXToggleButton_contains), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXToggleButton_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "setBackColor", VALUEFUNC(_wrap_FXToggleButton_setBackColor), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "tr", VALUEFUNC(_wrap_FXToggleButton_tr), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "dropEnable", VALUEFUNC(_wrap_FXToggleButton_dropEnable), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "dropDisable", VALUEFUNC(_wrap_FXToggleButton_dropDisable), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "setShape", VALUEFUNC(_wrap_FXToggleButton_setShape), -1);
+  rb_define_method(SwigClassFXToggleButton.klass, "clearShape", VALUEFUNC(_wrap_FXToggleButton_clearShape), -1);
+  SwigClassFXToggleButton.mark = (void (*)(void *)) FXRbToggleButton::markfunc;
+  SwigClassFXToggleButton.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXToggleButton.trackObjects = 0;
+  
+  SWIGTYPE_p_FXToggleButton->dcast = (swig_dycast_func) FXToggleButton_dynamic_cast;
+  
+  
+  SwigClassFXTriStateButton.klass = rb_define_class_under(mFox, "FXTriStateButton", ((swig_class *) SWIGTYPE_p_FXToggleButton->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXTriStateButton, (void *) &SwigClassFXTriStateButton);
+  rb_define_alloc_func(SwigClassFXTriStateButton.klass, _wrap_FXTriStateButton_allocate);
+  rb_define_method(SwigClassFXTriStateButton.klass, "initialize", VALUEFUNC(_wrap_new_FXTriStateButton), -1);
+  rb_define_method(SwigClassFXTriStateButton.klass, "onPaint", VALUEFUNC(_wrap_FXTriStateButton_onPaint), -1);
+  rb_define_method(SwigClassFXTriStateButton.klass, "onUnknown", VALUEFUNC(_wrap_FXTriStateButton_onUnknown), -1);
+  rb_define_method(SwigClassFXTriStateButton.klass, "onQueryHelp", VALUEFUNC(_wrap_FXTriStateButton_onQueryHelp), -1);
+  rb_define_method(SwigClassFXTriStateButton.klass, "onQueryTip", VALUEFUNC(_wrap_FXTriStateButton_onQueryTip), -1);
+  rb_define_method(SwigClassFXTriStateButton.klass, "setMaybeText", VALUEFUNC(_wrap_FXTriStateButton_setMaybeText), -1);
+  rb_define_method(SwigClassFXTriStateButton.klass, "getMaybeText", VALUEFUNC(_wrap_FXTriStateButton_getMaybeText), -1);
+  rb_define_method(SwigClassFXTriStateButton.klass, "setMaybeIcon", VALUEFUNC(_wrap_FXTriStateButton_setMaybeIcon), -1);
+  rb_define_method(SwigClassFXTriStateButton.klass, "getMaybeIcon", VALUEFUNC(_wrap_FXTriStateButton_getMaybeIcon), -1);
+  rb_define_method(SwigClassFXTriStateButton.klass, "setMaybeHelpText", VALUEFUNC(_wrap_FXTriStateButton_setMaybeHelpText), -1);
+  rb_define_method(SwigClassFXTriStateButton.klass, "getMaybeHelpText", VALUEFUNC(_wrap_FXTriStateButton_getMaybeHelpText), -1);
+  rb_define_method(SwigClassFXTriStateButton.klass, "setMaybeTipText", VALUEFUNC(_wrap_FXTriStateButton_setMaybeTipText), -1);
+  rb_define_method(SwigClassFXTriStateButton.klass, "getMaybeTipText", VALUEFUNC(_wrap_FXTriStateButton_getMaybeTipText), -1);
+  SwigClassFXTriStateButton.mark = (void (*)(void *)) FXRbTriStateButton::markfunc;
+  SwigClassFXTriStateButton.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXTriStateButton.trackObjects = 0;
+  
+  SwigClassFXPicker.klass = rb_define_class_under(mFox, "FXPicker", ((swig_class *) SWIGTYPE_p_FXButton->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXPicker, (void *) &SwigClassFXPicker);
+  rb_define_alloc_func(SwigClassFXPicker.klass, _wrap_FXPicker_allocate);
+  rb_define_method(SwigClassFXPicker.klass, "initialize", VALUEFUNC(_wrap_new_FXPicker), -1);
+  rb_define_method(SwigClassFXPicker.klass, "onMotion", VALUEFUNC(_wrap_FXPicker_onMotion), -1);
+  rb_define_method(SwigClassFXPicker.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXPicker_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXPicker.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXPicker_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXPicker.klass, "onEnter", VALUEFUNC(_wrap_FXPicker_onEnter), -1);
+  rb_define_method(SwigClassFXPicker.klass, "onLeave", VALUEFUNC(_wrap_FXPicker_onLeave), -1);
+  rb_define_method(SwigClassFXPicker.klass, "save", VALUEFUNC(_wrap_FXPicker_save), -1);
+  rb_define_method(SwigClassFXPicker.klass, "load", VALUEFUNC(_wrap_FXPicker_load), -1);
+  rb_define_method(SwigClassFXPicker.klass, "create", VALUEFUNC(_wrap_FXPicker_create), -1);
+  rb_define_method(SwigClassFXPicker.klass, "detach", VALUEFUNC(_wrap_FXPicker_detach), -1);
+  rb_define_method(SwigClassFXPicker.klass, "destroy", VALUEFUNC(_wrap_FXPicker_destroy), -1);
+  rb_define_method(SwigClassFXPicker.klass, "resize", VALUEFUNC(_wrap_FXPicker_resize), -1);
+  rb_define_method(SwigClassFXPicker.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXPicker_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXPicker.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXPicker_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXPicker.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXPicker_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXPicker.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXPicker_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXPicker.klass, "canFocus", VALUEFUNC(_wrap_FXPicker_canFocus), -1);
+  rb_define_method(SwigClassFXPicker.klass, "setFocus", VALUEFUNC(_wrap_FXPicker_setFocus), -1);
+  rb_define_method(SwigClassFXPicker.klass, "killFocus", VALUEFUNC(_wrap_FXPicker_killFocus), -1);
+  rb_define_method(SwigClassFXPicker.klass, "changeFocus", VALUEFUNC(_wrap_FXPicker_changeFocus), -1);
+  rb_define_method(SwigClassFXPicker.klass, "setDefault", VALUEFUNC(_wrap_FXPicker_setDefault), -1);
+  rb_define_method(SwigClassFXPicker.klass, "enable", VALUEFUNC(_wrap_FXPicker_enable), -1);
+  rb_define_method(SwigClassFXPicker.klass, "disable", VALUEFUNC(_wrap_FXPicker_disable), -1);
+  rb_define_method(SwigClassFXPicker.klass, "raiseWindow", VALUEFUNC(_wrap_FXPicker_raiseWindow), -1);
+  rb_define_method(SwigClassFXPicker.klass, "lower", VALUEFUNC(_wrap_FXPicker_lower), -1);
+  rb_define_method(SwigClassFXPicker.klass, "move", VALUEFUNC(_wrap_FXPicker_move), -1);
+  rb_define_method(SwigClassFXPicker.klass, "position", VALUEFUNC(_wrap_FXPicker_position), -1);
+  rb_define_method(SwigClassFXPicker.klass, "layout", VALUEFUNC(_wrap_FXPicker_layout), -1);
+  rb_define_method(SwigClassFXPicker.klass, "recalc", VALUEFUNC(_wrap_FXPicker_recalc), -1);
+  rb_define_method(SwigClassFXPicker.klass, "reparent", VALUEFUNC(_wrap_FXPicker_reparent), -1);
+  rb_define_method(SwigClassFXPicker.klass, "show", VALUEFUNC(_wrap_FXPicker_show), -1);
+  rb_define_method(SwigClassFXPicker.klass, "hide", VALUEFUNC(_wrap_FXPicker_hide), -1);
+  rb_define_method(SwigClassFXPicker.klass, "isComposite", VALUEFUNC(_wrap_FXPicker_isComposite), -1);
+  rb_define_method(SwigClassFXPicker.klass, "contains", VALUEFUNC(_wrap_FXPicker_contains), -1);
+  rb_define_method(SwigClassFXPicker.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXPicker_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXPicker.klass, "setBackColor", VALUEFUNC(_wrap_FXPicker_setBackColor), -1);
+  rb_define_method(SwigClassFXPicker.klass, "tr", VALUEFUNC(_wrap_FXPicker_tr), -1);
+  rb_define_method(SwigClassFXPicker.klass, "dropEnable", VALUEFUNC(_wrap_FXPicker_dropEnable), -1);
+  rb_define_method(SwigClassFXPicker.klass, "dropDisable", VALUEFUNC(_wrap_FXPicker_dropDisable), -1);
+  rb_define_method(SwigClassFXPicker.klass, "setShape", VALUEFUNC(_wrap_FXPicker_setShape), -1);
+  rb_define_method(SwigClassFXPicker.klass, "clearShape", VALUEFUNC(_wrap_FXPicker_clearShape), -1);
+  SwigClassFXPicker.mark = (void (*)(void *)) FXRbPicker::markfunc;
+  SwigClassFXPicker.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXPicker.trackObjects = 0;
+}
+
diff --git a/ext/fox16_c/layout_wrap.cpp b/ext/fox16_c/layout_wrap.cpp
new file mode 100644
index 00000000..93d7102f
--- /dev/null
+++ b/ext/fox16_c/layout_wrap.cpp
@@ -0,0 +1,25637 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 3.0.12
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+
+#ifndef SWIGRUBY
+#define SWIGRUBY
+#endif
+
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
+};
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic C API SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "4"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/*  Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN           0x1
+
+
+/*
+   Flags/methods for returning states.
+
+   The SWIG conversion methods, as ConvertPtr, return an integer
+   that tells if the conversion was successful or not. And if not,
+   an error code can be returned (see swigerrors.swg for the codes).
+
+   Use the following macros/flags to set or process the returning
+   states.
+
+   In old versions of SWIG, code such as the following was usually written:
+
+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+       // success code
+     } else {
+       //fail code
+     }
+
+   Now you can be more explicit:
+
+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+    } else {
+      // fail code
+    }
+
+   which is the same really, but now you can also do
+
+    Type *ptr;
+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+      if (SWIG_IsNewObj(res) {
+        ...
+	delete *ptr;
+      } else {
+        ...
+      }
+    } else {
+      // fail code
+    }
+
+   I.e., now SWIG_ConvertPtr can return new objects and you can
+   identify the case and take care of the deallocation. Of course that
+   also requires SWIG_ConvertPtr to return new result values, such as
+
+      int SWIG_ConvertPtr(obj, ptr,...) {
+        if (<obj is ok>) {
+          if (<need new object>) {
+            *ptr = <ptr to new allocated object>;
+            return SWIG_NEWOBJ;
+          } else {
+            *ptr = <ptr to old object>;
+            return SWIG_OLDOBJ;
+          }
+        } else {
+          return SWIG_BADOBJ;
+        }
+      }
+
+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+   SWIG errors code.
+
+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+   allows to return the 'cast rank', for example, if you have this
+
+       int food(double)
+       int fooi(int);
+
+   and you call
+
+      food(1)   // cast rank '1'  (1 -> 1.0)
+      fooi(1)   // cast rank '0'
+
+   just use the SWIG_AddCast()/SWIG_CheckState()
+*/
+
+#define SWIG_OK                    (0)
+#define SWIG_ERROR                 (-1)
+#define SWIG_IsOK(r)               (r >= 0)
+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT         (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ                (SWIG_ERROR)
+#define SWIG_OLDOBJ                (SWIG_OK)
+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+#  ifndef SWIG_TypeRank
+#    define SWIG_TypeRank             unsigned long
+#  endif
+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
+#    define SWIG_MAXCASTRANK          (2)
+#  endif
+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+#  define SWIG_AddCast(r) (r)
+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *, int *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store information on one type */
+typedef struct swig_type_info {
+  const char             *name;			/* mangled name of this type */
+  const char             *str;			/* human readable name of this type */
+  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
+  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
+  void                   *clientdata;		/* language specific type data */
+  int                    owndata;		/* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
+  swig_converter_func     converter;		/* function to cast the void pointers */
+  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
+  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
+  size_t                 size;		        /* Number of types in this module */
+  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
+  swig_type_info         **type_initial;	/* Array of initially generated type structures */
+  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
+  void                    *clientdata;		/* Language specific module data */
+} swig_module_info;
+
+/*
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+  }
+  return (int)((l1 - f1) - (l2 - f2));
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCmp(const char *nb, const char *tb) {
+  int equiv = 1;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (equiv != 0 && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
+}
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
+}
+
+/*
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+  swig_type_info *lastty = ty;
+  if (!ty || !ty->dcast) return ty;
+  while (ty && (ty->dcast)) {
+    ty = (*ty->dcast)(ptr);
+    if (ty) lastty = ty;
+  }
+  return lastty;
+}
+
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+  return ty->name;
+}
+
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (!type) return NULL;
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
+  }
+  else
+    return type->name;
+}
+
+/*
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+  swig_cast_info *cast = ti->cast;
+  /* if (ti->clientdata == clientdata) return; */
+  ti->clientdata = clientdata;
+
+  while (cast) {
+    if (!cast->converter) {
+      swig_type_info *tc = cast->type;
+      if (!tc->clientdata) {
+	SWIG_TypeClientData(tc, clientdata);
+      }
+    }
+    cast = cast->next;
+  }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientData(ti, clientdata);
+  ti->owndata = 1;
+}
+
+/*
+  Search for a swig_type_info structure only by mangled name
+  Search is a O(log #types)
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+                            swig_module_info *end,
+		            const char *name) {
+  swig_module_info *iter = start;
+  do {
+    if (iter->size) {
+      size_t l = 0;
+      size_t r = iter->size - 1;
+      do {
+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
+	size_t i = (l + r) >> 1;
+	const char *iname = iter->types[i]->name;
+	if (iname) {
+	  int compare = strcmp(name, iname);
+	  if (compare == 0) {
+	    return iter->types[i];
+	  } else if (compare < 0) {
+	    if (i) {
+	      r = i - 1;
+	    } else {
+	      break;
+	    }
+	  } else if (compare > 0) {
+	    l = i + 1;
+	  }
+	} else {
+	  break; /* should never happen */
+	}
+      } while (l <= r);
+    }
+    iter = iter->next;
+  } while (iter != end);
+  return 0;
+}
+
+/*
+  Search for a swig_type_info structure for either a mangled name or a human readable name.
+  It first searches the mangled names of the types, which is a O(log #types)
+  If a type is not found it then searches the human readable names, which is O(#types).
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+                     swig_module_info *end,
+		     const char *name) {
+  /* STEP 1: Search the name field using binary search */
+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+  if (ret) {
+    return ret;
+  } else {
+    /* STEP 2: If the type hasn't been found, do a complete search
+       of the str field (the human readable name) */
+    swig_module_info *iter = start;
+    do {
+      size_t i = 0;
+      for (; i < iter->size; ++i) {
+	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+	  return iter->types[i];
+      }
+      iter = iter->next;
+    } while (iter != end);
+  }
+
+  /* neither found a match */
+  return 0;
+}
+
+/*
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+
+/*
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = (unsigned char)((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = (unsigned char)((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (unsigned char)(d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (unsigned char)(d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/*
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/*  Errors in SWIG */
+#define  SWIG_UnknownError    	   -1
+#define  SWIG_IOError        	   -2
+#define  SWIG_RuntimeError   	   -3
+#define  SWIG_IndexError     	   -4
+#define  SWIG_TypeError      	   -5
+#define  SWIG_DivisionByZero 	   -6
+#define  SWIG_OverflowError  	   -7
+#define  SWIG_SyntaxError    	   -8
+#define  SWIG_ValueError     	   -9
+#define  SWIG_SystemError    	   -10
+#define  SWIG_AttributeError 	   -11
+#define  SWIG_MemoryError    	   -12
+#define  SWIG_NullReferenceError   -13
+
+
+
+      #include <ruby.h>
+
+      #if defined(RB_METHOD_DEFINITION_DECL)
+      # define RUBY_VALUE_METHOD_FUNC(func) (func)
+      # define RUBY_INT_METHOD_FUNC(func) (func)
+      # define RUBY_VOID_METHOD_FUNC(func) (func)
+      # define RUBY_VOIDP_METHOD_FUNC(func) (func)
+      #else
+      # define RUBY_VALUE_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
+      # define RUBY_INT_METHOD_FUNC(func) ((int (*)(ANYARGS))(func))
+      # define RUBY_VOID_METHOD_FUNC(func) ((void (*)(ANYARGS))(func))
+      # define RUBY_VOIDP_METHOD_FUNC(func) ((void *(*)(ANYARGS))(func))
+      #endif
+
+
+/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
+ * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
+ * issue for now by disabling this.
+ * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
+ */
+#ifdef rb_intern
+# undef rb_intern
+#endif
+
+/* Remove global macros defined in Ruby's win32.h */
+#ifdef write
+# undef write
+#endif
+#ifdef read
+# undef read
+#endif
+#ifdef bind
+# undef bind
+#endif
+#ifdef close
+# undef close
+#endif
+#ifdef connect
+# undef connect
+#endif
+
+
+/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
+#ifndef NUM2LL
+#define NUM2LL(x) NUM2LONG((x))
+#endif
+#ifndef LL2NUM
+#define LL2NUM(x) INT2NUM((long) (x))
+#endif
+#ifndef ULL2NUM
+#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
+#endif
+
+/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
+#ifndef NUM2ULL
+#ifdef HAVE_LONG_LONG
+#define NUM2ULL(x) rb_num2ull((x))
+#else
+#define NUM2ULL(x) NUM2ULONG(x)
+#endif
+#endif
+
+/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
+/* Define these for older versions so we can just write code the new way */
+#ifndef RSTRING_LEN
+# define RSTRING_LEN(x) RSTRING(x)->len
+#endif
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(x) RSTRING(x)->ptr
+#endif
+#ifndef RSTRING_END
+# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
+#endif
+#ifndef RARRAY_LEN
+# define RARRAY_LEN(x) RARRAY(x)->len
+#endif
+#ifndef RARRAY_PTR
+# define RARRAY_PTR(x) RARRAY(x)->ptr
+#endif
+#ifndef RFLOAT_VALUE
+# define RFLOAT_VALUE(x) RFLOAT(x)->value
+#endif
+#ifndef DOUBLE2NUM
+# define DOUBLE2NUM(x) rb_float_new(x)
+#endif
+#ifndef RHASH_TBL
+# define RHASH_TBL(x) (RHASH(x)->tbl)
+#endif
+#ifndef RHASH_ITER_LEV
+# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
+#endif
+#ifndef RHASH_IFNONE
+# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
+#endif
+#ifndef RHASH_SIZE
+# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
+#endif
+#ifndef RHASH_EMPTY_P
+# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
+#endif
+#ifndef RSTRUCT_LEN
+# define RSTRUCT_LEN(x) RSTRUCT(x)->len
+#endif
+#ifndef RSTRUCT_PTR
+# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
+#endif
+
+
+
+/*
+ * Need to be very careful about how these macros are defined, especially
+ * when compiling C++ code or C code with an ANSI C compiler.
+ *
+ * VALUEFUNC(f) is a macro used to typecast a C function that implements
+ * a Ruby method so that it can be passed as an argument to API functions
+ * like rb_define_method() and rb_define_singleton_method().
+ *
+ * VOIDFUNC(f) is a macro used to typecast a C function that implements
+ * either the "mark" or "free" stuff for a Ruby Data object, so that it
+ * can be passed as an argument to API functions like Data_Wrap_Struct()
+ * and Data_Make_Struct().
+ */
+ 
+#ifdef __cplusplus
+#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
+#    define PROTECTFUNC(f) ((VALUE (*)()) f)
+#    define VALUEFUNC(f) ((VALUE (*)()) f)
+#    define VOIDFUNC(f)  ((void (*)()) f)
+#  else
+#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
+#      define PROTECTFUNC(f) ((VALUE (*)()) f)
+#      define VALUEFUNC(f) ((VALUE (*)()) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    else /* These definitions should work for Ruby 1.7+ */
+#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
+#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    endif
+#  endif
+#else
+#  define VALUEFUNC(f) (f)
+#  define VOIDFUNC(f) (f)
+#endif
+
+/* Don't use for expressions have side effect */
+#ifndef RB_STRING_VALUE
+#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
+#endif
+#ifndef StringValue
+#define StringValue(s) RB_STRING_VALUE(s)
+#endif
+#ifndef StringValuePtr
+#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
+#endif
+#ifndef StringValueLen
+#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
+#endif
+#ifndef SafeStringValue
+#define SafeStringValue(v) do {\
+    StringValue(v);\
+    rb_check_safe_str(v);\
+} while (0)
+#endif
+
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
+#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
+#endif
+
+static VALUE _mSWIG = Qnil;
+
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+
+/* Define some additional error types */
+#define SWIG_ObjectPreviouslyDeletedError  -100
+
+
+/* Define custom exceptions for errors that do not map to existing Ruby
+   exceptions.  Note this only works for C++ since a global cannot be
+   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/
+
+SWIGINTERN VALUE 
+getNullReferenceError(void) {
+  static int init = 0;
+  static VALUE rb_eNullReferenceError ;
+  if (!init) {
+    init = 1;
+    rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
+  }
+  return rb_eNullReferenceError;
+} 
+
+SWIGINTERN VALUE 
+getObjectPreviouslyDeletedError(void) {
+  static int init = 0;
+  static VALUE rb_eObjectPreviouslyDeleted ;
+  if (!init) {
+    init = 1;
+    rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
+  }
+  return rb_eObjectPreviouslyDeleted;
+} 
+
+
+SWIGINTERN VALUE
+SWIG_Ruby_ErrorType(int SWIG_code) {
+  VALUE type;
+  switch (SWIG_code) {
+  case SWIG_MemoryError:
+    type = rb_eNoMemError;
+    break;
+  case SWIG_IOError:
+    type = rb_eIOError;
+    break;
+  case SWIG_RuntimeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_IndexError:
+    type = rb_eIndexError;
+    break;
+  case SWIG_TypeError:
+    type = rb_eTypeError;
+    break;
+  case SWIG_DivisionByZero:
+    type = rb_eZeroDivError;
+    break;
+  case SWIG_OverflowError:
+    type = rb_eRangeError;
+    break;
+  case SWIG_SyntaxError:
+    type = rb_eSyntaxError;
+    break;
+  case SWIG_ValueError:
+    type = rb_eArgError;
+    break;
+  case SWIG_SystemError:
+    type = rb_eFatal;
+    break;
+  case SWIG_AttributeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_NullReferenceError:
+    type = getNullReferenceError();
+    break;
+  case SWIG_ObjectPreviouslyDeletedError:
+    type = getObjectPreviouslyDeletedError();
+    break;
+  case SWIG_UnknownError:
+    type = rb_eRuntimeError;
+    break;
+  default:
+    type = rb_eRuntimeError;
+  }
+  return type;
+}
+
+
+/* This function is called when a user inputs a wrong argument to
+   a method.
+ */
+SWIGINTERN 
+const char* Ruby_Format_TypeError( const char* msg,
+				   const char* type, 
+				   const char* name, 
+				   const int argn,
+				   VALUE input )
+{
+  char buf[128];
+  VALUE str;
+  VALUE asStr;
+  if ( msg && *msg )
+    {
+      str = rb_str_new2(msg);
+    }
+  else
+    {
+      str = rb_str_new(NULL, 0);
+    }
+
+  str = rb_str_cat2( str, "Expected argument " );
+  sprintf( buf, "%d of type ", argn-1 );
+  str = rb_str_cat2( str, buf );
+  str = rb_str_cat2( str, type );
+  str = rb_str_cat2( str, ", but got " );
+  str = rb_str_cat2( str, rb_obj_classname(input) );
+  str = rb_str_cat2( str, " " );
+  asStr = rb_inspect(input);
+  if ( RSTRING_LEN(asStr) > 30 )
+    {
+      str = rb_str_cat( str, StringValuePtr(asStr), 30 );
+      str = rb_str_cat2( str, "..." );
+    }
+  else
+    {
+      str = rb_str_append( str, asStr );
+    }
+
+  if ( name )
+    {
+      str = rb_str_cat2( str, "\n\tin SWIG method '" );
+      str = rb_str_cat2( str, name );
+      str = rb_str_cat2( str, "'" );
+    }
+
+  return StringValuePtr( str );
+}
+
+/* This function is called when an overloaded method fails */
+SWIGINTERN 
+void Ruby_Format_OverloadedError(
+				 const int argc,
+				 const int maxargs,
+				 const char* method, 
+				 const char* prototypes 
+				 )
+{
+  const char* msg = "Wrong # of arguments";
+  if ( argc <= maxargs ) msg = "Wrong arguments";
+  rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
+	   "Possible C/C++ prototypes are:\n%s",
+	   msg, method, prototypes);
+}
+
+/* -----------------------------------------------------------------------------
+ * rubytracking.swg
+ *
+ * This file contains support for tracking mappings from 
+ * Ruby objects to C++ objects.  This functionality is needed
+ * to implement mark functions for Ruby's mark and sweep
+ * garbage collector.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(ST_DATA_T_DEFINED)
+/* Needs to be explicitly included for Ruby 1.8 and earlier */
+#include <st.h>
+#endif
+
+/* Ruby 1.8 actually assumes the first case. */
+#if SIZEOF_VOIDP == SIZEOF_LONG
+#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
+#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
+#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
+#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
+#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
+#else
+#  error sizeof(void*) is not the same as long or long long
+#endif
+
+/* Global hash table to store Trackings from C/C++
+   structs to Ruby Objects. 
+*/
+static st_table* swig_ruby_trackings = NULL;
+
+static VALUE swig_ruby_trackings_count(ID id, VALUE *var) {
+  return SWIG2NUM(swig_ruby_trackings->num_entries);
+}
+
+
+/* Setup a hash table to store Trackings */
+SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
+  /* Create a hash table to store Trackings from C++
+     objects to Ruby objects. */
+
+  /* Try to see if some other .so has already created a 
+     tracking hash table, which we keep hidden in an instance var
+     in the SWIG module.
+     This is done to allow multiple DSOs to share the same
+     tracking table.
+  */
+  VALUE trackings_value = Qnil;
+  /* change the variable name so that we can mix modules
+     compiled with older SWIG's - this used to be called "@__trackings__" */
+  ID trackings_id = rb_intern( "@__safetrackings__" );
+  VALUE verbose = rb_gv_get("VERBOSE");
+  rb_gv_set("VERBOSE", Qfalse);
+  trackings_value = rb_ivar_get( _mSWIG, trackings_id );
+  rb_gv_set("VERBOSE", verbose);
+
+  /* The trick here is that we have to store the hash table
+  pointer in a Ruby variable. We do not want Ruby's GC to
+  treat this pointer as a Ruby object, so we convert it to
+  a Ruby numeric value. */
+  if (trackings_value == Qnil) {
+    /* No, it hasn't.  Create one ourselves */
+    swig_ruby_trackings = st_init_numtable();
+    rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
+  } else {
+    swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
+  }
+
+        rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", RUBY_VALUE_METHOD_FUNC(swig_ruby_trackings_count), RUBY_VOID_METHOD_FUNC((rb_gvar_setter_t*)NULL))
+;
+}
+
+/* Add a Tracking from a C/C++ struct to a Ruby object */
+SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
+  /* Store the mapping to the global hash table. */
+  st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
+}
+
+/* Get the Ruby object that owns the specified C/C++ struct */
+SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
+  /* Now lookup the value stored in the global hash table */
+  VALUE value;
+
+  if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
+    return value;
+  } else {
+    return Qnil;
+  }
+}
+
+/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
+   is very important to remove objects once they are destroyed
+   since the same memory address may be reused later to create
+   a new object. */
+SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
+  /* Delete the object from the hash table */
+  st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
+}
+
+/* This is a helper method that unlinks a Ruby object from its
+   underlying C++ object.  This is needed if the lifetime of the
+   Ruby object is longer than the C++ object */
+SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
+  VALUE object = SWIG_RubyInstanceFor(ptr);
+
+  if (object != Qnil) {
+    if (TYPE(object) != T_DATA)
+      abort();
+    DATA_PTR(object) = 0;
+  }
+}
+
+/* This is a helper method that iterates over all the trackings
+   passing the C++ object pointer and its related Ruby object
+   to the passed callback function. */
+
+/* Proxy method to abstract the internal trackings datatype */
+      static int swig_ruby_internal_iterate_callback(st_data_t ptr, st_data_t obj, st_data_t meth) {
+        ((void(*)(void*, VALUE))meth)((void*)ptr, (VALUE)obj);
+
+  return ST_CONTINUE;
+}
+
+SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
+  st_foreach(swig_ruby_trackings, RUBY_INT_METHOD_FUNC(swig_ruby_internal_iterate_callback), (st_data_t)meth);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Ruby API portion that goes into the runtime
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGINTERN VALUE
+SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
+  if (NIL_P(target)) {
+    target = o;
+  } else {
+    if (TYPE(target) != T_ARRAY) {
+      VALUE o2 = target;
+      target = rb_ary_new();
+      rb_ary_push(target, o2);
+    }
+    rb_ary_push(target, o);
+  }
+  return target;
+}
+
+/* For ruby1.8.4 and earlier. */
+#ifndef RUBY_INIT_STACK
+   RUBY_EXTERN void Init_stack(VALUE* addr);
+#  define RUBY_INIT_STACK \
+   VALUE variable_in_this_stack_frame; \
+   Init_stack(&variable_in_this_stack_frame);
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* -----------------------------------------------------------------------------
+ * rubyrun.swg
+ *
+ * This file contains the runtime support for Ruby modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
+#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
+#define swig_owntype                                    swig_ruby_owntype
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) 		SWIG_Ruby_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
+#define SWIG_Error(code, msg)            		rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
+#define SWIG_fail                        		goto fail				 
+
+
+/* Ruby-specific SWIG API */
+
+#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
+#define SWIG_define_class(ty)                        	SWIG_Ruby_define_class(ty)
+#define SWIG_NewClassInstance(value, ty)             	SWIG_Ruby_NewClassInstance(value, ty)
+#define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
+#define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  
+
+#include "assert.h"
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  VALUE klass;
+  VALUE mImpl;
+  void  (*mark)(void *);
+  void  (*destroy)(void *);
+  int trackObjects;
+} swig_class;
+
+
+/* Global pointer used to keep some internal SWIG stuff */
+static VALUE _cSWIG_Pointer = Qnil;
+static VALUE swig_runtime_data_type_pointer = Qnil;
+
+/* Global IDs used to keep some internal SWIG stuff */
+static ID swig_arity_id = 0;
+static ID swig_call_id  = 0;
+
+/*
+  If your swig extension is to be run within an embedded ruby and has
+  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
+  This will reset ruby's stack frame on each entry point from the main 
+  program the first time a virtual director function is invoked (in a 
+  non-recursive way).
+  If this is not done, you run the risk of Ruby trashing the stack.
+*/
+
+#ifdef RUBY_EMBEDDED
+
+#  define SWIG_INIT_STACK                            \
+      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
+      ++swig_virtual_calls;
+#  define SWIG_RELEASE_STACK --swig_virtual_calls;
+#  define Ruby_DirectorTypeMismatchException(x) \
+          rb_raise( rb_eTypeError, "%s", x ); return c_result;
+
+      static unsigned int swig_virtual_calls = 0;
+
+#else  /* normal non-embedded extension */
+
+#  define SWIG_INIT_STACK
+#  define SWIG_RELEASE_STACK
+#  define Ruby_DirectorTypeMismatchException(x) \
+          throw Swig::DirectorTypeMismatchException( x );
+
+#endif  /* RUBY_EMBEDDED */
+
+
+SWIGRUNTIME VALUE 
+getExceptionClass(void) {
+  static int init = 0;
+  static VALUE rubyExceptionClass ;
+  if (!init) {
+    init = 1;
+    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
+  }
+  return rubyExceptionClass;
+} 
+
+/* This code checks to see if the Ruby object being raised as part
+   of an exception inherits from the Ruby class Exception.  If so,
+   the object is simply returned.  If not, then a new Ruby exception
+   object is created and that will be returned to Ruby.*/
+SWIGRUNTIME VALUE
+SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
+  VALUE exceptionClass = getExceptionClass();
+  if (rb_obj_is_kind_of(obj, exceptionClass)) {
+    return obj;
+  }  else {
+    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
+  }
+}
+
+/* Initialize Ruby runtime support */
+SWIGRUNTIME void
+SWIG_Ruby_InitRuntime(void)
+{
+  if (_mSWIG == Qnil) {
+    _mSWIG = rb_define_module("SWIG");
+    swig_call_id  = rb_intern("call");
+    swig_arity_id = rb_intern("arity");
+  }
+}
+
+/* Define Ruby class for C type */
+SWIGRUNTIME void
+SWIG_Ruby_define_class(swig_type_info *type)
+{
+  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+  sprintf(klass_name, "TYPE%s", type->name);
+  if (NIL_P(_cSWIG_Pointer)) {
+    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
+    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
+  }
+  rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
+  free((void *) klass_name);
+}
+
+/* Create a new pointer object */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
+{
+  int own =  flags & SWIG_POINTER_OWN; 
+  int track;
+  char *klass_name;
+  swig_class *sklass;
+  VALUE klass;
+  VALUE obj;
+  
+  if (!ptr)
+    return Qnil;
+  
+  if (type->clientdata) {
+    sklass = (swig_class *) type->clientdata;
+		
+    /* Are we tracking this class and have we already returned this Ruby object? */
+    track = sklass->trackObjects;
+    if (track) {
+      obj = SWIG_RubyInstanceFor(ptr);
+      
+      /* Check the object's type and make sure it has the correct type.
+        It might not in cases where methods do things like 
+        downcast methods. */
+      if (obj != Qnil) {
+        VALUE value = rb_iv_get(obj, "@__swigtype__");
+        const char* type_name = RSTRING_PTR(value);
+				
+        if (strcmp(type->name, type_name) == 0) {
+          return obj;
+        }
+      }
+    }
+
+    /* Create a new Ruby object */
+    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
+			   ( own ? VOIDFUNC(sklass->destroy) : 
+			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
+			     ), ptr);
+
+    /* If tracking is on for this class then track this object. */
+    if (track) {
+      SWIG_RubyAddTracking(ptr, obj);
+    }
+  } else {
+    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+    sprintf(klass_name, "TYPE%s", type->name);
+    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
+    free((void *) klass_name);
+    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
+  }
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  
+  return obj;
+}
+
+/* Create a new class instance (always owned) */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
+{
+  VALUE obj;
+  swig_class *sklass = (swig_class *) type->clientdata;
+  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  return obj;
+}
+
+/* Get type mangle from class name */
+SWIGRUNTIMEINLINE char *
+SWIG_Ruby_MangleStr(VALUE obj)
+{
+  VALUE stype = rb_iv_get(obj, "@__swigtype__");
+  return StringValuePtr(stype);
+}
+
+/* Acquire a pointer value */
+typedef struct {
+  void (*datafree)(void *);
+  int own;
+} swig_ruby_owntype;
+
+SWIGRUNTIME swig_ruby_owntype
+SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
+  swig_ruby_owntype oldown = {0, 0};
+  if (obj) {
+    oldown.datafree = RDATA(obj)->dfree;
+    RDATA(obj)->dfree = own.datafree;
+  }
+  return oldown;
+}
+
+/* Convert a pointer value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
+{
+  char *c;
+  swig_cast_info *tc;
+  void *vptr = 0;
+
+  /* Grab the pointer */
+  if (NIL_P(obj)) {
+    if (ptr)
+      *ptr = 0;
+    return SWIG_OK;
+  } else {
+    if (TYPE(obj) != T_DATA) {
+      return SWIG_ERROR;
+    }
+    Data_Get_Struct(obj, void, vptr);
+  }
+  
+  if (own) {
+    own->datafree = RDATA(obj)->dfree;
+    own->own = 0;
+  }
+    
+  /* Check to see if the input object is giving up ownership
+     of the underlying C struct or C++ object.  If so then we
+     need to reset the destructor since the Ruby object no 
+     longer owns the underlying C++ object.*/ 
+  if (flags & SWIG_POINTER_DISOWN) {
+    /* Is tracking on for this class? */
+    int track = 0;
+    if (ty && ty->clientdata) {
+      swig_class *sklass = (swig_class *) ty->clientdata;
+      track = sklass->trackObjects;
+    }
+		
+    if (track) {
+      /* We are tracking objects for this class.  Thus we change the destructor
+       * to SWIG_RubyRemoveTracking.  This allows us to
+       * remove the mapping from the C++ to Ruby object
+       * when the Ruby object is garbage collected.  If we don't
+       * do this, then it is possible we will return a reference 
+       * to a Ruby object that no longer exists thereby crashing Ruby. */
+      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
+    } else {    
+      RDATA(obj)->dfree = 0;
+    }
+  }
+
+  /* Do type-checking if type info was provided */
+  if (ty) {
+    if (ty->clientdata) {
+      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
+        if (vptr == 0) {
+          /* The object has already been deleted */
+          return SWIG_ObjectPreviouslyDeletedError;
+        }
+      }
+    }
+    if ((c = SWIG_MangleStr(obj)) == NULL) {
+      return SWIG_ERROR;
+    }
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) {
+      return SWIG_ERROR;
+    } else {
+      if (ptr) {
+        if (tc->type == ty) {
+          *ptr = vptr;
+        } else {
+          int newmemory = 0;
+          *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
+          if (newmemory == SWIG_CAST_NEW_MEMORY) {
+            assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+            if (own)
+              own->own = own->own | SWIG_CAST_NEW_MEMORY;
+          }
+        }
+      }
+    }
+  } else {
+    if (ptr)
+      *ptr = vptr;
+  }
+  
+  return SWIG_OK;
+}
+
+/* Check convert */
+SWIGRUNTIMEINLINE int
+SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
+{
+  char *c = SWIG_MangleStr(obj);
+  if (!c) return 0;
+  return SWIG_TypeCheck(c,ty) != 0;
+}
+
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r, ptr, sz);
+  strcpy(r, type->name);
+  return rb_str_new2(result);
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c;
+
+  if (TYPE(obj) != T_STRING) goto type_error;
+  c = StringValuePtr(obj);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') goto type_error;
+  c++;
+  c = SWIG_UnpackData(c, ptr, sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) goto type_error;
+  }
+  return SWIG_OK;
+
+ type_error:
+  return SWIG_ERROR;
+}
+
+SWIGRUNTIME swig_module_info *
+SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
+{
+  VALUE pointer;
+  swig_module_info *ret = 0;
+  VALUE verbose = rb_gv_get("VERBOSE");
+
+ /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
+  rb_gv_set("VERBOSE", Qfalse);
+  
+  /* first check if pointer already created */
+  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  if (pointer != Qnil) {
+    Data_Get_Struct(pointer, swig_module_info, ret);
+  }
+
+  /* reinstate warnings */
+  rb_gv_set("VERBOSE", verbose);
+  return ret;
+}
+
+SWIGRUNTIME void 
+SWIG_Ruby_SetModule(swig_module_info *pointer)
+{
+  /* register a new class */
+  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
+  /* create and store the structure pointer to a global variable */
+  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
+  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
+}
+
+/* This function can be used to check whether a proc or method or similarly
+   callable function has been passed.  Usually used in a %typecheck, like:
+
+   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
+        $result = SWIG_Ruby_isCallable( $input );
+   }
+ */
+SWIGINTERN
+int SWIG_Ruby_isCallable( VALUE proc )
+{
+  if ( rb_respond_to( proc, swig_call_id ) )
+    return 1;
+  return 0;
+}
+
+/* This function can be used to check the arity (number of arguments)
+   a proc or method can take.  Usually used in a %typecheck.
+   Valid arities will be that equal to minimal or those < 0
+   which indicate a variable number of parameters at the end.
+ */
+SWIGINTERN
+int SWIG_Ruby_arity( VALUE proc, int minimal )
+{
+  if ( rb_respond_to( proc, swig_arity_id ) )
+    {
+      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
+      int arity = NUM2INT(num);
+      if ( arity < 0 && (arity+1) < -minimal ) return 1;
+      if ( arity == minimal ) return 1;
+      return 1;
+    }
+  return 0;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
+
+
+
+  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) 
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_p_FX4Splitter swig_types[0]
+#define SWIGTYPE_p_FXAccelTable swig_types[1]
+#define SWIGTYPE_p_FXApp swig_types[2]
+#define SWIGTYPE_p_FXBitmap swig_types[3]
+#define SWIGTYPE_p_FXButton swig_types[4]
+#define SWIGTYPE_p_FXCURCursor swig_types[5]
+#define SWIGTYPE_p_FXComposite swig_types[6]
+#define SWIGTYPE_p_FXCursor swig_types[7]
+#define SWIGTYPE_p_FXDataTarget swig_types[8]
+#define SWIGTYPE_p_FXDebugTarget swig_types[9]
+#define SWIGTYPE_p_FXDelegator swig_types[10]
+#define SWIGTYPE_p_FXDict swig_types[11]
+#define SWIGTYPE_p_FXDockBar swig_types[12]
+#define SWIGTYPE_p_FXDockSite swig_types[13]
+#define SWIGTYPE_p_FXDocument swig_types[14]
+#define SWIGTYPE_p_FXDragCorner swig_types[15]
+#define SWIGTYPE_p_FXDrawable swig_types[16]
+#define SWIGTYPE_p_FXFileDict swig_types[17]
+#define SWIGTYPE_p_FXFileStream swig_types[18]
+#define SWIGTYPE_p_FXFont swig_types[19]
+#define SWIGTYPE_p_FXFrame swig_types[20]
+#define SWIGTYPE_p_FXGIFCursor swig_types[21]
+#define SWIGTYPE_p_FXGroupBox swig_types[22]
+#define SWIGTYPE_p_FXHorizontalFrame swig_types[23]
+#define SWIGTYPE_p_FXIcon swig_types[24]
+#define SWIGTYPE_p_FXIconDict swig_types[25]
+#define SWIGTYPE_p_FXId swig_types[26]
+#define SWIGTYPE_p_FXMainWindow swig_types[27]
+#define SWIGTYPE_p_FXMatrix swig_types[28]
+#define SWIGTYPE_p_FXMemoryStream swig_types[29]
+#define SWIGTYPE_p_FXObject swig_types[30]
+#define SWIGTYPE_p_FXPacker swig_types[31]
+#define SWIGTYPE_p_FXPopup swig_types[32]
+#define SWIGTYPE_p_FXRecentFiles swig_types[33]
+#define SWIGTYPE_p_FXRegion swig_types[34]
+#define SWIGTYPE_p_FXRegistry swig_types[35]
+#define SWIGTYPE_p_FXRootWindow swig_types[36]
+#define SWIGTYPE_p_FXScrollArea swig_types[37]
+#define SWIGTYPE_p_FXScrollBar swig_types[38]
+#define SWIGTYPE_p_FXScrollWindow swig_types[39]
+#define SWIGTYPE_p_FXSettings swig_types[40]
+#define SWIGTYPE_p_FXShell swig_types[41]
+#define SWIGTYPE_p_FXShutter swig_types[42]
+#define SWIGTYPE_p_FXShutterItem swig_types[43]
+#define SWIGTYPE_p_FXSplashWindow swig_types[44]
+#define SWIGTYPE_p_FXSplitter swig_types[45]
+#define SWIGTYPE_p_FXSpring swig_types[46]
+#define SWIGTYPE_p_FXStatusBar swig_types[47]
+#define SWIGTYPE_p_FXStatusLine swig_types[48]
+#define SWIGTYPE_p_FXStream swig_types[49]
+#define SWIGTYPE_p_FXStringDict swig_types[50]
+#define SWIGTYPE_p_FXSwitcher swig_types[51]
+#define SWIGTYPE_p_FXTopWindow swig_types[52]
+#define SWIGTYPE_p_FXTranslator swig_types[53]
+#define SWIGTYPE_p_FXVerticalFrame swig_types[54]
+#define SWIGTYPE_p_FXVisual swig_types[55]
+#define SWIGTYPE_p_FXWindow swig_types[56]
+#define SWIGTYPE_p_char swig_types[57]
+#define SWIGTYPE_p_double swig_types[58]
+#define SWIGTYPE_p_float swig_types[59]
+#define SWIGTYPE_p_int swig_types[60]
+#define SWIGTYPE_p_long swig_types[61]
+#define SWIGTYPE_p_short swig_types[62]
+#define SWIGTYPE_p_unsigned_char swig_types[63]
+#define SWIGTYPE_p_unsigned_int swig_types[64]
+#define SWIGTYPE_p_unsigned_long swig_types[65]
+#define SWIGTYPE_p_unsigned_short swig_types[66]
+static swig_type_info *swig_types[68];
+static swig_module_info swig_module = {swig_types, 67, 0, 0, 0, 0};
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
+
+/* -------- TYPES TABLE (END) -------- */
+
+#define SWIG_init    Init_layout
+#define SWIG_name    "Layout"
+
+
+
+#define SWIG_RUBY_THREAD_BEGIN_BLOCK
+#define SWIG_RUBY_THREAD_END_BLOCK
+
+
+#define SWIGVERSION 0x030012 
+#define SWIG_VERSION SWIGVERSION
+
+
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
+
+
+#include <stdexcept>
+
+
+#include "FXRbCommon.h"
+
+
+inline FXColor to_FXColor(VALUE obj){
+  if(TYPE(obj)==T_STRING){
+    return fxcolorfromname(StringValuePtr(obj));
+    }
+  else if(TYPE(obj)==T_SYMBOL){
+    return fxcolorfromname(rb_id2name(SYM2ID(obj)));
+    }
+  else{
+    return NUM2ULONG(obj);
+    }
+  }
+
+
+inline FXString to_FXString(VALUE obj){
+  if(!NIL_P(obj)){
+    Check_Type(obj,T_STRING);
+    return FXString(StringValuePtr(obj));
+    }
+  else{
+    return FXString::null;
+    }
+  }
+
+
+inline FXbool to_FXbool(VALUE obj){
+  if (obj == Qtrue || obj == Qfalse){
+    return (obj == Qtrue) ? TRUE : FALSE;
+    }
+  else{
+    return static_cast<FXbool>(NUM2UINT(obj));
+    }
+  }
+
+
+static swig_type_info* FXEventTypeInfo=0;
+
+inline void* to_FXEvent(VALUE obj){
+  void* ptr;
+  if(!FXEventTypeInfo){
+    FXEventTypeInfo=SWIG_TypeQuery("FXEvent *");
+    FXASSERT(FXEventTypeInfo!=0);
+    }
+  SWIG_ConvertPtr(obj,&ptr,FXEventTypeInfo,1);
+  return ptr;
+  }
+
+
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
+
+
+  #define SWIG_From_long   LONG2NUM 
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_int  (int value)
+{    
+  return SWIG_From_long  (value);
+}
+
+SWIGINTERN FXPacker *new_FXPacker(FXComposite *p,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_SPACING,FXint pr=DEFAULT_SPACING,FXint pt=DEFAULT_SPACING,FXint pb=DEFAULT_SPACING,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING){
+      return new FXRbPacker(p,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_long  (unsigned long value)
+{
+  return ULONG2NUM(value); 
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_int  (unsigned int value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_bool  (bool value)
+{
+  return value ? Qtrue : Qfalse;
+}
+
+
+SWIGINTERN swig_type_info*
+SWIG_pchar_descriptor(void)
+{
+  static int init = 0;
+  static swig_type_info* info = 0;
+  if (!init) {
+    info = SWIG_TypeQuery("_p_char");
+    init = 1;
+  }
+  return info;
+}
+
+
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
+{
+  if (TYPE(obj) == T_STRING) {
+    char *cstr = StringValuePtr(obj); 
+    size_t size = RSTRING_LEN(obj) + 1;
+    if (cptr)  {
+      if (alloc) {
+	if (*alloc == SWIG_NEWOBJ) {
+	  *cptr = reinterpret_cast< char* >(memcpy(new char[size], cstr, sizeof(char)*(size)));
+	} else {
+	  *cptr = cstr;
+	  *alloc = SWIG_OLDOBJ;
+	}
+      }
+    }
+    if (psize) *psize = size;
+    return SWIG_OK;
+  } else {
+    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+    if (pchar_descriptor) {
+      void* vptr = 0;
+      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
+	if (cptr) *cptr = (char *)vptr;
+	if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
+	if (alloc) *alloc = SWIG_OLDOBJ;
+	return SWIG_OK;
+      }
+    }
+  }  
+  return SWIG_TypeError;
+}
+
+
+
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+  if (carray) {
+    if (size > LONG_MAX) {
+      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+      return pchar_descriptor ? 
+	SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : Qnil;
+    } else {
+      return rb_str_new(carray, static_cast< long >(size));
+    }
+  } else {
+    return Qnil;
+  }
+}
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtr(const char *cptr)
+{ 
+  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
+}
+
+
+static swig_type_info *FXPacker_dynamic_cast(void **ptr) {
+    FXPacker **ppPacker = reinterpret_cast<FXPacker **>(ptr);
+    FXColorSelector *pColorSelector=dynamic_cast<FXColorSelector*>(*ppPacker);
+    if(pColorSelector){
+      *ptr=reinterpret_cast<void*>(pColorSelector);
+      return SWIG_TypeQuery("FXColorSelector *");
+      }
+    FXComboBox *pComboBox=dynamic_cast<FXComboBox*>(*ppPacker);
+    if(pComboBox){
+      *ptr=reinterpret_cast<void*>(pComboBox);
+      return SWIG_TypeQuery("FXComboBox *");
+      }
+    FXDirSelector *pDirSelector=dynamic_cast<FXDirSelector*>(*ppPacker);
+    if(pDirSelector){
+      *ptr=reinterpret_cast<void*>(pDirSelector);
+      return SWIG_TypeQuery("FXDirSelector *");
+      }
+    FXDockBar *pDockBar=dynamic_cast<FXDockBar*>(*ppPacker);
+    if(pDockBar){
+      *ptr=reinterpret_cast<void*>(pDockBar);
+      return SWIG_TypeQuery("FXDockBar *");
+      }
+    FXDockSite *pDockSite=dynamic_cast<FXDockSite*>(*ppPacker);
+    if(pDockSite){
+      *ptr=reinterpret_cast<void*>(pDockSite);
+      return SWIG_TypeQuery("FXDockSite *");
+      }
+    FXFileSelector *pFileSelector=dynamic_cast<FXFileSelector*>(*ppPacker);
+    if(pFileSelector){
+      *ptr=reinterpret_cast<void*>(pFileSelector);
+      return SWIG_TypeQuery("FXFileSelector *");
+      }
+    FXFontSelector *pFontSelector=dynamic_cast<FXFontSelector*>(*ppPacker);
+    if(pFontSelector){
+      *ptr=reinterpret_cast<void*>(pFontSelector);
+      return SWIG_TypeQuery("FXFontSelector *");
+      }
+    FXGroupBox *pGroupBox=dynamic_cast<FXGroupBox*>(*ppPacker);
+    if(pGroupBox){
+      *ptr=reinterpret_cast<void*>(pGroupBox);
+      return SWIG_TypeQuery("FXGroupBox *");
+      }
+    FXHorizontalFrame *pHorizontalFrame=dynamic_cast<FXHorizontalFrame*>(*ppPacker);
+    if(pHorizontalFrame){
+      *ptr=reinterpret_cast<void*>(pHorizontalFrame);
+      return SWIG_TypeQuery("FXHorizontalFrame *");
+      }
+    FXListBox *pListBox=dynamic_cast<FXListBox*>(*ppPacker);
+    if(pListBox){
+      *ptr=reinterpret_cast<void*>(pListBox);
+      return SWIG_TypeQuery("FXListBox *");
+      }
+    FXMatrix *pMatrix=dynamic_cast<FXMatrix*>(*ppPacker);
+    if(pMatrix){
+      *ptr=reinterpret_cast<void*>(pMatrix);
+      return SWIG_TypeQuery("FXMatrix *");
+      }
+    FXRealSpinner *pRealSpinner=dynamic_cast<FXRealSpinner*>(*ppPacker);
+    if(pRealSpinner){
+      *ptr=reinterpret_cast<void*>(pRealSpinner);
+      return SWIG_TypeQuery("FXRealSpinner *");
+      }
+    FXSpinner *pSpinner=dynamic_cast<FXSpinner*>(*ppPacker);
+    if(pSpinner){
+      *ptr=reinterpret_cast<void*>(pSpinner);
+      return SWIG_TypeQuery("FXSpinner *");
+      }
+    FXSwitcher *pSwitcher=dynamic_cast<FXSwitcher*>(*ppPacker);
+    if(pSwitcher){
+      *ptr=reinterpret_cast<void*>(pSwitcher);
+      return SWIG_TypeQuery("FXSwitcher *");
+      }
+    FXTabBar *pTabBar=dynamic_cast<FXTabBar*>(*ppPacker);
+    if(pTabBar){
+      *ptr=reinterpret_cast<void*>(pTabBar);
+      return SWIG_TypeQuery("FXTabBar *");
+      }
+    FXTreeListBox *pTreeListBox=dynamic_cast<FXTreeListBox*>(*ppPacker);
+    if(pTreeListBox){
+      *ptr=reinterpret_cast<void*>(pTreeListBox);
+      return SWIG_TypeQuery("FXTreeListBox *");
+      }
+    FXVerticalFrame *pVerticalFrame=dynamic_cast<FXVerticalFrame*>(*ppPacker);
+    if(pVerticalFrame){
+      *ptr=reinterpret_cast<void*>(pVerticalFrame);
+      return SWIG_TypeQuery("FXVerticalFrame *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXDockSite *new_FXDockSite(FXComposite *p,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=0,FXint pr=0,FXint pt=0,FXint pb=0,FXint hs=0,FXint vs=0){
+      return new FXRbDockSite(p,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+SWIGINTERN FXSpring *new_FXSpring(FXComposite *p,FXuint opts=0,FXint relw=0,FXint relh=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_SPACING,FXint pr=DEFAULT_SPACING,FXint pt=DEFAULT_SPACING,FXint pb=DEFAULT_SPACING,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING){
+      return new FXRbSpring(p,opts,relw,relh,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+SWIGINTERN FXHorizontalFrame *new_FXHorizontalFrame(FXComposite *p,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_SPACING,FXint pr=DEFAULT_SPACING,FXint pt=DEFAULT_SPACING,FXint pb=DEFAULT_SPACING,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING){
+      return new FXRbHorizontalFrame(p,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+
+static swig_type_info *FXHorizontalFrame_dynamic_cast(void **ptr) {
+    FXHorizontalFrame **ppHorizontalFrame = reinterpret_cast<FXHorizontalFrame **>(ptr);
+    FXStatusBar *pStatusBar=dynamic_cast<FXStatusBar*>(*ppHorizontalFrame);
+    if(pStatusBar){
+      *ptr=reinterpret_cast<void*>(pStatusBar);
+      return SWIG_TypeQuery("FXStatusBar *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXVerticalFrame *new_FXVerticalFrame(FXComposite *p,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_SPACING,FXint pr=DEFAULT_SPACING,FXint pt=DEFAULT_SPACING,FXint pb=DEFAULT_SPACING,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING){
+      return new FXRbVerticalFrame(p,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+
+static swig_type_info *FXVerticalFrame_dynamic_cast(void **ptr) {
+    FXVerticalFrame **ppVerticalFrame = reinterpret_cast<FXVerticalFrame **>(ptr);
+    FXShutter *pShutter=dynamic_cast<FXShutter*>(*ppVerticalFrame);
+    if(pShutter){
+      *ptr=reinterpret_cast<void*>(pShutter);
+      return SWIG_TypeQuery("FXShutter *");
+      }
+    FXShutterItem *pShutterItem=dynamic_cast<FXShutterItem*>(*ppVerticalFrame);
+    if(pShutterItem){
+      *ptr=reinterpret_cast<void*>(pShutterItem);
+      return SWIG_TypeQuery("FXShutterItem *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXMatrix *new_FXMatrix(FXComposite *p,FXint n=1,FXuint opts=MATRIX_BY_ROWS,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_SPACING,FXint pr=DEFAULT_SPACING,FXint pt=DEFAULT_SPACING,FXint pb=DEFAULT_SPACING,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING){
+      return new FXRbMatrix(p,n,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+SWIGINTERN FXGroupBox *new_FXGroupBox(FXComposite *p,FXString const &text,FXuint opts=GROUPBOX_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_SPACING,FXint pr=DEFAULT_SPACING,FXint pt=DEFAULT_SPACING,FXint pb=DEFAULT_SPACING,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING){
+      return new FXRbGroupBox(p,text,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+SWIGINTERN FXSwitcher *new_FXSwitcher(FXComposite *p,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_SPACING,FXint pr=DEFAULT_SPACING,FXint pt=DEFAULT_SPACING,FXint pb=DEFAULT_SPACING){
+      return new FXRbSwitcher(p,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN FXShutterItem *new_FXShutterItem(FXShutter *p,FXString const &text=FXString::null,FXIcon *icon=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_SPACING,FXint pr=DEFAULT_SPACING,FXint pt=DEFAULT_SPACING,FXint pb=DEFAULT_SPACING,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING){
+      return new FXRbShutterItem(p,text,icon,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+SWIGINTERN FXShutter *new_FXShutter(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_SPACING,FXint pr=DEFAULT_SPACING,FXint pt=DEFAULT_SPACING,FXint pb=DEFAULT_SPACING,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING){
+      return new FXRbShutter(p,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+SWIGINTERN FXSplitter *new_FXSplitter__SWIG_0(FXComposite *p,FXuint opts=SPLITTER_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbSplitter(p,opts,x,y,w,h);
+      }
+SWIGINTERN FXSplitter *new_FXSplitter__SWIG_1(FXComposite *p,FXObject *tgt,FXSelector sel,FXuint opts=SPLITTER_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbSplitter(p,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN FX4Splitter *new_FX4Splitter__SWIG_0(FXComposite *p,FXuint opts=FOURSPLITTER_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRb4Splitter(p,opts,x,y,w,h);
+      }
+SWIGINTERN FX4Splitter *new_FX4Splitter__SWIG_1(FXComposite *p,FXObject *tgt,FXSelector sel,FXuint opts=FOURSPLITTER_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRb4Splitter(p,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN FXStatusBar *new_FXStatusBar(FXComposite *p,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=3,FXint pr=3,FXint pt=2,FXint pb=2,FXint hs=4,FXint vs=0){
+      return new FXRbStatusBar(p,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+SWIGINTERN FXScrollArea *new_FXScrollArea(FXComposite *p,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbScrollArea(p,opts,x,y,w,h);
+      }
+SWIGINTERN VALUE FXScrollArea_position__SWIG_1(FXScrollArea const *self){
+    FXint x, y;
+    self->getPosition(x, y);
+    VALUE pos = rb_ary_new();
+    rb_ary_push(pos, INT2NUM(x));
+    rb_ary_push(pos, INT2NUM(y));
+    return pos;
+  }
+
+static swig_type_info *FXScrollArea_dynamic_cast(void **ptr) {
+    FXScrollArea **ppScrollArea = reinterpret_cast<FXScrollArea **>(ptr);
+    FXBitmapView *pBitmapView=dynamic_cast<FXBitmapView*>(*ppScrollArea);
+    if(pBitmapView){
+      *ptr=reinterpret_cast<void*>(pBitmapView);
+      return SWIG_TypeQuery("FXBitmapView *");
+      }
+    FXFoldingList *pFoldingList=dynamic_cast<FXFoldingList*>(*ppScrollArea);
+    if(pFoldingList){
+      *ptr=reinterpret_cast<void*>(pFoldingList);
+      return SWIG_TypeQuery("FXFoldingList *");
+      }
+    FXIconList *pIconList=dynamic_cast<FXIconList*>(*ppScrollArea);
+    if(pIconList){
+      *ptr=reinterpret_cast<void*>(pIconList);
+      return SWIG_TypeQuery("FXIconList *");
+      }
+    FXImageView *pImageView=dynamic_cast<FXImageView*>(*ppScrollArea);
+    if(pImageView){
+      *ptr=reinterpret_cast<void*>(pImageView);
+      return SWIG_TypeQuery("FXImageView *");
+      }
+    FXList *pList=dynamic_cast<FXList*>(*ppScrollArea);
+    if(pList){
+      *ptr=reinterpret_cast<void*>(pList);
+      return SWIG_TypeQuery("FXList *");
+      }
+    FXMDIClient *pMDIClient=dynamic_cast<FXMDIClient*>(*ppScrollArea);
+    if(pMDIClient){
+      *ptr=reinterpret_cast<void*>(pMDIClient);
+      return SWIG_TypeQuery("FXMDIClient *");
+      }
+    FXScrollWindow *pScrollWindow=dynamic_cast<FXScrollWindow*>(*ppScrollArea);
+    if(pScrollWindow){
+      *ptr=reinterpret_cast<void*>(pScrollWindow);
+      return SWIG_TypeQuery("FXScrollWindow *");
+      }
+    FXTable *pTable=dynamic_cast<FXTable*>(*ppScrollArea);
+    if(pTable){
+      *ptr=reinterpret_cast<void*>(pTable);
+      return SWIG_TypeQuery("FXTable *");
+      }
+    FXText *pText=dynamic_cast<FXText*>(*ppScrollArea);
+    if(pText){
+      *ptr=reinterpret_cast<void*>(pText);
+      return SWIG_TypeQuery("FXText *");
+      }
+    FXTreeList *pTreeList=dynamic_cast<FXTreeList*>(*ppScrollArea);
+    if(pTreeList){
+      *ptr=reinterpret_cast<void*>(pTreeList);
+      return SWIG_TypeQuery("FXTreeList *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXScrollWindow *new_FXScrollWindow(FXComposite *p,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbScrollWindow(p,opts,x,y,w,h);
+      }
+SWIGINTERN VALUE FXScrollWindow_position__SWIG_1(FXScrollWindow const *self){
+    FXint x, y;
+    self->getPosition(x, y);
+    VALUE pos = rb_ary_new();
+    rb_ary_push(pos, INT2NUM(x));
+    rb_ary_push(pos, INT2NUM(y));
+    return pos;
+  }
+static swig_class SwigClassFXPacker;
+
+SWIGINTERN VALUE
+_wrap_FXPacker_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_onFocusUp(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","onFocusUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_onFocusDown(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","onFocusDown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusDown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusDown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_onFocusLeft(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","onFocusLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusLeft", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusLeft(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_onFocusRight(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","onFocusRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusRight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusRight(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXPacker_allocate(VALUE self)
+#else
+_wrap_FXPacker_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXPacker);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXPacker(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXuint arg2 = (FXuint) 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) DEFAULT_SPACING ;
+  FXint arg8 = (FXint) DEFAULT_SPACING ;
+  FXint arg9 = (FXint) DEFAULT_SPACING ;
+  FXint arg10 = (FXint) DEFAULT_SPACING ;
+  FXint arg11 = (FXint) DEFAULT_SPACING ;
+  FXint arg12 = (FXint) DEFAULT_SPACING ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPacker *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXPacker", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXPacker *)new_FXPacker(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_setFrameStyle(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","setFrameStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setFrameStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_getFrameStyle(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker const *","getFrameStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  result = (FXuint)((FXPacker const *)arg1)->getFrameStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_setPackingHints(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","setPackingHints", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setPackingHints(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_getPackingHints(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker const *","getPackingHints", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  result = (FXuint)((FXPacker const *)arg1)->getPackingHints();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_getBorderWidth(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker const *","getBorderWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  result = (FXint)((FXPacker const *)arg1)->getBorderWidth();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_setPadTop(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","setPadTop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setPadTop(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_getPadTop(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker const *","getPadTop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  result = (FXint)((FXPacker const *)arg1)->getPadTop();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_setPadBottom(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","setPadBottom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setPadBottom(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_getPadBottom(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker const *","getPadBottom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  result = (FXint)((FXPacker const *)arg1)->getPadBottom();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_setPadLeft(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","setPadLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setPadLeft(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_getPadLeft(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker const *","getPadLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  result = (FXint)((FXPacker const *)arg1)->getPadLeft();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_setPadRight(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","setPadRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setPadRight(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_getPadRight(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker const *","getPadRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  result = (FXint)((FXPacker const *)arg1)->getPadRight();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_setHiliteColor(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","setHiliteColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setHiliteColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_getHiliteColor(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker const *","getHiliteColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  result = (FXColor)((FXPacker const *)arg1)->getHiliteColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_setShadowColor(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","setShadowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setShadowColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_getShadowColor(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker const *","getShadowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  result = (FXColor)((FXPacker const *)arg1)->getShadowColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_setBorderColor(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","setBorderColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setBorderColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_getBorderColor(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker const *","getBorderColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  result = (FXColor)((FXPacker const *)arg1)->getBorderColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_setBaseColor(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","setBaseColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setBaseColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_getBaseColor(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker const *","getBaseColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  result = (FXColor)((FXPacker const *)arg1)->getBaseColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_setHSpacing(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","setHSpacing", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setHSpacing(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_getHSpacing(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker const *","getHSpacing", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  result = (FXint)((FXPacker const *)arg1)->getHSpacing();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_setVSpacing(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","setVSpacing", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setVSpacing(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_getVSpacing(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker const *","getVSpacing", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  result = (FXint)((FXPacker const *)arg1)->getVSpacing();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_save(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXPacker_save((FXPacker const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_load(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXPacker_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_create(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  FXPacker_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_detach(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  FXPacker_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_destroy(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  FXPacker_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_resize(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXPacker_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  result = (FXint)FXPacker_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  result = (FXint)FXPacker_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXPacker_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXPacker_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  result = (bool)FXPacker_canFocus((FXPacker const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  FXPacker_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  FXPacker_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXPacker_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXPacker_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_enable(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  FXPacker_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_disable(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  FXPacker_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  FXPacker_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_lower(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  FXPacker_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_move(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXPacker_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_position(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXPacker_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_layout(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  FXPacker_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_recalc(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  FXPacker_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_reparent(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXPacker_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_show(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  FXPacker_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_hide(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  FXPacker_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  result = (bool)FXPacker_isComposite((FXPacker const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_contains(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXPacker_contains((FXPacker const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  result = (bool)FXPacker_doesSaveUnder((FXPacker const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXPacker_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_tr(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXPacker_tr((FXPacker const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  FXPacker_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  FXPacker_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXPacker_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXPacker_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXPacker_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXPacker_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXPacker, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXPacker_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXPacker, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXPacker_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXPacker, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXPacker_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXPacker_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXPacker *arg1 = (FXPacker *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXPacker, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXPacker *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXPacker * >(argp1);
+  FXPacker_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXDockSite;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXDockSite_allocate(VALUE self)
+#else
+_wrap_FXDockSite_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXDockSite);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXDockSite(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXuint arg2 = (FXuint) 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) 0 ;
+  FXint arg11 = (FXint) 0 ;
+  FXint arg12 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXDockSite *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXDockSite", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXDockSite *)new_FXDockSite(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_wrapGalleyse___(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","wrapGalleys", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->wrapGalleys(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_wrapGalleysq___(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite const *","wrapGalleys", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  result = (FXbool)((FXDockSite const *)arg1)->wrapGalleys();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_save(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDockSite_save((FXDockSite const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_load(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDockSite_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_create(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  FXDockSite_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_detach(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  FXDockSite_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_destroy(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  FXDockSite_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_resize(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDockSite_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  result = (FXint)FXDockSite_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  result = (FXint)FXDockSite_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDockSite_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDockSite_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  result = (bool)FXDockSite_canFocus((FXDockSite const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  FXDockSite_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  FXDockSite_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXDockSite_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXDockSite_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_enable(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  FXDockSite_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_disable(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  FXDockSite_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  FXDockSite_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_lower(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  FXDockSite_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_move(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDockSite_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_position(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDockSite_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_layout(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  FXDockSite_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_recalc(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  FXDockSite_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_reparent(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXDockSite_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_show(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  FXDockSite_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_hide(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  FXDockSite_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  result = (bool)FXDockSite_isComposite((FXDockSite const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_contains(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXDockSite_contains((FXDockSite const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  result = (bool)FXDockSite_doesSaveUnder((FXDockSite const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXDockSite_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_tr(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXDockSite_tr((FXDockSite const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  FXDockSite_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  FXDockSite_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXDockSite_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXDockSite_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXDockSite_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDockSite_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDockSite, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDockSite_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDockSite, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDockSite_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDockSite, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDockSite_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  FXDockSite_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_moveToolBar(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  FXDockBar *arg2 = (FXDockBar *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","moveToolBar", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDockBar *","moveToolBar", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXDockBar * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  FXDockSite_moveToolBar(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_dockToolBar__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  FXDockBar *arg2 = (FXDockBar *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","dockToolBar", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDockBar *","dockToolBar", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXDockBar * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","dockToolBar", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXDockSite_dockToolBar(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_dockToolBar__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  FXDockBar *arg2 = (FXDockBar *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","dockToolBar", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDockBar *","dockToolBar", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXDockBar * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  FXDockSite_dockToolBar(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDockSite_dockToolBar(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 5) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDockSite, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXDockBar, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXWindow, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_FXDockSite_dockToolBar__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDockSite, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXDockBar, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_FXDockSite_dockToolBar__SWIG_1(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 5, "dockToolBar", 
+    "    void dockToolBar(FXDockBar *bar, FXWindow *before)\n"
+    "    void dockToolBar(FXDockBar *bar, FXint barx, FXint bary)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockSite_undockToolBar(int argc, VALUE *argv, VALUE self) {
+  FXDockSite *arg1 = (FXDockSite *) 0 ;
+  FXDockBar *arg2 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockSite *","undockToolBar", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockSite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDockBar *","undockToolBar", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXDockBar * >(argp2);
+  FXDockSite_undockToolBar(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXSpring;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXSpring_allocate(VALUE self)
+#else
+_wrap_FXSpring_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXSpring);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSpring(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXuint arg2 = (FXuint) 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) DEFAULT_SPACING ;
+  FXint arg10 = (FXint) DEFAULT_SPACING ;
+  FXint arg11 = (FXint) DEFAULT_SPACING ;
+  FXint arg12 = (FXint) DEFAULT_SPACING ;
+  FXint arg13 = (FXint) DEFAULT_SPACING ;
+  FXint arg14 = (FXint) DEFAULT_SPACING ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXSpring *result = 0 ;
+  
+  if ((argc < 1) || (argc > 14)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXSpring", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  if (argc > 13) {
+    arg14 = NUM2INT(argv[13]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXSpring *)new_FXSpring(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_setRelativeWidth(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","setRelativeWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setRelativeWidth(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_getRelativeWidth(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring const *","getRelativeWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  result = (FXint)((FXSpring const *)arg1)->getRelativeWidth();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_setRelativeHeight(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","setRelativeHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setRelativeHeight(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_getRelativeHeight(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring const *","getRelativeHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  result = (FXint)((FXSpring const *)arg1)->getRelativeHeight();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_save(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXSpring_save((FXSpring const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_load(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXSpring_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_create(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  FXSpring_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_detach(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  FXSpring_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_destroy(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  FXSpring_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_resize(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXSpring_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  result = (FXint)FXSpring_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  result = (FXint)FXSpring_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXSpring_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXSpring_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  result = (bool)FXSpring_canFocus((FXSpring const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  FXSpring_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  FXSpring_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXSpring_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXSpring_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_enable(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  FXSpring_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_disable(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  FXSpring_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  FXSpring_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_lower(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  FXSpring_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_move(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXSpring_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_position(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXSpring_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_layout(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  FXSpring_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_recalc(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  FXSpring_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_reparent(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXSpring_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_show(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  FXSpring_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_hide(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  FXSpring_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  result = (bool)FXSpring_isComposite((FXSpring const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_contains(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXSpring_contains((FXSpring const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  result = (bool)FXSpring_doesSaveUnder((FXSpring const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXSpring_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_tr(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXSpring_tr((FXSpring const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  FXSpring_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  FXSpring_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXSpring_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXSpring_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXSpring_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXSpring_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSpring, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSpring_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSpring, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSpring_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSpring, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSpring_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpring_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXSpring *arg1 = (FXSpring *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpring, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpring *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpring * >(argp1);
+  FXSpring_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXHorizontalFrame;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXHorizontalFrame_allocate(VALUE self)
+#else
+_wrap_FXHorizontalFrame_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXHorizontalFrame);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXHorizontalFrame(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXuint arg2 = (FXuint) 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) DEFAULT_SPACING ;
+  FXint arg8 = (FXint) DEFAULT_SPACING ;
+  FXint arg9 = (FXint) DEFAULT_SPACING ;
+  FXint arg10 = (FXint) DEFAULT_SPACING ;
+  FXint arg11 = (FXint) DEFAULT_SPACING ;
+  FXint arg12 = (FXint) DEFAULT_SPACING ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXHorizontalFrame *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXHorizontalFrame", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXHorizontalFrame *)new_FXHorizontalFrame(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_save(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXHorizontalFrame_save((FXHorizontalFrame const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_load(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXHorizontalFrame_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_create(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  FXHorizontalFrame_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_detach(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  FXHorizontalFrame_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_destroy(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  FXHorizontalFrame_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_resize(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXHorizontalFrame_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  result = (FXint)FXHorizontalFrame_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  result = (FXint)FXHorizontalFrame_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXHorizontalFrame_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXHorizontalFrame_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  result = (bool)FXHorizontalFrame_canFocus((FXHorizontalFrame const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  FXHorizontalFrame_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  FXHorizontalFrame_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXHorizontalFrame_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXHorizontalFrame_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_enable(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  FXHorizontalFrame_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_disable(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  FXHorizontalFrame_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  FXHorizontalFrame_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_lower(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  FXHorizontalFrame_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_move(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXHorizontalFrame_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_position(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXHorizontalFrame_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_layout(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  FXHorizontalFrame_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_recalc(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  FXHorizontalFrame_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_reparent(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXHorizontalFrame_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_show(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  FXHorizontalFrame_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_hide(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  FXHorizontalFrame_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  result = (bool)FXHorizontalFrame_isComposite((FXHorizontalFrame const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_contains(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXHorizontalFrame_contains((FXHorizontalFrame const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  result = (bool)FXHorizontalFrame_doesSaveUnder((FXHorizontalFrame const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXHorizontalFrame_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_tr(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXHorizontalFrame_tr((FXHorizontalFrame const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  FXHorizontalFrame_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  FXHorizontalFrame_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXHorizontalFrame_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXHorizontalFrame_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXHorizontalFrame_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXHorizontalFrame_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHorizontalFrame, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXHorizontalFrame_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHorizontalFrame, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXHorizontalFrame_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXHorizontalFrame, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXHorizontalFrame_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHorizontalFrame_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXHorizontalFrame *arg1 = (FXHorizontalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHorizontalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHorizontalFrame *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHorizontalFrame * >(argp1);
+  FXHorizontalFrame_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXVerticalFrame;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXVerticalFrame_allocate(VALUE self)
+#else
+_wrap_FXVerticalFrame_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXVerticalFrame);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXVerticalFrame(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXuint arg2 = (FXuint) 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) DEFAULT_SPACING ;
+  FXint arg8 = (FXint) DEFAULT_SPACING ;
+  FXint arg9 = (FXint) DEFAULT_SPACING ;
+  FXint arg10 = (FXint) DEFAULT_SPACING ;
+  FXint arg11 = (FXint) DEFAULT_SPACING ;
+  FXint arg12 = (FXint) DEFAULT_SPACING ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVerticalFrame *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXVerticalFrame", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXVerticalFrame *)new_FXVerticalFrame(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_save(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXVerticalFrame_save((FXVerticalFrame const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_load(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXVerticalFrame_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_create(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  FXVerticalFrame_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_detach(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  FXVerticalFrame_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_destroy(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  FXVerticalFrame_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_resize(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXVerticalFrame_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  result = (FXint)FXVerticalFrame_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  result = (FXint)FXVerticalFrame_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXVerticalFrame_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXVerticalFrame_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  result = (bool)FXVerticalFrame_canFocus((FXVerticalFrame const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  FXVerticalFrame_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  FXVerticalFrame_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXVerticalFrame_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXVerticalFrame_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_enable(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  FXVerticalFrame_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_disable(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  FXVerticalFrame_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  FXVerticalFrame_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_lower(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  FXVerticalFrame_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_move(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXVerticalFrame_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_position(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXVerticalFrame_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_layout(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  FXVerticalFrame_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_recalc(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  FXVerticalFrame_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_reparent(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXVerticalFrame_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_show(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  FXVerticalFrame_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_hide(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  FXVerticalFrame_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  result = (bool)FXVerticalFrame_isComposite((FXVerticalFrame const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_contains(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXVerticalFrame_contains((FXVerticalFrame const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  result = (bool)FXVerticalFrame_doesSaveUnder((FXVerticalFrame const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXVerticalFrame_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_tr(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXVerticalFrame_tr((FXVerticalFrame const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  FXVerticalFrame_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  FXVerticalFrame_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXVerticalFrame_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXVerticalFrame_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXVerticalFrame_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXVerticalFrame_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVerticalFrame, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXVerticalFrame_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVerticalFrame, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXVerticalFrame_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXVerticalFrame, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXVerticalFrame_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXVerticalFrame_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXVerticalFrame *arg1 = (FXVerticalFrame *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXVerticalFrame, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXVerticalFrame *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXVerticalFrame * >(argp1);
+  FXVerticalFrame_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMatrix;
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_onFocusUp(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","onFocusUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_onFocusDown(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","onFocusDown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusDown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusDown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_onFocusLeft(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","onFocusLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusLeft", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusLeft(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_onFocusRight(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","onFocusRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusRight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusRight(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMatrix_allocate(VALUE self)
+#else
+_wrap_FXMatrix_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMatrix);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMatrix(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXint arg2 = (FXint) 1 ;
+  FXuint arg3 = (FXuint) MATRIX_BY_ROWS ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) DEFAULT_SPACING ;
+  FXint arg9 = (FXint) DEFAULT_SPACING ;
+  FXint arg10 = (FXint) DEFAULT_SPACING ;
+  FXint arg11 = (FXint) DEFAULT_SPACING ;
+  FXint arg12 = (FXint) DEFAULT_SPACING ;
+  FXint arg13 = (FXint) DEFAULT_SPACING ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMatrix *result = 0 ;
+  
+  if ((argc < 1) || (argc > 13)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXMatrix", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXMatrix *)new_FXMatrix(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_childAtRowCol(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix const *","childAtRowCol", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXWindow *)((FXMatrix const *)arg1)->childAtRowCol(arg2,arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_rowOfChild(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix const *","rowOfChild", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow const *","rowOfChild", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  result = (FXint)((FXMatrix const *)arg1)->rowOfChild((FXWindow const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_colOfChild(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix const *","colOfChild", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow const *","colOfChild", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  result = (FXint)((FXMatrix const *)arg1)->colOfChild((FXWindow const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_setMatrixStyle(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","setMatrixStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setMatrixStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_getMatrixStyle(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix const *","getMatrixStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  result = (FXuint)((FXMatrix const *)arg1)->getMatrixStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_setNumRows(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","setNumRows", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setNumRows(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_getNumRows(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix const *","getNumRows", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  result = (FXint)((FXMatrix const *)arg1)->getNumRows();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_setNumColumns(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","setNumColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setNumColumns(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_getNumColumns(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix const *","getNumColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  result = (FXint)((FXMatrix const *)arg1)->getNumColumns();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_save(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMatrix_save((FXMatrix const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_load(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMatrix_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_create(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  FXMatrix_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_detach(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  FXMatrix_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_destroy(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  FXMatrix_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_resize(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMatrix_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  result = (FXint)FXMatrix_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  result = (FXint)FXMatrix_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMatrix_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMatrix_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  result = (bool)FXMatrix_canFocus((FXMatrix const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  FXMatrix_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  FXMatrix_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXMatrix_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMatrix_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_enable(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  FXMatrix_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_disable(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  FXMatrix_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  FXMatrix_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_lower(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  FXMatrix_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_move(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMatrix_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_position(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXMatrix_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_layout(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  FXMatrix_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_recalc(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  FXMatrix_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_reparent(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXMatrix_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_show(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  FXMatrix_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_hide(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  FXMatrix_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  result = (bool)FXMatrix_isComposite((FXMatrix const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_contains(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXMatrix_contains((FXMatrix const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  result = (bool)FXMatrix_doesSaveUnder((FXMatrix const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXMatrix_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_tr(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXMatrix_tr((FXMatrix const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  FXMatrix_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  FXMatrix_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXMatrix_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXMatrix_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXMatrix_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMatrix_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMatrix, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMatrix_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMatrix, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMatrix_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMatrix, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMatrix_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMatrix_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXMatrix *arg1 = (FXMatrix *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMatrix, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMatrix *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMatrix * >(argp1);
+  FXMatrix_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXGroupBox;
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_onCmdSetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","onCmdSetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_onCmdGetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","onCmdGetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXGroupBox_allocate(VALUE self)
+#else
+_wrap_FXGroupBox_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXGroupBox);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXGroupBox(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXString *arg2 = 0 ;
+  FXuint arg3 = (FXuint) GROUPBOX_NORMAL ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) DEFAULT_SPACING ;
+  FXint arg9 = (FXint) DEFAULT_SPACING ;
+  FXint arg10 = (FXint) DEFAULT_SPACING ;
+  FXint arg11 = (FXint) DEFAULT_SPACING ;
+  FXint arg12 = (FXint) DEFAULT_SPACING ;
+  FXint arg13 = (FXint) DEFAULT_SPACING ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXGroupBox *result = 0 ;
+  
+  if ((argc < 2) || (argc > 13)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXGroupBox", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXGroupBox *)new_FXGroupBox(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_setText(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","setText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_getText(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox const *","getText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  result = ((FXGroupBox const *)arg1)->getText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_setGroupBoxStyle(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","setGroupBoxStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setGroupBoxStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_getGroupBoxStyle(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox const *","getGroupBoxStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  result = (FXuint)((FXGroupBox const *)arg1)->getGroupBoxStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_setFont(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  (arg1)->setFont(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_getFont(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  result = (FXFont *)((FXGroupBox const *)arg1)->getFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_setTextColor(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","setTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_getTextColor(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox const *","getTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  result = (FXColor)((FXGroupBox const *)arg1)->getTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_save(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXGroupBox_save((FXGroupBox const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_load(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXGroupBox_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_create(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  FXGroupBox_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_detach(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  FXGroupBox_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_destroy(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  FXGroupBox_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_resize(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXGroupBox_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  result = (FXint)FXGroupBox_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  result = (FXint)FXGroupBox_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXGroupBox_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXGroupBox_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  result = (bool)FXGroupBox_canFocus((FXGroupBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  FXGroupBox_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  FXGroupBox_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXGroupBox_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXGroupBox_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_enable(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  FXGroupBox_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_disable(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  FXGroupBox_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  FXGroupBox_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_lower(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  FXGroupBox_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_move(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXGroupBox_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_position(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXGroupBox_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_layout(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  FXGroupBox_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_recalc(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  FXGroupBox_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_reparent(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXGroupBox_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_show(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  FXGroupBox_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_hide(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  FXGroupBox_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  result = (bool)FXGroupBox_isComposite((FXGroupBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_contains(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXGroupBox_contains((FXGroupBox const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  result = (bool)FXGroupBox_doesSaveUnder((FXGroupBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXGroupBox_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_tr(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXGroupBox_tr((FXGroupBox const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  FXGroupBox_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  FXGroupBox_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXGroupBox_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXGroupBox_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXGroupBox_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXGroupBox_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXGroupBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXGroupBox_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXGroupBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXGroupBox_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXGroupBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXGroupBox_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXGroupBox_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXGroupBox *arg1 = (FXGroupBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXGroupBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXGroupBox *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXGroupBox * >(argp1);
+  FXGroupBox_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXSwitcher;
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXint) NUM2INT(argv[2]);
+    arg4 = static_cast<void*>(&value4);
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_onCmdOpen(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","onCmdOpen", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdOpen", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdOpen(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_onUpdOpen(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","onUpdOpen", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdOpen", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdOpen(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXSwitcher_allocate(VALUE self)
+#else
+_wrap_FXSwitcher_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXSwitcher);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSwitcher(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXuint arg2 = (FXuint) 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) DEFAULT_SPACING ;
+  FXint arg8 = (FXint) DEFAULT_SPACING ;
+  FXint arg9 = (FXint) DEFAULT_SPACING ;
+  FXint arg10 = (FXint) DEFAULT_SPACING ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXSwitcher *result = 0 ;
+  
+  if ((argc < 1) || (argc > 10)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXSwitcher", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXSwitcher *)new_FXSwitcher(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_setCurrent(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","setCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->numChildren()) {
+      rb_raise(rb_eIndexError, "switcher item index out of bounds");
+    }
+  }
+  (arg1)->setCurrent(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_getCurrent(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher const *","getCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  result = (FXint)((FXSwitcher const *)arg1)->getCurrent();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_setSwitcherStyle(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","setSwitcherStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setSwitcherStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_getSwitcherStyle(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher const *","getSwitcherStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  result = (FXuint)((FXSwitcher const *)arg1)->getSwitcherStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_save(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXSwitcher_save((FXSwitcher const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_load(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXSwitcher_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_create(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  FXSwitcher_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_detach(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  FXSwitcher_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_destroy(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  FXSwitcher_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_resize(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXSwitcher_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  result = (FXint)FXSwitcher_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  result = (FXint)FXSwitcher_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXSwitcher_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXSwitcher_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  result = (bool)FXSwitcher_canFocus((FXSwitcher const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  FXSwitcher_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  FXSwitcher_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXSwitcher_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXSwitcher_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_enable(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  FXSwitcher_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_disable(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  FXSwitcher_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  FXSwitcher_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_lower(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  FXSwitcher_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_move(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXSwitcher_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_position(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXSwitcher_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_layout(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  FXSwitcher_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_recalc(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  FXSwitcher_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_reparent(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXSwitcher_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_show(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  FXSwitcher_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_hide(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  FXSwitcher_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  result = (bool)FXSwitcher_isComposite((FXSwitcher const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_contains(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXSwitcher_contains((FXSwitcher const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  result = (bool)FXSwitcher_doesSaveUnder((FXSwitcher const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXSwitcher_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_tr(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXSwitcher_tr((FXSwitcher const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  FXSwitcher_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  FXSwitcher_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXSwitcher_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXSwitcher_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXSwitcher_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXSwitcher_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSwitcher, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSwitcher_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSwitcher, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSwitcher_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSwitcher, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSwitcher_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSwitcher_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXSwitcher *arg1 = (FXSwitcher *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSwitcher, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSwitcher *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSwitcher * >(argp1);
+  FXSwitcher_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXShutterItem;
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_onFocusUp(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","onFocusUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_onFocusDown(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","onFocusDown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusDown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusDown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_onCmdButton(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","onCmdButton", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdButton", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdButton(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXShutterItem_allocate(VALUE self)
+#else
+_wrap_FXShutterItem_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXShutterItem);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXShutterItem(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXString const &arg2_defvalue = FXString::null ;
+  FXString *arg2 = (FXString *) &arg2_defvalue ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) DEFAULT_SPACING ;
+  FXint arg10 = (FXint) DEFAULT_SPACING ;
+  FXint arg11 = (FXint) DEFAULT_SPACING ;
+  FXint arg12 = (FXint) DEFAULT_SPACING ;
+  FXint arg13 = (FXint) DEFAULT_SPACING ;
+  FXint arg14 = (FXint) DEFAULT_SPACING ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXShutterItem *result = 0 ;
+  
+  if ((argc < 1) || (argc > 14)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","FXShutterItem", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  if (argc > 1) {
+    p2 = to_FXString(argv[1]); arg2 = &p2;
+  }
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","FXShutterItem", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  if (argc > 13) {
+    arg14 = NUM2INT(argv[13]);
+  }
+  {
+    result = (FXShutterItem *)new_FXShutterItem(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_getButton(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXButton *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem const *","getButton", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  result = (FXButton *)((FXShutterItem const *)arg1)->getButton();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXButton, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_getContent(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXVerticalFrame *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem const *","getContent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  result = (FXVerticalFrame *)((FXShutterItem const *)arg1)->getContent();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXVerticalFrame, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  result = ((FXShutterItem const *)arg1)->getHelpText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_setTipText(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_getTipText(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  result = ((FXShutterItem const *)arg1)->getTipText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_save(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXShutterItem_save((FXShutterItem const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_load(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXShutterItem_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_create(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  FXShutterItem_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_detach(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  FXShutterItem_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_destroy(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  FXShutterItem_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_resize(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXShutterItem_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  result = (FXint)FXShutterItem_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  result = (FXint)FXShutterItem_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXShutterItem_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXShutterItem_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  result = (bool)FXShutterItem_canFocus((FXShutterItem const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  FXShutterItem_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  FXShutterItem_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXShutterItem_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXShutterItem_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_enable(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  FXShutterItem_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_disable(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  FXShutterItem_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  FXShutterItem_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_lower(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  FXShutterItem_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_move(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXShutterItem_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_position(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXShutterItem_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_layout(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  FXShutterItem_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_recalc(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  FXShutterItem_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_reparent(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXShutterItem_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_show(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  FXShutterItem_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_hide(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  FXShutterItem_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  result = (bool)FXShutterItem_isComposite((FXShutterItem const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_contains(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXShutterItem_contains((FXShutterItem const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  result = (bool)FXShutterItem_doesSaveUnder((FXShutterItem const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXShutterItem_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_tr(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXShutterItem_tr((FXShutterItem const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  FXShutterItem_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  FXShutterItem_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXShutterItem_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXShutterItem_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXShutterItem_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXShutterItem_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXShutterItem, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXShutterItem_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXShutterItem, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXShutterItem_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXShutterItem, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXShutterItem_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutterItem_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXShutterItem *arg1 = (FXShutterItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutterItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutterItem *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutterItem * >(argp1);
+  FXShutterItem_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXShutter;
+
+SWIGINTERN VALUE
+_wrap_FXShutter_onFocusUp(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","onFocusUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_onFocusDown(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","onFocusDown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusDown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusDown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_onTimeout(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","onTimeout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTimeout", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onTimeout(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_onOpenItem(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","onOpenItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onOpenItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onOpenItem(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXint) NUM2INT(argv[2]);
+    arg4 = static_cast<void*>(&value4);
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_onCmdOpen(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","onCmdOpen", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdOpen", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdOpen(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_onUpdOpen(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","onUpdOpen", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdOpen", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdOpen(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXShutter_allocate(VALUE self)
+#else
+_wrap_FXShutter_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXShutter);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXShutter(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) DEFAULT_SPACING ;
+  FXint arg10 = (FXint) DEFAULT_SPACING ;
+  FXint arg11 = (FXint) DEFAULT_SPACING ;
+  FXint arg12 = (FXint) DEFAULT_SPACING ;
+  FXint arg13 = (FXint) DEFAULT_SPACING ;
+  FXint arg14 = (FXint) DEFAULT_SPACING ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXShutter *result = 0 ;
+  
+  if ((argc < 1) || (argc > 14)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXShutter", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXShutter", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  if (argc > 13) {
+    arg14 = NUM2INT(argv[13]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXShutter *)new_FXShutter(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_getCurrent(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter const *","getCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  result = (FXint)((FXShutter const *)arg1)->getCurrent();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_save(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXShutter_save((FXShutter const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_load(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXShutter_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_create(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  FXShutter_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_detach(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  FXShutter_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_destroy(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  FXShutter_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_resize(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXShutter_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  result = (FXint)FXShutter_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  result = (FXint)FXShutter_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXShutter_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXShutter_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  result = (bool)FXShutter_canFocus((FXShutter const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  FXShutter_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  FXShutter_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXShutter_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXShutter_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_enable(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  FXShutter_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_disable(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  FXShutter_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  FXShutter_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_lower(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  FXShutter_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_move(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXShutter_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_position(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXShutter_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_layout(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  FXShutter_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_recalc(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  FXShutter_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_reparent(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXShutter_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_show(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  FXShutter_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_hide(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  FXShutter_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  result = (bool)FXShutter_isComposite((FXShutter const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_contains(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXShutter_contains((FXShutter const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  result = (bool)FXShutter_doesSaveUnder((FXShutter const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXShutter_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_tr(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXShutter_tr((FXShutter const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  FXShutter_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  FXShutter_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXShutter_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXShutter_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXShutter_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXShutter_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXShutter, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXShutter_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXShutter, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXShutter_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXShutter, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXShutter_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  FXShutter_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXShutter_setCurrent(int argc, VALUE *argv, VALUE self) {
+  FXShutter *arg1 = (FXShutter *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXShutter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXShutter *","setCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXShutter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXShutter_setCurrent(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXSplitter;
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_onFocusNext(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","onFocusNext", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusNext", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusNext(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_onFocusPrev(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","onFocusPrev", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusPrev", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusPrev(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_onFocusUp(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","onFocusUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_onFocusDown(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","onFocusDown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusDown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusDown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_onFocusLeft(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","onFocusLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusLeft", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusLeft(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_onFocusRight(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","onFocusRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusRight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusRight(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSplitter__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXuint arg2 = (FXuint) SPLITTER_NORMAL ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXSplitter *result = 0 ;
+  
+  if ((argc < 1) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXSplitter", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXSplitter *)new_FXSplitter__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXSplitter_allocate(VALUE self)
+#else
+_wrap_FXSplitter_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXSplitter);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSplitter__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  FXuint arg4 = (FXuint) SPLITTER_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXSplitter *result = 0 ;
+  
+  if ((argc < 3) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXSplitter", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXSplitter", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[2]);
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXSplitter *)new_FXSplitter__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXSplitter(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[8];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 8) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 1) && (argc <= 6)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComposite, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      if (argc <= 1) {
+        return _wrap_new_FXSplitter__SWIG_0(nargs, args, self);
+      }
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_new_FXSplitter__SWIG_0(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXSplitter__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXSplitter__SWIG_0(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXSplitter__SWIG_0(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                return _wrap_new_FXSplitter__SWIG_0(nargs, args, self);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 3) && (argc <= 8)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComposite, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXObject, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXSplitter__SWIG_1(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXSplitter__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXSplitter__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXSplitter__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  if (argc <= 7) {
+                    return _wrap_new_FXSplitter__SWIG_1(nargs, args, self);
+                  }
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    return _wrap_new_FXSplitter__SWIG_1(nargs, args, self);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 8, "FXSplitter.new", 
+    "    FXSplitter.new(FXComposite *p, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n"
+    "    FXSplitter.new(FXComposite *p, FXObject *tgt, FXSelector sel, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_getSplit(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter const *","getSplit", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->numChildren()) {
+      rb_raise(rb_eIndexError, "splitter panel index out of bounds");
+    }
+  }
+  result = (FXint)((FXSplitter const *)arg1)->getSplit(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_setSplit(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","setSplit", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->numChildren()) {
+      rb_raise(rb_eIndexError, "splitter panel index out of bounds");
+    }
+  }
+  (arg1)->setSplit(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_setSplitterStyle(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","setSplitterStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setSplitterStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_getSplitterStyle(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter const *","getSplitterStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  result = (FXuint)((FXSplitter const *)arg1)->getSplitterStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_setBarSize(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","setBarSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setBarSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_getBarSize(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter const *","getBarSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  result = (FXint)((FXSplitter const *)arg1)->getBarSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_save(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXSplitter_save((FXSplitter const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_load(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXSplitter_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_create(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  FXSplitter_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_detach(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  FXSplitter_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_destroy(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  FXSplitter_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_resize(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXSplitter_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  result = (FXint)FXSplitter_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  result = (FXint)FXSplitter_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXSplitter_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXSplitter_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  result = (bool)FXSplitter_canFocus((FXSplitter const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  FXSplitter_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  FXSplitter_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXSplitter_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXSplitter_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_enable(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  FXSplitter_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_disable(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  FXSplitter_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  FXSplitter_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_lower(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  FXSplitter_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_move(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXSplitter_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_position(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXSplitter_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_layout(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  FXSplitter_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_recalc(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  FXSplitter_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_reparent(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXSplitter_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_show(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  FXSplitter_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_hide(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  FXSplitter_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  result = (bool)FXSplitter_isComposite((FXSplitter const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_contains(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXSplitter_contains((FXSplitter const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  result = (bool)FXSplitter_doesSaveUnder((FXSplitter const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXSplitter_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_tr(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXSplitter_tr((FXSplitter const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  FXSplitter_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  FXSplitter_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXSplitter_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXSplitter_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXSplitter_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXSplitter_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSplitter, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSplitter_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSplitter, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSplitter_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSplitter, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSplitter_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSplitter_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXSplitter *arg1 = (FXSplitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSplitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSplitter *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSplitter * >(argp1);
+  FXSplitter_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFX4Splitter;
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_onMotion(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_onFocusUp(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","onFocusUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_onFocusDown(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","onFocusDown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusDown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusDown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_onFocusLeft(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","onFocusLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusLeft", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusLeft(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_onFocusRight(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","onFocusRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusRight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusRight(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_onCmdExpand(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","onCmdExpand", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdExpand", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdExpand", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdExpand(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_onUpdExpand(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","onUpdExpand", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdExpand", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onUpdExpand", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onUpdExpand(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FX4Splitter__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXuint arg2 = (FXuint) FOURSPLITTER_NORMAL ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FX4Splitter *result = 0 ;
+  
+  if ((argc < 1) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FX4Splitter", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FX4Splitter *)new_FX4Splitter__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FX4Splitter_allocate(VALUE self)
+#else
+_wrap_FX4Splitter_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FX4Splitter);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FX4Splitter__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  FXuint arg4 = (FXuint) FOURSPLITTER_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FX4Splitter *result = 0 ;
+  
+  if ((argc < 3) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FX4Splitter", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FX4Splitter", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[2]);
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FX4Splitter *)new_FX4Splitter__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FX4Splitter(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[8];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 8) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 1) && (argc <= 6)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComposite, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      if (argc <= 1) {
+        return _wrap_new_FX4Splitter__SWIG_0(nargs, args, self);
+      }
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_new_FX4Splitter__SWIG_0(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FX4Splitter__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FX4Splitter__SWIG_0(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FX4Splitter__SWIG_0(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                return _wrap_new_FX4Splitter__SWIG_0(nargs, args, self);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 3) && (argc <= 8)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComposite, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXObject, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FX4Splitter__SWIG_1(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FX4Splitter__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FX4Splitter__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FX4Splitter__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  if (argc <= 7) {
+                    return _wrap_new_FX4Splitter__SWIG_1(nargs, args, self);
+                  }
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    return _wrap_new_FX4Splitter__SWIG_1(nargs, args, self);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 8, "FX4Splitter.new", 
+    "    FX4Splitter.new(FXComposite *p, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n"
+    "    FX4Splitter.new(FXComposite *p, FXObject *tgt, FXSelector sel, FXuint opts, FXint x, FXint y, FXint w, FXint h)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_getTopLeft(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter const *","getTopLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  result = (FXWindow *)((FX4Splitter const *)arg1)->getTopLeft();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_getTopRight(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter const *","getTopRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  result = (FXWindow *)((FX4Splitter const *)arg1)->getTopRight();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_getBottomLeft(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter const *","getBottomLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  result = (FXWindow *)((FX4Splitter const *)arg1)->getBottomLeft();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_getBottomRight(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter const *","getBottomRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  result = (FXWindow *)((FX4Splitter const *)arg1)->getBottomRight();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_getHSplit(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter const *","getHSplit", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  result = (FXint)((FX4Splitter const *)arg1)->getHSplit();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_getVSplit(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter const *","getVSplit", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  result = (FXint)((FX4Splitter const *)arg1)->getVSplit();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_setHSplit(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","setHSplit", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setHSplit(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_setVSplit(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","setVSplit", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setVSplit(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_getSplitterStyle(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter const *","getSplitterStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  result = (FXuint)((FX4Splitter const *)arg1)->getSplitterStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_setSplitterStyle(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","setSplitterStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setSplitterStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_setBarSize(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","setBarSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setBarSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_getBarSize(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter const *","getBarSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  result = (FXint)((FX4Splitter const *)arg1)->getBarSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_setExpanded(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXuint arg2 = (FXuint) FX4Splitter::ExpandAll ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","setExpanded", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  (arg1)->setExpanded(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_getExpanded(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter const *","getExpanded", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  result = (FXuint)((FX4Splitter const *)arg1)->getExpanded();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_save(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FX4Splitter_save((FX4Splitter const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_load(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FX4Splitter_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_create(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  FX4Splitter_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_detach(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  FX4Splitter_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_destroy(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  FX4Splitter_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_resize(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FX4Splitter_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  result = (FXint)FX4Splitter_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  result = (FXint)FX4Splitter_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FX4Splitter_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FX4Splitter_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_canFocus(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  result = (bool)FX4Splitter_canFocus((FX4Splitter const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_setFocus(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  FX4Splitter_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_killFocus(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  FX4Splitter_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FX4Splitter_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_setDefault(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FX4Splitter_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_enable(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  FX4Splitter_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_disable(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  FX4Splitter_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  FX4Splitter_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_lower(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  FX4Splitter_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_move(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FX4Splitter_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_position(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FX4Splitter_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_layout(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  FX4Splitter_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_recalc(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  FX4Splitter_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_reparent(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FX4Splitter_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_show(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  FX4Splitter_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_hide(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  FX4Splitter_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_isComposite(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  result = (bool)FX4Splitter_isComposite((FX4Splitter const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_contains(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FX4Splitter_contains((FX4Splitter const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  result = (bool)FX4Splitter_doesSaveUnder((FX4Splitter const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FX4Splitter_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_tr(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FX4Splitter_tr((FX4Splitter const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  FX4Splitter_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  FX4Splitter_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FX4Splitter_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FX4Splitter_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FX4Splitter_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FX4Splitter_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FX4Splitter, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FX4Splitter_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FX4Splitter, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FX4Splitter_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FX4Splitter, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FX4Splitter_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX4Splitter_clearShape(int argc, VALUE *argv, VALUE self) {
+  FX4Splitter *arg1 = (FX4Splitter *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX4Splitter, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX4Splitter *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX4Splitter * >(argp1);
+  FX4Splitter_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXStatusBar;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXStatusBar_allocate(VALUE self)
+#else
+_wrap_FXStatusBar_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXStatusBar);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXStatusBar(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXuint arg2 = (FXuint) 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 3 ;
+  FXint arg8 = (FXint) 3 ;
+  FXint arg9 = (FXint) 2 ;
+  FXint arg10 = (FXint) 2 ;
+  FXint arg11 = (FXint) 4 ;
+  FXint arg12 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXStatusBar *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXStatusBar", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXStatusBar *)new_FXStatusBar(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_setCornerStyle(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","setCornerStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->setCornerStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_getCornerStyle(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar const *","getCornerStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  result = (FXbool)((FXStatusBar const *)arg1)->getCornerStyle();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_getStatusLine(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXStatusLine *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar const *","getStatusLine", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  result = (FXStatusLine *)((FXStatusBar const *)arg1)->getStatusLine();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXStatusLine, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_getDragCorner(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXDragCorner *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar const *","getDragCorner", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  result = (FXDragCorner *)((FXStatusBar const *)arg1)->getDragCorner();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXDragCorner, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_save(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXStatusBar_save((FXStatusBar const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_load(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXStatusBar_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_create(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  FXStatusBar_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_detach(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  FXStatusBar_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_destroy(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  FXStatusBar_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_resize(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXStatusBar_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  result = (FXint)FXStatusBar_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  result = (FXint)FXStatusBar_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXStatusBar_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXStatusBar_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  result = (bool)FXStatusBar_canFocus((FXStatusBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  FXStatusBar_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  FXStatusBar_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXStatusBar_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXStatusBar_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_enable(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  FXStatusBar_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_disable(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  FXStatusBar_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  FXStatusBar_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_lower(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  FXStatusBar_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_move(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXStatusBar_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_position(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXStatusBar_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_layout(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  FXStatusBar_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_recalc(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  FXStatusBar_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_reparent(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXStatusBar_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_show(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  FXStatusBar_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_hide(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  FXStatusBar_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  result = (bool)FXStatusBar_isComposite((FXStatusBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_contains(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXStatusBar_contains((FXStatusBar const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  result = (bool)FXStatusBar_doesSaveUnder((FXStatusBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXStatusBar_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_tr(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXStatusBar_tr((FXStatusBar const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  FXStatusBar_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  FXStatusBar_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXStatusBar_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXStatusBar_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXStatusBar_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXStatusBar_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXStatusBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXStatusBar_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXStatusBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXStatusBar_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXStatusBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXStatusBar_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXStatusBar_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXStatusBar *arg1 = (FXStatusBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXStatusBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXStatusBar *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXStatusBar * >(argp1);
+  FXStatusBar_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXScrollArea;
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_onHMouseWheel(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","onHMouseWheel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHMouseWheel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHMouseWheel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_onVMouseWheel(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","onVMouseWheel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onVMouseWheel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onVMouseWheel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_onHScrollerChanged(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","onHScrollerChanged", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHScrollerChanged", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onHScrollerChanged(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_onVScrollerChanged(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","onVScrollerChanged", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onVScrollerChanged", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onVScrollerChanged(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_onHScrollerDragged(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","onHScrollerDragged", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHScrollerDragged", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onHScrollerDragged(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_onVScrollerDragged(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","onVScrollerDragged", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onVScrollerDragged", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onVScrollerDragged(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_onAutoScroll(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","onAutoScroll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onAutoScroll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onAutoScroll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXScrollArea_allocate(VALUE self)
+#else
+_wrap_FXScrollArea_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXScrollArea);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXScrollArea(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXuint arg2 = (FXuint) 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXScrollArea *result = 0 ;
+  
+  if ((argc < 1) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXScrollArea", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXScrollArea *)new_FXScrollArea(arg1,arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_setScrollStyle(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","setScrollStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setScrollStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_getScrollStyle(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea const *","getScrollStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  result = (FXuint)((FXScrollArea const *)arg1)->getScrollStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_isHorizontalScrollable(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea const *","isHorizontalScrollable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  result = (FXbool)((FXScrollArea const *)arg1)->isHorizontalScrollable();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_isVerticalScrollable(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea const *","isVerticalScrollable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  result = (FXbool)((FXScrollArea const *)arg1)->isVerticalScrollable();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_horizontalScrollBar(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXScrollBar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea const *","horizontalScrollBar", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  result = (FXScrollBar *)((FXScrollArea const *)arg1)->horizontalScrollBar();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXScrollBar, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_verticalScrollBar(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXScrollBar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea const *","verticalScrollBar", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  result = (FXScrollBar *)((FXScrollArea const *)arg1)->verticalScrollBar();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXScrollBar, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_getXPosition(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea const *","getXPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  result = (FXint)((FXScrollArea const *)arg1)->getXPosition();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_getYPosition(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea const *","getYPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  result = (FXint)((FXScrollArea const *)arg1)->getYPosition();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_setPosition(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","setPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  (arg1)->setPosition(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_save(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXScrollArea_save((FXScrollArea const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_load(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXScrollArea_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_create(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  FXScrollArea_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_detach(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  FXScrollArea_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_destroy(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  FXScrollArea_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_resize(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXScrollArea_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  result = (FXint)FXScrollArea_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  result = (FXint)FXScrollArea_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXScrollArea_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXScrollArea_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  result = (bool)FXScrollArea_canFocus((FXScrollArea const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  FXScrollArea_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  FXScrollArea_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXScrollArea_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXScrollArea_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_enable(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  FXScrollArea_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_disable(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  FXScrollArea_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  FXScrollArea_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_lower(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  FXScrollArea_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_move(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXScrollArea_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXScrollArea_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_layout(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  FXScrollArea_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_recalc(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  FXScrollArea_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_reparent(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXScrollArea_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_show(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  FXScrollArea_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_hide(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  FXScrollArea_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  result = (bool)FXScrollArea_isComposite((FXScrollArea const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_contains(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXScrollArea_contains((FXScrollArea const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  result = (bool)FXScrollArea_doesSaveUnder((FXScrollArea const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXScrollArea_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_tr(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXScrollArea_tr((FXScrollArea const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  FXScrollArea_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  FXScrollArea_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXScrollArea_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXScrollArea_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXScrollArea_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXScrollArea_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScrollArea, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXScrollArea_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScrollArea, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXScrollArea_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScrollArea, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXScrollArea_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  FXScrollArea_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_getViewportHeight(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","getViewportHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  result = (FXint)FXScrollArea_getViewportHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_getViewportWidth(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","getViewportWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  result = (FXint)FXScrollArea_getViewportWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_getContentHeight(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","getContentHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  result = (FXint)FXScrollArea_getContentHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_getContentWidth(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea *","getContentWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  result = (FXint)FXScrollArea_getContentWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollArea_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXScrollArea *arg1 = (FXScrollArea *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollArea, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollArea const *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollArea * >(argp1);
+  result = (VALUE)FXScrollArea_position__SWIG_1((FXScrollArea const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXScrollArea_position(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScrollArea, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXScrollArea_position__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScrollArea, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXScrollArea_position__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "position", 
+    "    void position(FXint x, FXint y, FXint w, FXint h)\n"
+    "    VALUE position()\n");
+  
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXScrollWindow;
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_onFocusSelf(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","onFocusSelf", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusSelf", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusSelf(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXScrollWindow_allocate(VALUE self)
+#else
+_wrap_FXScrollWindow_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXScrollWindow);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXScrollWindow(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXuint arg2 = (FXuint) 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXScrollWindow *result = 0 ;
+  
+  if ((argc < 1) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXScrollWindow", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXScrollWindow *)new_FXScrollWindow(arg1,arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_contentWindow(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow const *","contentWindow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  result = (FXWindow *)((FXScrollWindow const *)arg1)->contentWindow();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_save(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXScrollWindow_save((FXScrollWindow const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_load(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXScrollWindow_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_create(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  FXScrollWindow_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_detach(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  FXScrollWindow_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_destroy(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  FXScrollWindow_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_resize(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXScrollWindow_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  result = (FXint)FXScrollWindow_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  result = (FXint)FXScrollWindow_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXScrollWindow_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXScrollWindow_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  result = (bool)FXScrollWindow_canFocus((FXScrollWindow const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  FXScrollWindow_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  FXScrollWindow_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXScrollWindow_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXScrollWindow_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_enable(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  FXScrollWindow_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_disable(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  FXScrollWindow_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  FXScrollWindow_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_lower(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  FXScrollWindow_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_move(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXScrollWindow_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXScrollWindow_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_layout(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  FXScrollWindow_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_recalc(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  FXScrollWindow_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_reparent(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXScrollWindow_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_show(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  FXScrollWindow_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_hide(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  FXScrollWindow_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  result = (bool)FXScrollWindow_isComposite((FXScrollWindow const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_contains(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXScrollWindow_contains((FXScrollWindow const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  result = (bool)FXScrollWindow_doesSaveUnder((FXScrollWindow const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXScrollWindow_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_tr(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXScrollWindow_tr((FXScrollWindow const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  FXScrollWindow_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  FXScrollWindow_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXScrollWindow_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXScrollWindow_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXScrollWindow_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXScrollWindow_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScrollWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXScrollWindow_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScrollWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXScrollWindow_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScrollWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXScrollWindow_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  FXScrollWindow_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_getViewportHeight(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","getViewportHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  result = (FXint)FXScrollWindow_getViewportHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_getViewportWidth(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","getViewportWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  result = (FXint)FXScrollWindow_getViewportWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_getContentHeight(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","getContentHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  result = (FXint)FXScrollWindow_getContentHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_getContentWidth(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow *","getContentWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  result = (FXint)FXScrollWindow_getContentWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollWindow_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXScrollWindow *arg1 = (FXScrollWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollWindow const *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollWindow * >(argp1);
+  result = (VALUE)FXScrollWindow_position__SWIG_1((FXScrollWindow const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXScrollWindow_position(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScrollWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXScrollWindow_position__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScrollWindow, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXScrollWindow_position__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "position", 
+    "    void position(FXint x, FXint y, FXint w, FXint h)\n"
+    "    VALUE position()\n");
+  
+  return Qnil;
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_FXDockSiteTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXPopupTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXShutterItemTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXScrollArea *) x));
+}
+static void *_p_FXStatusBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXRootWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXShell *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXSplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FX4Splitter *) x));
+}
+static void *_p_FXPackerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXPacker *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXShutterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXMatrixTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXSpringTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXSwitcherTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXScrollWindow *) x));
+}
+static void *_p_FXDockSiteTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXFrame *) x));
+}
+static void *_p_FXPopupTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXShutterItemTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXStatusBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXCompositeTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXComposite *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXSplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXPackerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXShutterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXMatrixTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXSpringTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXSwitcherTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXShutterItemTo_p_FXVerticalFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXVerticalFrame *)  ((FXShutterItem *) x));
+}
+static void *_p_FXShutterTo_p_FXVerticalFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXVerticalFrame *)  ((FXShutter *) x));
+}
+static void *_p_FXStatusBarTo_p_FXHorizontalFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXHorizontalFrame *)  ((FXStatusBar *) x));
+}
+static void *_p_FXSettingsTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXSettings *) x));
+}
+static void *_p_FXAccelTableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXAccelTable *) x));
+}
+static void *_p_FXCompositeTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXRegistryTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *)(FXSettings *) ((FXRegistry *) x));
+}
+static void *_p_FXIconDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXIconDict *) x));
+}
+static void *_p_FXShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXPopupTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXStatusBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXRecentFilesTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXRecentFiles *) x));
+}
+static void *_p_FXDocumentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDocument *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXSplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXStringDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXStringDict *) x));
+}
+static void *_p_FXPackerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXFontTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXFont *) x));
+}
+static void *_p_FXFileDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXFileDict *) x));
+}
+static void *_p_FXDataTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDataTarget *) x));
+}
+static void *_p_FXDebugTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDebugTarget *) x));
+}
+static void *_p_FXSwitcherTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXShutterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXDelegatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDelegator *) x));
+}
+static void *_p_FXDrawableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXDrawable *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXCursor *) x));
+}
+static void *_p_FXTranslatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXTranslator *) x));
+}
+static void *_p_FXDockSiteTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDict *) x));
+}
+static void *_p_FXMatrixTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXShutterItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXIdTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXId *) x));
+}
+static void *_p_FXFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FXSpringTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXVisualTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXVisual *) x));
+}
+static void *_p_FXAppTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXApp *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXVerticalFrame *) x));
+}
+static void *_p_FXSpringTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXSpring *) x));
+}
+static void *_p_FXMatrixTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXMatrix *) x));
+}
+static void *_p_FXDockSiteTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXDockSite *) x));
+}
+static void *_p_FXShutterItemTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *) (FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXStatusBarTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *) (FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXGroupBox *) x));
+}
+static void *_p_FXSwitcherTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXSwitcher *) x));
+}
+static void *_p_FXShutterTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *) (FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXDockSiteTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FXPopupTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXShutterItemTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXStatusBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *)  ((FXWindow *) x));
+}
+static void *_p_FXCompositeTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXSplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXPackerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXShutterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXMatrixTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXSpringTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXSwitcherTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXFileStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXFileStream *) x));
+}
+static void *_p_FXMemoryStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXMemoryStream *) x));
+}
+static void *_p_FXFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FXDockSiteTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXPopupTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXShutterItemTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXStatusBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXMainWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXCompositeTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXCursor *) x));
+}
+static void *_p_FXDrawableTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXDrawable *) x));
+}
+static void *_p_FXSplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXFontTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXFont *) x));
+}
+static void *_p_FXPackerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXShutterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXVisualTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXVisual *) x));
+}
+static void *_p_FXMatrixTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXSpringTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXSwitcherTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static swig_type_info _swigt__p_FX4Splitter = {"_p_FX4Splitter", "FX4Splitter *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXBitmap = {"_p_FXBitmap", "FXBitmap *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXButton = {"_p_FXButton", "FXButton *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXComposite = {"_p_FXComposite", "FXComposite *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXPopup = {"_p_FXPopup", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplashWindow = {"_p_FXSplashWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMainWindow = {"_p_FXMainWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTopWindow = {"_p_FXTopWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRootWindow = {"_p_FXRootWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShell = {"_p_FXShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockBar = {"_p_FXDockBar", "FXDockBar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDockSite = {"_p_FXDockSite", "FXDockSite *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDragCorner = {"_p_FXDragCorner", "FXDragCorner *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDrawable = {"_p_FXDrawable", "FXDrawable *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFrame = {"_p_FXFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFont = {"_p_FXFont", "FXFont *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGroupBox = {"_p_FXGroupBox", "FXGroupBox *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXHorizontalFrame = {"_p_FXHorizontalFrame", "FXHorizontalFrame *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXIcon = {"_p_FXIcon", "FXIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXId = {"_p_FXId", "FXId *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGIFCursor = {"_p_FXGIFCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCURCursor = {"_p_FXCURCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCursor = {"_p_FXCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVisual = {"_p_FXVisual", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMatrix = {"_p_FXMatrix", "FXMatrix *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXObject = {"_p_FXObject", "FXObject *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDict = {"_p_FXDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSettings = {"_p_FXSettings", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXAccelTable = {"_p_FXAccelTable", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRegistry = {"_p_FXRegistry", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXIconDict = {"_p_FXIconDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRecentFiles = {"_p_FXRecentFiles", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDocument = {"_p_FXDocument", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStringDict = {"_p_FXStringDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileDict = {"_p_FXFileDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDebugTarget = {"_p_FXDebugTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDataTarget = {"_p_FXDataTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDelegator = {"_p_FXDelegator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTranslator = {"_p_FXTranslator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXApp = {"_p_FXApp", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPacker = {"_p_FXPacker", "FXPacker *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRegion = {"_p_FXRegion", "FXRegion *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXScrollArea = {"_p_FXScrollArea", "FXScrollArea *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXScrollBar = {"_p_FXScrollBar", "FXScrollBar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXScrollWindow = {"_p_FXScrollWindow", "FXScrollWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXShutter = {"_p_FXShutter", "FXShutter *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXShutterItem = {"_p_FXShutterItem", "FXShutterItem *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXSplitter = {"_p_FXSplitter", "FXSplitter *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXSpring = {"_p_FXSpring", "FXSpring *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXStatusBar = {"_p_FXStatusBar", "FXStatusBar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXStatusLine = {"_p_FXStatusLine", "FXStatusLine *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXStream = {"_p_FXStream", "FXStream *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFileStream = {"_p_FXFileStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMemoryStream = {"_p_FXMemoryStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSwitcher = {"_p_FXSwitcher", "FXSwitcher *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXVerticalFrame = {"_p_FXVerticalFrame", "FXVerticalFrame *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXWindow = {"_p_FXWindow", "FXWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_char = {"_p_char", "char *|FXchar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "double *|FXdouble *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_float = {"_p_float", "float *|FXfloat *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "FXint *|int *|FXInputHandle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_long = {"_p_long", "long *|FXTime *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_short = {"_p_short", "short *|FXshort *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "FXuchar *|unsigned char *|FXbool *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "FXwchar *|FXDragType *|unsigned int *|FXuint *|FXColor *|FXSelector *|FXHotKey *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|FXuval *|FXPixel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|FXushort *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_FX4Splitter,
+  &_swigt__p_FXAccelTable,
+  &_swigt__p_FXApp,
+  &_swigt__p_FXBitmap,
+  &_swigt__p_FXButton,
+  &_swigt__p_FXCURCursor,
+  &_swigt__p_FXComposite,
+  &_swigt__p_FXCursor,
+  &_swigt__p_FXDataTarget,
+  &_swigt__p_FXDebugTarget,
+  &_swigt__p_FXDelegator,
+  &_swigt__p_FXDict,
+  &_swigt__p_FXDockBar,
+  &_swigt__p_FXDockSite,
+  &_swigt__p_FXDocument,
+  &_swigt__p_FXDragCorner,
+  &_swigt__p_FXDrawable,
+  &_swigt__p_FXFileDict,
+  &_swigt__p_FXFileStream,
+  &_swigt__p_FXFont,
+  &_swigt__p_FXFrame,
+  &_swigt__p_FXGIFCursor,
+  &_swigt__p_FXGroupBox,
+  &_swigt__p_FXHorizontalFrame,
+  &_swigt__p_FXIcon,
+  &_swigt__p_FXIconDict,
+  &_swigt__p_FXId,
+  &_swigt__p_FXMainWindow,
+  &_swigt__p_FXMatrix,
+  &_swigt__p_FXMemoryStream,
+  &_swigt__p_FXObject,
+  &_swigt__p_FXPacker,
+  &_swigt__p_FXPopup,
+  &_swigt__p_FXRecentFiles,
+  &_swigt__p_FXRegion,
+  &_swigt__p_FXRegistry,
+  &_swigt__p_FXRootWindow,
+  &_swigt__p_FXScrollArea,
+  &_swigt__p_FXScrollBar,
+  &_swigt__p_FXScrollWindow,
+  &_swigt__p_FXSettings,
+  &_swigt__p_FXShell,
+  &_swigt__p_FXShutter,
+  &_swigt__p_FXShutterItem,
+  &_swigt__p_FXSplashWindow,
+  &_swigt__p_FXSplitter,
+  &_swigt__p_FXSpring,
+  &_swigt__p_FXStatusBar,
+  &_swigt__p_FXStatusLine,
+  &_swigt__p_FXStream,
+  &_swigt__p_FXStringDict,
+  &_swigt__p_FXSwitcher,
+  &_swigt__p_FXTopWindow,
+  &_swigt__p_FXTranslator,
+  &_swigt__p_FXVerticalFrame,
+  &_swigt__p_FXVisual,
+  &_swigt__p_FXWindow,
+  &_swigt__p_char,
+  &_swigt__p_double,
+  &_swigt__p_float,
+  &_swigt__p_int,
+  &_swigt__p_long,
+  &_swigt__p_short,
+  &_swigt__p_unsigned_char,
+  &_swigt__p_unsigned_int,
+  &_swigt__p_unsigned_long,
+  &_swigt__p_unsigned_short,
+};
+
+static swig_cast_info _swigc__p_FX4Splitter[] = {  {&_swigt__p_FX4Splitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBitmap[] = {  {&_swigt__p_FXBitmap, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXButton[] = {  {&_swigt__p_FXButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPopup[] = {{&_swigt__p_FXPopup, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplashWindow[] = {{&_swigt__p_FXSplashWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMainWindow[] = {{&_swigt__p_FXMainWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTopWindow[] = {{&_swigt__p_FXTopWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRootWindow[] = {{&_swigt__p_FXRootWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShell[] = {{&_swigt__p_FXShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComposite[] = {  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXComposite, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXComposite, 0, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXComposite, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXComposite, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockBar[] = {  {&_swigt__p_FXDockBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockSite[] = {  {&_swigt__p_FXDockSite, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDragCorner[] = {  {&_swigt__p_FXDragCorner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFrame[] = {{&_swigt__p_FXFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDrawable[] = {  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDrawable, 0, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXDrawable, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFont[] = {  {&_swigt__p_FXFont, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGroupBox[] = {  {&_swigt__p_FXGroupBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalFrame[] = {  {&_swigt__p_FXHorizontalFrame, 0, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXHorizontalFrame, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIcon[] = {  {&_swigt__p_FXIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGIFCursor[] = {{&_swigt__p_FXGIFCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCURCursor[] = {{&_swigt__p_FXCURCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCursor[] = {{&_swigt__p_FXCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVisual[] = {{&_swigt__p_FXVisual, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXId[] = {  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXId, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXId, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXId, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXId, 0, 0},  {&_swigt__p_FXId, 0, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXId, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXId, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXId, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXId, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXId, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXId, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXId, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXId, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXId, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXId, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMatrix[] = {  {&_swigt__p_FXMatrix, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDict[] = {{&_swigt__p_FXDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSettings[] = {{&_swigt__p_FXSettings, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXAccelTable[] = {{&_swigt__p_FXAccelTable, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegistry[] = {{&_swigt__p_FXRegistry, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIconDict[] = {{&_swigt__p_FXIconDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRecentFiles[] = {{&_swigt__p_FXRecentFiles, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDocument[] = {{&_swigt__p_FXDocument, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStringDict[] = {{&_swigt__p_FXStringDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileDict[] = {{&_swigt__p_FXFileDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDebugTarget[] = {{&_swigt__p_FXDebugTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDataTarget[] = {{&_swigt__p_FXDataTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDelegator[] = {{&_swigt__p_FXDelegator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTranslator[] = {{&_swigt__p_FXTranslator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXApp[] = {{&_swigt__p_FXApp, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXObject[] = {  {&_swigt__p_FXDict, _p_FXDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXSettings, _p_FXSettingsTo_p_FXObject, 0, 0},  {&_swigt__p_FXAccelTable, _p_FXAccelTableTo_p_FXObject, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXObject, 0, 0},  {&_swigt__p_FXRegistry, _p_FXRegistryTo_p_FXObject, 0, 0},  {&_swigt__p_FXId, _p_FXIdTo_p_FXObject, 0, 0},  {&_swigt__p_FXIconDict, _p_FXIconDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXObject, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXObject, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXRecentFiles, _p_FXRecentFilesTo_p_FXObject, 0, 0},  {&_swigt__p_FXDocument, _p_FXDocumentTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FXObject, 0, 0, 0},  {&_swigt__p_FXStringDict, _p_FXStringDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileDict, _p_FXFileDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXObject, 0, 0},  {&_swigt__p_FXDebugTarget, _p_FXDebugTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDataTarget, _p_FXDataTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXObject, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXObject, 0, 0},  {&_swigt__p_FXDelegator, _p_FXDelegatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXObject, 0, 0},  {&_swigt__p_FXTranslator, _p_FXTranslatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXApp, _p_FXAppTo_p_FXObject, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXObject, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXObject, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXObject, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPacker[] = {  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXPacker, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXPacker, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXPacker, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXPacker, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXPacker, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXPacker, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXPacker, 0, 0},  {&_swigt__p_FXPacker, 0, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXPacker, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXPacker, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXPacker, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegion[] = {  {&_swigt__p_FXRegion, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollArea[] = {  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXScrollArea, 0, 0},  {&_swigt__p_FXScrollArea, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollBar[] = {  {&_swigt__p_FXScrollBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollWindow[] = {  {&_swigt__p_FXScrollWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutter[] = {  {&_swigt__p_FXShutter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutterItem[] = {  {&_swigt__p_FXShutterItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplitter[] = {  {&_swigt__p_FXSplitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpring[] = {  {&_swigt__p_FXSpring, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusBar[] = {  {&_swigt__p_FXStatusBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusLine[] = {  {&_swigt__p_FXStatusLine, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileStream[] = {{&_swigt__p_FXFileStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMemoryStream[] = {{&_swigt__p_FXMemoryStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStream[] = {  {&_swigt__p_FXFileStream, _p_FXFileStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXMemoryStream, _p_FXMemoryStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSwitcher[] = {  {&_swigt__p_FXSwitcher, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalFrame[] = {  {&_swigt__p_FXVerticalFrame, 0, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXVerticalFrame, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXVerticalFrame, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXWindow[] = {  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXWindow, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXWindow, 0, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXWindow, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
+
+static swig_cast_info *swig_cast_initial[] = {
+  _swigc__p_FX4Splitter,
+  _swigc__p_FXAccelTable,
+  _swigc__p_FXApp,
+  _swigc__p_FXBitmap,
+  _swigc__p_FXButton,
+  _swigc__p_FXCURCursor,
+  _swigc__p_FXComposite,
+  _swigc__p_FXCursor,
+  _swigc__p_FXDataTarget,
+  _swigc__p_FXDebugTarget,
+  _swigc__p_FXDelegator,
+  _swigc__p_FXDict,
+  _swigc__p_FXDockBar,
+  _swigc__p_FXDockSite,
+  _swigc__p_FXDocument,
+  _swigc__p_FXDragCorner,
+  _swigc__p_FXDrawable,
+  _swigc__p_FXFileDict,
+  _swigc__p_FXFileStream,
+  _swigc__p_FXFont,
+  _swigc__p_FXFrame,
+  _swigc__p_FXGIFCursor,
+  _swigc__p_FXGroupBox,
+  _swigc__p_FXHorizontalFrame,
+  _swigc__p_FXIcon,
+  _swigc__p_FXIconDict,
+  _swigc__p_FXId,
+  _swigc__p_FXMainWindow,
+  _swigc__p_FXMatrix,
+  _swigc__p_FXMemoryStream,
+  _swigc__p_FXObject,
+  _swigc__p_FXPacker,
+  _swigc__p_FXPopup,
+  _swigc__p_FXRecentFiles,
+  _swigc__p_FXRegion,
+  _swigc__p_FXRegistry,
+  _swigc__p_FXRootWindow,
+  _swigc__p_FXScrollArea,
+  _swigc__p_FXScrollBar,
+  _swigc__p_FXScrollWindow,
+  _swigc__p_FXSettings,
+  _swigc__p_FXShell,
+  _swigc__p_FXShutter,
+  _swigc__p_FXShutterItem,
+  _swigc__p_FXSplashWindow,
+  _swigc__p_FXSplitter,
+  _swigc__p_FXSpring,
+  _swigc__p_FXStatusBar,
+  _swigc__p_FXStatusLine,
+  _swigc__p_FXStream,
+  _swigc__p_FXStringDict,
+  _swigc__p_FXSwitcher,
+  _swigc__p_FXTopWindow,
+  _swigc__p_FXTranslator,
+  _swigc__p_FXVerticalFrame,
+  _swigc__p_FXVisual,
+  _swigc__p_FXWindow,
+  _swigc__p_char,
+  _swigc__p_double,
+  _swigc__p_float,
+  _swigc__p_int,
+  _swigc__p_long,
+  _swigc__p_short,
+  _swigc__p_unsigned_char,
+  _swigc__p_unsigned_int,
+  _swigc__p_unsigned_long,
+  _swigc__p_unsigned_short,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned statically to an initial
+ * array. We just loop through that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded.
+ * There are three cases to handle:
+ *  1) If the cast->type has already been loaded AND the type we are adding
+ *     casting info to has not been loaded (it is in this module), THEN we
+ *     replace the cast->type pointer with the type pointer that has already
+ *     been loaded.
+ *  2) If BOTH types (the one we are adding casting info to, and the
+ *     cast->type) are loaded, THEN the cast info has already been loaded by
+ *     the previous module so we just ignore it.
+ *  3) Finally, if cast->type has not already been loaded, then we add that
+ *     swig_cast_info to the linked list (because the cast->type) pointer will
+ *     be correct.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* c-mode */
+#endif
+#endif
+
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+  size_t i;
+  swig_module_info *module_head, *iter;
+  int init;
+
+  /* check to see if the circular list has been setup, if not, set it up */
+  if (swig_module.next==0) {
+    /* Initialize the swig_module */
+    swig_module.type_initial = swig_type_initial;
+    swig_module.cast_initial = swig_cast_initial;
+    swig_module.next = &swig_module;
+    init = 1;
+  } else {
+    init = 0;
+  }
+
+  /* Try and load any already created modules */
+  module_head = SWIG_GetModule(clientdata);
+  if (!module_head) {
+    /* This is the first module loaded for this interpreter */
+    /* so set the swig module into the interpreter */
+    SWIG_SetModule(clientdata, &swig_module);
+  } else {
+    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+    iter=module_head;
+    do {
+      if (iter==&swig_module) {
+        /* Our module is already in the list, so there's nothing more to do. */
+        return;
+      }
+      iter=iter->next;
+    } while (iter!= module_head);
+
+    /* otherwise we must add our module into the list */
+    swig_module.next = module_head->next;
+    module_head->next = &swig_module;
+  }
+
+  /* When multiple interpreters are used, a module could have already been initialized in
+     a different interpreter, but not yet have a pointer in this interpreter.
+     In this case, we do not want to continue adding types... everything should be
+     set up already */
+  if (init == 0) return;
+
+  /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+  for (i = 0; i < swig_module.size; ++i) {
+    swig_type_info *type = 0;
+    swig_type_info *ret;
+    swig_cast_info *cast;
+
+#ifdef SWIGRUNTIME_DEBUG
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+
+    /* if there is another module already loaded */
+    if (swig_module.next != &swig_module) {
+      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
+    }
+    if (type) {
+      /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+      if (swig_module.type_initial[i]->clientdata) {
+	type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+      }
+    } else {
+      type = swig_module.type_initial[i];
+    }
+
+    /* Insert casting types */
+    cast = swig_module.cast_initial[i];
+    while (cast->type) {
+
+      /* Don't need to add information already in the list */
+      ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+      if (swig_module.next != &swig_module) {
+        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+      }
+      if (ret) {
+	if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+	  cast->type = ret;
+	  ret = 0;
+	} else {
+	  /* Check for casting already in the list */
+	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+	  if (!ocast) ret = 0;
+	}
+      }
+
+      if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+        if (type->cast) {
+          type->cast->prev = cast;
+          cast->next = type->cast;
+        }
+        type->cast = cast;
+      }
+      cast++;
+    }
+    /* Set entry in modules->types array equal to the type */
+    swig_module.types[i] = type;
+  }
+  swig_module.types[i] = 0;
+
+#ifdef SWIGRUNTIME_DEBUG
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+  for (i = 0; i < swig_module.size; ++i) {
+    int j = 0;
+    swig_cast_info *cast = swig_module.cast_initial[i];
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    while (cast->type) {
+      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+      cast++;
+      ++j;
+    }
+  printf("---- Total casts: %d\n",j);
+  }
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types.  It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+  size_t i;
+  swig_cast_info *equiv;
+  static int init_run = 0;
+
+  if (init_run) return;
+  init_run = 1;
+
+  for (i = 0; i < swig_module.size; i++) {
+    if (swig_module.types[i]->clientdata) {
+      equiv = swig_module.types[i]->cast;
+      while (equiv) {
+        if (!equiv->converter) {
+          if (equiv->type && !equiv->type->clientdata)
+            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+        }
+        equiv = equiv->next;
+      }
+    }
+  }
+}
+
+#ifdef __cplusplus
+#if 0
+{ /* c-mode */
+#endif
+}
+#endif
+
+/*
+
+*/
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void Init_layout(void) {
+  size_t i;
+  
+  SWIG_InitRuntime();
+  
+  
+  SWIG_InitializeModule(0);
+  for (i = 0; i < swig_module.size; i++) {
+    SWIG_define_class(swig_module.types[i]);
+  }
+  
+  SWIG_RubyInitializeTrackings();
+  
+  rb_define_const(mFox, "DEFAULT_SPACING", SWIG_From_int(static_cast< int >(DEFAULT_SPACING)));
+  
+  SwigClassFXPacker.klass = rb_define_class_under(mFox, "FXPacker", ((swig_class *) SWIGTYPE_p_FXComposite->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXPacker, (void *) &SwigClassFXPacker);
+  rb_define_alloc_func(SwigClassFXPacker.klass, _wrap_FXPacker_allocate);
+  rb_define_method(SwigClassFXPacker.klass, "initialize", VALUEFUNC(_wrap_new_FXPacker), -1);
+  rb_define_method(SwigClassFXPacker.klass, "onPaint", VALUEFUNC(_wrap_FXPacker_onPaint), -1);
+  rb_define_method(SwigClassFXPacker.klass, "onFocusUp", VALUEFUNC(_wrap_FXPacker_onFocusUp), -1);
+  rb_define_method(SwigClassFXPacker.klass, "onFocusDown", VALUEFUNC(_wrap_FXPacker_onFocusDown), -1);
+  rb_define_method(SwigClassFXPacker.klass, "onFocusLeft", VALUEFUNC(_wrap_FXPacker_onFocusLeft), -1);
+  rb_define_method(SwigClassFXPacker.klass, "onFocusRight", VALUEFUNC(_wrap_FXPacker_onFocusRight), -1);
+  rb_define_method(SwigClassFXPacker.klass, "setFrameStyle", VALUEFUNC(_wrap_FXPacker_setFrameStyle), -1);
+  rb_define_method(SwigClassFXPacker.klass, "getFrameStyle", VALUEFUNC(_wrap_FXPacker_getFrameStyle), -1);
+  rb_define_method(SwigClassFXPacker.klass, "setPackingHints", VALUEFUNC(_wrap_FXPacker_setPackingHints), -1);
+  rb_define_method(SwigClassFXPacker.klass, "getPackingHints", VALUEFUNC(_wrap_FXPacker_getPackingHints), -1);
+  rb_define_method(SwigClassFXPacker.klass, "getBorderWidth", VALUEFUNC(_wrap_FXPacker_getBorderWidth), -1);
+  rb_define_method(SwigClassFXPacker.klass, "setPadTop", VALUEFUNC(_wrap_FXPacker_setPadTop), -1);
+  rb_define_method(SwigClassFXPacker.klass, "getPadTop", VALUEFUNC(_wrap_FXPacker_getPadTop), -1);
+  rb_define_method(SwigClassFXPacker.klass, "setPadBottom", VALUEFUNC(_wrap_FXPacker_setPadBottom), -1);
+  rb_define_method(SwigClassFXPacker.klass, "getPadBottom", VALUEFUNC(_wrap_FXPacker_getPadBottom), -1);
+  rb_define_method(SwigClassFXPacker.klass, "setPadLeft", VALUEFUNC(_wrap_FXPacker_setPadLeft), -1);
+  rb_define_method(SwigClassFXPacker.klass, "getPadLeft", VALUEFUNC(_wrap_FXPacker_getPadLeft), -1);
+  rb_define_method(SwigClassFXPacker.klass, "setPadRight", VALUEFUNC(_wrap_FXPacker_setPadRight), -1);
+  rb_define_method(SwigClassFXPacker.klass, "getPadRight", VALUEFUNC(_wrap_FXPacker_getPadRight), -1);
+  rb_define_method(SwigClassFXPacker.klass, "setHiliteColor", VALUEFUNC(_wrap_FXPacker_setHiliteColor), -1);
+  rb_define_method(SwigClassFXPacker.klass, "getHiliteColor", VALUEFUNC(_wrap_FXPacker_getHiliteColor), -1);
+  rb_define_method(SwigClassFXPacker.klass, "setShadowColor", VALUEFUNC(_wrap_FXPacker_setShadowColor), -1);
+  rb_define_method(SwigClassFXPacker.klass, "getShadowColor", VALUEFUNC(_wrap_FXPacker_getShadowColor), -1);
+  rb_define_method(SwigClassFXPacker.klass, "setBorderColor", VALUEFUNC(_wrap_FXPacker_setBorderColor), -1);
+  rb_define_method(SwigClassFXPacker.klass, "getBorderColor", VALUEFUNC(_wrap_FXPacker_getBorderColor), -1);
+  rb_define_method(SwigClassFXPacker.klass, "setBaseColor", VALUEFUNC(_wrap_FXPacker_setBaseColor), -1);
+  rb_define_method(SwigClassFXPacker.klass, "getBaseColor", VALUEFUNC(_wrap_FXPacker_getBaseColor), -1);
+  rb_define_method(SwigClassFXPacker.klass, "setHSpacing", VALUEFUNC(_wrap_FXPacker_setHSpacing), -1);
+  rb_define_method(SwigClassFXPacker.klass, "getHSpacing", VALUEFUNC(_wrap_FXPacker_getHSpacing), -1);
+  rb_define_method(SwigClassFXPacker.klass, "setVSpacing", VALUEFUNC(_wrap_FXPacker_setVSpacing), -1);
+  rb_define_method(SwigClassFXPacker.klass, "getVSpacing", VALUEFUNC(_wrap_FXPacker_getVSpacing), -1);
+  rb_define_method(SwigClassFXPacker.klass, "save", VALUEFUNC(_wrap_FXPacker_save), -1);
+  rb_define_method(SwigClassFXPacker.klass, "load", VALUEFUNC(_wrap_FXPacker_load), -1);
+  rb_define_method(SwigClassFXPacker.klass, "create", VALUEFUNC(_wrap_FXPacker_create), -1);
+  rb_define_method(SwigClassFXPacker.klass, "detach", VALUEFUNC(_wrap_FXPacker_detach), -1);
+  rb_define_method(SwigClassFXPacker.klass, "destroy", VALUEFUNC(_wrap_FXPacker_destroy), -1);
+  rb_define_method(SwigClassFXPacker.klass, "resize", VALUEFUNC(_wrap_FXPacker_resize), -1);
+  rb_define_method(SwigClassFXPacker.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXPacker_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXPacker.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXPacker_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXPacker.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXPacker_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXPacker.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXPacker_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXPacker.klass, "canFocus", VALUEFUNC(_wrap_FXPacker_canFocus), -1);
+  rb_define_method(SwigClassFXPacker.klass, "setFocus", VALUEFUNC(_wrap_FXPacker_setFocus), -1);
+  rb_define_method(SwigClassFXPacker.klass, "killFocus", VALUEFUNC(_wrap_FXPacker_killFocus), -1);
+  rb_define_method(SwigClassFXPacker.klass, "changeFocus", VALUEFUNC(_wrap_FXPacker_changeFocus), -1);
+  rb_define_method(SwigClassFXPacker.klass, "setDefault", VALUEFUNC(_wrap_FXPacker_setDefault), -1);
+  rb_define_method(SwigClassFXPacker.klass, "enable", VALUEFUNC(_wrap_FXPacker_enable), -1);
+  rb_define_method(SwigClassFXPacker.klass, "disable", VALUEFUNC(_wrap_FXPacker_disable), -1);
+  rb_define_method(SwigClassFXPacker.klass, "raiseWindow", VALUEFUNC(_wrap_FXPacker_raiseWindow), -1);
+  rb_define_method(SwigClassFXPacker.klass, "lower", VALUEFUNC(_wrap_FXPacker_lower), -1);
+  rb_define_method(SwigClassFXPacker.klass, "move", VALUEFUNC(_wrap_FXPacker_move), -1);
+  rb_define_method(SwigClassFXPacker.klass, "position", VALUEFUNC(_wrap_FXPacker_position), -1);
+  rb_define_method(SwigClassFXPacker.klass, "layout", VALUEFUNC(_wrap_FXPacker_layout), -1);
+  rb_define_method(SwigClassFXPacker.klass, "recalc", VALUEFUNC(_wrap_FXPacker_recalc), -1);
+  rb_define_method(SwigClassFXPacker.klass, "reparent", VALUEFUNC(_wrap_FXPacker_reparent), -1);
+  rb_define_method(SwigClassFXPacker.klass, "show", VALUEFUNC(_wrap_FXPacker_show), -1);
+  rb_define_method(SwigClassFXPacker.klass, "hide", VALUEFUNC(_wrap_FXPacker_hide), -1);
+  rb_define_method(SwigClassFXPacker.klass, "isComposite", VALUEFUNC(_wrap_FXPacker_isComposite), -1);
+  rb_define_method(SwigClassFXPacker.klass, "contains", VALUEFUNC(_wrap_FXPacker_contains), -1);
+  rb_define_method(SwigClassFXPacker.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXPacker_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXPacker.klass, "setBackColor", VALUEFUNC(_wrap_FXPacker_setBackColor), -1);
+  rb_define_method(SwigClassFXPacker.klass, "tr", VALUEFUNC(_wrap_FXPacker_tr), -1);
+  rb_define_method(SwigClassFXPacker.klass, "dropEnable", VALUEFUNC(_wrap_FXPacker_dropEnable), -1);
+  rb_define_method(SwigClassFXPacker.klass, "dropDisable", VALUEFUNC(_wrap_FXPacker_dropDisable), -1);
+  rb_define_method(SwigClassFXPacker.klass, "setShape", VALUEFUNC(_wrap_FXPacker_setShape), -1);
+  rb_define_method(SwigClassFXPacker.klass, "clearShape", VALUEFUNC(_wrap_FXPacker_clearShape), -1);
+  SwigClassFXPacker.mark = (void (*)(void *)) FXRbPacker::markfunc;
+  SwigClassFXPacker.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXPacker.trackObjects = 0;
+  
+  SWIGTYPE_p_FXPacker->dcast = (swig_dycast_func) FXPacker_dynamic_cast;
+  
+  rb_define_const(mFox, "DOCKSITE_WRAP", SWIG_From_int(static_cast< int >(DOCKSITE_WRAP)));
+  rb_define_const(mFox, "DOCKSITE_NO_WRAP", SWIG_From_int(static_cast< int >(DOCKSITE_NO_WRAP)));
+  
+  SwigClassFXDockSite.klass = rb_define_class_under(mFox, "FXDockSite", ((swig_class *) SWIGTYPE_p_FXPacker->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXDockSite, (void *) &SwigClassFXDockSite);
+  rb_define_alloc_func(SwigClassFXDockSite.klass, _wrap_FXDockSite_allocate);
+  rb_define_method(SwigClassFXDockSite.klass, "initialize", VALUEFUNC(_wrap_new_FXDockSite), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "wrapGalleys=", VALUEFUNC(_wrap_FXDockSite_wrapGalleyse___), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "wrapGalleys?", VALUEFUNC(_wrap_FXDockSite_wrapGalleysq___), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "save", VALUEFUNC(_wrap_FXDockSite_save), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "load", VALUEFUNC(_wrap_FXDockSite_load), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "create", VALUEFUNC(_wrap_FXDockSite_create), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "detach", VALUEFUNC(_wrap_FXDockSite_detach), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "destroy", VALUEFUNC(_wrap_FXDockSite_destroy), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "resize", VALUEFUNC(_wrap_FXDockSite_resize), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXDockSite_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXDockSite_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXDockSite_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXDockSite_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "canFocus", VALUEFUNC(_wrap_FXDockSite_canFocus), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "setFocus", VALUEFUNC(_wrap_FXDockSite_setFocus), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "killFocus", VALUEFUNC(_wrap_FXDockSite_killFocus), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "changeFocus", VALUEFUNC(_wrap_FXDockSite_changeFocus), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "setDefault", VALUEFUNC(_wrap_FXDockSite_setDefault), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "enable", VALUEFUNC(_wrap_FXDockSite_enable), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "disable", VALUEFUNC(_wrap_FXDockSite_disable), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "raiseWindow", VALUEFUNC(_wrap_FXDockSite_raiseWindow), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "lower", VALUEFUNC(_wrap_FXDockSite_lower), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "move", VALUEFUNC(_wrap_FXDockSite_move), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "position", VALUEFUNC(_wrap_FXDockSite_position), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "layout", VALUEFUNC(_wrap_FXDockSite_layout), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "recalc", VALUEFUNC(_wrap_FXDockSite_recalc), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "reparent", VALUEFUNC(_wrap_FXDockSite_reparent), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "show", VALUEFUNC(_wrap_FXDockSite_show), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "hide", VALUEFUNC(_wrap_FXDockSite_hide), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "isComposite", VALUEFUNC(_wrap_FXDockSite_isComposite), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "contains", VALUEFUNC(_wrap_FXDockSite_contains), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXDockSite_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "setBackColor", VALUEFUNC(_wrap_FXDockSite_setBackColor), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "tr", VALUEFUNC(_wrap_FXDockSite_tr), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "dropEnable", VALUEFUNC(_wrap_FXDockSite_dropEnable), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "dropDisable", VALUEFUNC(_wrap_FXDockSite_dropDisable), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "setShape", VALUEFUNC(_wrap_FXDockSite_setShape), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "clearShape", VALUEFUNC(_wrap_FXDockSite_clearShape), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "moveToolBar", VALUEFUNC(_wrap_FXDockSite_moveToolBar), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "dockToolBar", VALUEFUNC(_wrap_FXDockSite_dockToolBar), -1);
+  rb_define_method(SwigClassFXDockSite.klass, "undockToolBar", VALUEFUNC(_wrap_FXDockSite_undockToolBar), -1);
+  SwigClassFXDockSite.mark = (void (*)(void *)) FXRbDockSite::markfunc;
+  SwigClassFXDockSite.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXDockSite.trackObjects = 0;
+  
+  SwigClassFXSpring.klass = rb_define_class_under(mFox, "FXSpring", ((swig_class *) SWIGTYPE_p_FXPacker->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXSpring, (void *) &SwigClassFXSpring);
+  rb_define_alloc_func(SwigClassFXSpring.klass, _wrap_FXSpring_allocate);
+  rb_define_method(SwigClassFXSpring.klass, "initialize", VALUEFUNC(_wrap_new_FXSpring), -1);
+  rb_define_method(SwigClassFXSpring.klass, "setRelativeWidth", VALUEFUNC(_wrap_FXSpring_setRelativeWidth), -1);
+  rb_define_method(SwigClassFXSpring.klass, "getRelativeWidth", VALUEFUNC(_wrap_FXSpring_getRelativeWidth), -1);
+  rb_define_method(SwigClassFXSpring.klass, "setRelativeHeight", VALUEFUNC(_wrap_FXSpring_setRelativeHeight), -1);
+  rb_define_method(SwigClassFXSpring.klass, "getRelativeHeight", VALUEFUNC(_wrap_FXSpring_getRelativeHeight), -1);
+  rb_define_method(SwigClassFXSpring.klass, "save", VALUEFUNC(_wrap_FXSpring_save), -1);
+  rb_define_method(SwigClassFXSpring.klass, "load", VALUEFUNC(_wrap_FXSpring_load), -1);
+  rb_define_method(SwigClassFXSpring.klass, "create", VALUEFUNC(_wrap_FXSpring_create), -1);
+  rb_define_method(SwigClassFXSpring.klass, "detach", VALUEFUNC(_wrap_FXSpring_detach), -1);
+  rb_define_method(SwigClassFXSpring.klass, "destroy", VALUEFUNC(_wrap_FXSpring_destroy), -1);
+  rb_define_method(SwigClassFXSpring.klass, "resize", VALUEFUNC(_wrap_FXSpring_resize), -1);
+  rb_define_method(SwigClassFXSpring.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXSpring_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXSpring.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXSpring_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXSpring.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXSpring_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXSpring.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXSpring_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXSpring.klass, "canFocus", VALUEFUNC(_wrap_FXSpring_canFocus), -1);
+  rb_define_method(SwigClassFXSpring.klass, "setFocus", VALUEFUNC(_wrap_FXSpring_setFocus), -1);
+  rb_define_method(SwigClassFXSpring.klass, "killFocus", VALUEFUNC(_wrap_FXSpring_killFocus), -1);
+  rb_define_method(SwigClassFXSpring.klass, "changeFocus", VALUEFUNC(_wrap_FXSpring_changeFocus), -1);
+  rb_define_method(SwigClassFXSpring.klass, "setDefault", VALUEFUNC(_wrap_FXSpring_setDefault), -1);
+  rb_define_method(SwigClassFXSpring.klass, "enable", VALUEFUNC(_wrap_FXSpring_enable), -1);
+  rb_define_method(SwigClassFXSpring.klass, "disable", VALUEFUNC(_wrap_FXSpring_disable), -1);
+  rb_define_method(SwigClassFXSpring.klass, "raiseWindow", VALUEFUNC(_wrap_FXSpring_raiseWindow), -1);
+  rb_define_method(SwigClassFXSpring.klass, "lower", VALUEFUNC(_wrap_FXSpring_lower), -1);
+  rb_define_method(SwigClassFXSpring.klass, "move", VALUEFUNC(_wrap_FXSpring_move), -1);
+  rb_define_method(SwigClassFXSpring.klass, "position", VALUEFUNC(_wrap_FXSpring_position), -1);
+  rb_define_method(SwigClassFXSpring.klass, "layout", VALUEFUNC(_wrap_FXSpring_layout), -1);
+  rb_define_method(SwigClassFXSpring.klass, "recalc", VALUEFUNC(_wrap_FXSpring_recalc), -1);
+  rb_define_method(SwigClassFXSpring.klass, "reparent", VALUEFUNC(_wrap_FXSpring_reparent), -1);
+  rb_define_method(SwigClassFXSpring.klass, "show", VALUEFUNC(_wrap_FXSpring_show), -1);
+  rb_define_method(SwigClassFXSpring.klass, "hide", VALUEFUNC(_wrap_FXSpring_hide), -1);
+  rb_define_method(SwigClassFXSpring.klass, "isComposite", VALUEFUNC(_wrap_FXSpring_isComposite), -1);
+  rb_define_method(SwigClassFXSpring.klass, "contains", VALUEFUNC(_wrap_FXSpring_contains), -1);
+  rb_define_method(SwigClassFXSpring.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXSpring_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXSpring.klass, "setBackColor", VALUEFUNC(_wrap_FXSpring_setBackColor), -1);
+  rb_define_method(SwigClassFXSpring.klass, "tr", VALUEFUNC(_wrap_FXSpring_tr), -1);
+  rb_define_method(SwigClassFXSpring.klass, "dropEnable", VALUEFUNC(_wrap_FXSpring_dropEnable), -1);
+  rb_define_method(SwigClassFXSpring.klass, "dropDisable", VALUEFUNC(_wrap_FXSpring_dropDisable), -1);
+  rb_define_method(SwigClassFXSpring.klass, "setShape", VALUEFUNC(_wrap_FXSpring_setShape), -1);
+  rb_define_method(SwigClassFXSpring.klass, "clearShape", VALUEFUNC(_wrap_FXSpring_clearShape), -1);
+  SwigClassFXSpring.mark = (void (*)(void *)) FXRbSpring::markfunc;
+  SwigClassFXSpring.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXSpring.trackObjects = 0;
+  
+  SwigClassFXHorizontalFrame.klass = rb_define_class_under(mFox, "FXHorizontalFrame", ((swig_class *) SWIGTYPE_p_FXPacker->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXHorizontalFrame, (void *) &SwigClassFXHorizontalFrame);
+  rb_define_alloc_func(SwigClassFXHorizontalFrame.klass, _wrap_FXHorizontalFrame_allocate);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "initialize", VALUEFUNC(_wrap_new_FXHorizontalFrame), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "save", VALUEFUNC(_wrap_FXHorizontalFrame_save), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "load", VALUEFUNC(_wrap_FXHorizontalFrame_load), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "create", VALUEFUNC(_wrap_FXHorizontalFrame_create), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "detach", VALUEFUNC(_wrap_FXHorizontalFrame_detach), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "destroy", VALUEFUNC(_wrap_FXHorizontalFrame_destroy), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "resize", VALUEFUNC(_wrap_FXHorizontalFrame_resize), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXHorizontalFrame_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXHorizontalFrame_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXHorizontalFrame_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXHorizontalFrame_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "canFocus", VALUEFUNC(_wrap_FXHorizontalFrame_canFocus), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "setFocus", VALUEFUNC(_wrap_FXHorizontalFrame_setFocus), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "killFocus", VALUEFUNC(_wrap_FXHorizontalFrame_killFocus), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "changeFocus", VALUEFUNC(_wrap_FXHorizontalFrame_changeFocus), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "setDefault", VALUEFUNC(_wrap_FXHorizontalFrame_setDefault), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "enable", VALUEFUNC(_wrap_FXHorizontalFrame_enable), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "disable", VALUEFUNC(_wrap_FXHorizontalFrame_disable), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "raiseWindow", VALUEFUNC(_wrap_FXHorizontalFrame_raiseWindow), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "lower", VALUEFUNC(_wrap_FXHorizontalFrame_lower), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "move", VALUEFUNC(_wrap_FXHorizontalFrame_move), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "position", VALUEFUNC(_wrap_FXHorizontalFrame_position), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "layout", VALUEFUNC(_wrap_FXHorizontalFrame_layout), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "recalc", VALUEFUNC(_wrap_FXHorizontalFrame_recalc), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "reparent", VALUEFUNC(_wrap_FXHorizontalFrame_reparent), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "show", VALUEFUNC(_wrap_FXHorizontalFrame_show), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "hide", VALUEFUNC(_wrap_FXHorizontalFrame_hide), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "isComposite", VALUEFUNC(_wrap_FXHorizontalFrame_isComposite), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "contains", VALUEFUNC(_wrap_FXHorizontalFrame_contains), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXHorizontalFrame_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "setBackColor", VALUEFUNC(_wrap_FXHorizontalFrame_setBackColor), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "tr", VALUEFUNC(_wrap_FXHorizontalFrame_tr), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "dropEnable", VALUEFUNC(_wrap_FXHorizontalFrame_dropEnable), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "dropDisable", VALUEFUNC(_wrap_FXHorizontalFrame_dropDisable), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "setShape", VALUEFUNC(_wrap_FXHorizontalFrame_setShape), -1);
+  rb_define_method(SwigClassFXHorizontalFrame.klass, "clearShape", VALUEFUNC(_wrap_FXHorizontalFrame_clearShape), -1);
+  SwigClassFXHorizontalFrame.mark = (void (*)(void *)) FXRbHorizontalFrame::markfunc;
+  SwigClassFXHorizontalFrame.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXHorizontalFrame.trackObjects = 0;
+  
+  SWIGTYPE_p_FXHorizontalFrame->dcast = (swig_dycast_func) FXHorizontalFrame_dynamic_cast;
+  
+  
+  SwigClassFXVerticalFrame.klass = rb_define_class_under(mFox, "FXVerticalFrame", ((swig_class *) SWIGTYPE_p_FXPacker->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXVerticalFrame, (void *) &SwigClassFXVerticalFrame);
+  rb_define_alloc_func(SwigClassFXVerticalFrame.klass, _wrap_FXVerticalFrame_allocate);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "initialize", VALUEFUNC(_wrap_new_FXVerticalFrame), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "save", VALUEFUNC(_wrap_FXVerticalFrame_save), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "load", VALUEFUNC(_wrap_FXVerticalFrame_load), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "create", VALUEFUNC(_wrap_FXVerticalFrame_create), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "detach", VALUEFUNC(_wrap_FXVerticalFrame_detach), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "destroy", VALUEFUNC(_wrap_FXVerticalFrame_destroy), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "resize", VALUEFUNC(_wrap_FXVerticalFrame_resize), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXVerticalFrame_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXVerticalFrame_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXVerticalFrame_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXVerticalFrame_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "canFocus", VALUEFUNC(_wrap_FXVerticalFrame_canFocus), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "setFocus", VALUEFUNC(_wrap_FXVerticalFrame_setFocus), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "killFocus", VALUEFUNC(_wrap_FXVerticalFrame_killFocus), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "changeFocus", VALUEFUNC(_wrap_FXVerticalFrame_changeFocus), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "setDefault", VALUEFUNC(_wrap_FXVerticalFrame_setDefault), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "enable", VALUEFUNC(_wrap_FXVerticalFrame_enable), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "disable", VALUEFUNC(_wrap_FXVerticalFrame_disable), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "raiseWindow", VALUEFUNC(_wrap_FXVerticalFrame_raiseWindow), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "lower", VALUEFUNC(_wrap_FXVerticalFrame_lower), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "move", VALUEFUNC(_wrap_FXVerticalFrame_move), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "position", VALUEFUNC(_wrap_FXVerticalFrame_position), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "layout", VALUEFUNC(_wrap_FXVerticalFrame_layout), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "recalc", VALUEFUNC(_wrap_FXVerticalFrame_recalc), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "reparent", VALUEFUNC(_wrap_FXVerticalFrame_reparent), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "show", VALUEFUNC(_wrap_FXVerticalFrame_show), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "hide", VALUEFUNC(_wrap_FXVerticalFrame_hide), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "isComposite", VALUEFUNC(_wrap_FXVerticalFrame_isComposite), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "contains", VALUEFUNC(_wrap_FXVerticalFrame_contains), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXVerticalFrame_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "setBackColor", VALUEFUNC(_wrap_FXVerticalFrame_setBackColor), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "tr", VALUEFUNC(_wrap_FXVerticalFrame_tr), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "dropEnable", VALUEFUNC(_wrap_FXVerticalFrame_dropEnable), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "dropDisable", VALUEFUNC(_wrap_FXVerticalFrame_dropDisable), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "setShape", VALUEFUNC(_wrap_FXVerticalFrame_setShape), -1);
+  rb_define_method(SwigClassFXVerticalFrame.klass, "clearShape", VALUEFUNC(_wrap_FXVerticalFrame_clearShape), -1);
+  SwigClassFXVerticalFrame.mark = (void (*)(void *)) FXRbVerticalFrame::markfunc;
+  SwigClassFXVerticalFrame.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXVerticalFrame.trackObjects = 0;
+  
+  SWIGTYPE_p_FXVerticalFrame->dcast = (swig_dycast_func) FXVerticalFrame_dynamic_cast;
+  
+  rb_define_const(mFox, "MATRIX_BY_ROWS", SWIG_From_int(static_cast< int >(MATRIX_BY_ROWS)));
+  rb_define_const(mFox, "MATRIX_BY_COLUMNS", SWIG_From_int(static_cast< int >(MATRIX_BY_COLUMNS)));
+  
+  SwigClassFXMatrix.klass = rb_define_class_under(mFox, "FXMatrix", ((swig_class *) SWIGTYPE_p_FXPacker->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMatrix, (void *) &SwigClassFXMatrix);
+  rb_define_alloc_func(SwigClassFXMatrix.klass, _wrap_FXMatrix_allocate);
+  rb_define_method(SwigClassFXMatrix.klass, "initialize", VALUEFUNC(_wrap_new_FXMatrix), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "onFocusUp", VALUEFUNC(_wrap_FXMatrix_onFocusUp), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "onFocusDown", VALUEFUNC(_wrap_FXMatrix_onFocusDown), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "onFocusLeft", VALUEFUNC(_wrap_FXMatrix_onFocusLeft), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "onFocusRight", VALUEFUNC(_wrap_FXMatrix_onFocusRight), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "childAtRowCol", VALUEFUNC(_wrap_FXMatrix_childAtRowCol), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "rowOfChild", VALUEFUNC(_wrap_FXMatrix_rowOfChild), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "colOfChild", VALUEFUNC(_wrap_FXMatrix_colOfChild), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "setMatrixStyle", VALUEFUNC(_wrap_FXMatrix_setMatrixStyle), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "getMatrixStyle", VALUEFUNC(_wrap_FXMatrix_getMatrixStyle), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "setNumRows", VALUEFUNC(_wrap_FXMatrix_setNumRows), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "getNumRows", VALUEFUNC(_wrap_FXMatrix_getNumRows), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "setNumColumns", VALUEFUNC(_wrap_FXMatrix_setNumColumns), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "getNumColumns", VALUEFUNC(_wrap_FXMatrix_getNumColumns), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "save", VALUEFUNC(_wrap_FXMatrix_save), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "load", VALUEFUNC(_wrap_FXMatrix_load), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "create", VALUEFUNC(_wrap_FXMatrix_create), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "detach", VALUEFUNC(_wrap_FXMatrix_detach), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "destroy", VALUEFUNC(_wrap_FXMatrix_destroy), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "resize", VALUEFUNC(_wrap_FXMatrix_resize), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXMatrix_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXMatrix_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXMatrix_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXMatrix_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "canFocus", VALUEFUNC(_wrap_FXMatrix_canFocus), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "setFocus", VALUEFUNC(_wrap_FXMatrix_setFocus), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "killFocus", VALUEFUNC(_wrap_FXMatrix_killFocus), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "changeFocus", VALUEFUNC(_wrap_FXMatrix_changeFocus), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "setDefault", VALUEFUNC(_wrap_FXMatrix_setDefault), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "enable", VALUEFUNC(_wrap_FXMatrix_enable), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "disable", VALUEFUNC(_wrap_FXMatrix_disable), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "raiseWindow", VALUEFUNC(_wrap_FXMatrix_raiseWindow), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "lower", VALUEFUNC(_wrap_FXMatrix_lower), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "move", VALUEFUNC(_wrap_FXMatrix_move), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "position", VALUEFUNC(_wrap_FXMatrix_position), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "layout", VALUEFUNC(_wrap_FXMatrix_layout), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "recalc", VALUEFUNC(_wrap_FXMatrix_recalc), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "reparent", VALUEFUNC(_wrap_FXMatrix_reparent), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "show", VALUEFUNC(_wrap_FXMatrix_show), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "hide", VALUEFUNC(_wrap_FXMatrix_hide), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "isComposite", VALUEFUNC(_wrap_FXMatrix_isComposite), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "contains", VALUEFUNC(_wrap_FXMatrix_contains), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXMatrix_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "setBackColor", VALUEFUNC(_wrap_FXMatrix_setBackColor), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "tr", VALUEFUNC(_wrap_FXMatrix_tr), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "dropEnable", VALUEFUNC(_wrap_FXMatrix_dropEnable), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "dropDisable", VALUEFUNC(_wrap_FXMatrix_dropDisable), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "setShape", VALUEFUNC(_wrap_FXMatrix_setShape), -1);
+  rb_define_method(SwigClassFXMatrix.klass, "clearShape", VALUEFUNC(_wrap_FXMatrix_clearShape), -1);
+  SwigClassFXMatrix.mark = (void (*)(void *)) FXRbMatrix::markfunc;
+  SwigClassFXMatrix.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXMatrix.trackObjects = 0;
+  rb_define_const(mFox, "GROUPBOX_TITLE_LEFT", SWIG_From_int(static_cast< int >(GROUPBOX_TITLE_LEFT)));
+  rb_define_const(mFox, "GROUPBOX_TITLE_CENTER", SWIG_From_int(static_cast< int >(GROUPBOX_TITLE_CENTER)));
+  rb_define_const(mFox, "GROUPBOX_TITLE_RIGHT", SWIG_From_int(static_cast< int >(GROUPBOX_TITLE_RIGHT)));
+  rb_define_const(mFox, "GROUPBOX_NORMAL", SWIG_From_int(static_cast< int >(GROUPBOX_NORMAL)));
+  
+  SwigClassFXGroupBox.klass = rb_define_class_under(mFox, "FXGroupBox", ((swig_class *) SWIGTYPE_p_FXPacker->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXGroupBox, (void *) &SwigClassFXGroupBox);
+  rb_define_alloc_func(SwigClassFXGroupBox.klass, _wrap_FXGroupBox_allocate);
+  rb_define_method(SwigClassFXGroupBox.klass, "initialize", VALUEFUNC(_wrap_new_FXGroupBox), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "onPaint", VALUEFUNC(_wrap_FXGroupBox_onPaint), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXGroupBox_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "onCmdSetStringValue", VALUEFUNC(_wrap_FXGroupBox_onCmdSetStringValue), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "onCmdGetStringValue", VALUEFUNC(_wrap_FXGroupBox_onCmdGetStringValue), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "setText", VALUEFUNC(_wrap_FXGroupBox_setText), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "getText", VALUEFUNC(_wrap_FXGroupBox_getText), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "setGroupBoxStyle", VALUEFUNC(_wrap_FXGroupBox_setGroupBoxStyle), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "getGroupBoxStyle", VALUEFUNC(_wrap_FXGroupBox_getGroupBoxStyle), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "setFont", VALUEFUNC(_wrap_FXGroupBox_setFont), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "getFont", VALUEFUNC(_wrap_FXGroupBox_getFont), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "setTextColor", VALUEFUNC(_wrap_FXGroupBox_setTextColor), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "getTextColor", VALUEFUNC(_wrap_FXGroupBox_getTextColor), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "save", VALUEFUNC(_wrap_FXGroupBox_save), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "load", VALUEFUNC(_wrap_FXGroupBox_load), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "create", VALUEFUNC(_wrap_FXGroupBox_create), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "detach", VALUEFUNC(_wrap_FXGroupBox_detach), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "destroy", VALUEFUNC(_wrap_FXGroupBox_destroy), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "resize", VALUEFUNC(_wrap_FXGroupBox_resize), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXGroupBox_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXGroupBox_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXGroupBox_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXGroupBox_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "canFocus", VALUEFUNC(_wrap_FXGroupBox_canFocus), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "setFocus", VALUEFUNC(_wrap_FXGroupBox_setFocus), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "killFocus", VALUEFUNC(_wrap_FXGroupBox_killFocus), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "changeFocus", VALUEFUNC(_wrap_FXGroupBox_changeFocus), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "setDefault", VALUEFUNC(_wrap_FXGroupBox_setDefault), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "enable", VALUEFUNC(_wrap_FXGroupBox_enable), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "disable", VALUEFUNC(_wrap_FXGroupBox_disable), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "raiseWindow", VALUEFUNC(_wrap_FXGroupBox_raiseWindow), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "lower", VALUEFUNC(_wrap_FXGroupBox_lower), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "move", VALUEFUNC(_wrap_FXGroupBox_move), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "position", VALUEFUNC(_wrap_FXGroupBox_position), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "layout", VALUEFUNC(_wrap_FXGroupBox_layout), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "recalc", VALUEFUNC(_wrap_FXGroupBox_recalc), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "reparent", VALUEFUNC(_wrap_FXGroupBox_reparent), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "show", VALUEFUNC(_wrap_FXGroupBox_show), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "hide", VALUEFUNC(_wrap_FXGroupBox_hide), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "isComposite", VALUEFUNC(_wrap_FXGroupBox_isComposite), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "contains", VALUEFUNC(_wrap_FXGroupBox_contains), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXGroupBox_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "setBackColor", VALUEFUNC(_wrap_FXGroupBox_setBackColor), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "tr", VALUEFUNC(_wrap_FXGroupBox_tr), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "dropEnable", VALUEFUNC(_wrap_FXGroupBox_dropEnable), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "dropDisable", VALUEFUNC(_wrap_FXGroupBox_dropDisable), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "setShape", VALUEFUNC(_wrap_FXGroupBox_setShape), -1);
+  rb_define_method(SwigClassFXGroupBox.klass, "clearShape", VALUEFUNC(_wrap_FXGroupBox_clearShape), -1);
+  SwigClassFXGroupBox.mark = (void (*)(void *)) FXRbGroupBox::markfunc;
+  SwigClassFXGroupBox.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXGroupBox.trackObjects = 0;
+  rb_define_const(mFox, "SWITCHER_HCOLLAPSE", SWIG_From_int(static_cast< int >(SWITCHER_HCOLLAPSE)));
+  rb_define_const(mFox, "SWITCHER_VCOLLAPSE", SWIG_From_int(static_cast< int >(SWITCHER_VCOLLAPSE)));
+  
+  SwigClassFXSwitcher.klass = rb_define_class_under(mFox, "FXSwitcher", ((swig_class *) SWIGTYPE_p_FXPacker->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXSwitcher, (void *) &SwigClassFXSwitcher);
+  rb_define_alloc_func(SwigClassFXSwitcher.klass, _wrap_FXSwitcher_allocate);
+  rb_define_method(SwigClassFXSwitcher.klass, "initialize", VALUEFUNC(_wrap_new_FXSwitcher), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "onPaint", VALUEFUNC(_wrap_FXSwitcher_onPaint), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXSwitcher_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXSwitcher_onCmdSetIntValue), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXSwitcher_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "onCmdOpen", VALUEFUNC(_wrap_FXSwitcher_onCmdOpen), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "onUpdOpen", VALUEFUNC(_wrap_FXSwitcher_onUpdOpen), -1);
+  rb_define_const(SwigClassFXSwitcher.klass, "ID_OPEN_FIRST", SWIG_From_int(static_cast< int >(FXSwitcher::ID_OPEN_FIRST)));
+  rb_define_const(SwigClassFXSwitcher.klass, "ID_OPEN_SECOND", SWIG_From_int(static_cast< int >(FXSwitcher::ID_OPEN_SECOND)));
+  rb_define_const(SwigClassFXSwitcher.klass, "ID_OPEN_THIRD", SWIG_From_int(static_cast< int >(FXSwitcher::ID_OPEN_THIRD)));
+  rb_define_const(SwigClassFXSwitcher.klass, "ID_OPEN_FOURTH", SWIG_From_int(static_cast< int >(FXSwitcher::ID_OPEN_FOURTH)));
+  rb_define_const(SwigClassFXSwitcher.klass, "ID_OPEN_FIFTH", SWIG_From_int(static_cast< int >(FXSwitcher::ID_OPEN_FIFTH)));
+  rb_define_const(SwigClassFXSwitcher.klass, "ID_OPEN_SIXTH", SWIG_From_int(static_cast< int >(FXSwitcher::ID_OPEN_SIXTH)));
+  rb_define_const(SwigClassFXSwitcher.klass, "ID_OPEN_SEVENTH", SWIG_From_int(static_cast< int >(FXSwitcher::ID_OPEN_SEVENTH)));
+  rb_define_const(SwigClassFXSwitcher.klass, "ID_OPEN_EIGHTH", SWIG_From_int(static_cast< int >(FXSwitcher::ID_OPEN_EIGHTH)));
+  rb_define_const(SwigClassFXSwitcher.klass, "ID_OPEN_NINETH", SWIG_From_int(static_cast< int >(FXSwitcher::ID_OPEN_NINETH)));
+  rb_define_const(SwigClassFXSwitcher.klass, "ID_OPEN_TENTH", SWIG_From_int(static_cast< int >(FXSwitcher::ID_OPEN_TENTH)));
+  rb_define_const(SwigClassFXSwitcher.klass, "ID_OPEN_LAST", SWIG_From_int(static_cast< int >(FXSwitcher::ID_OPEN_LAST)));
+  rb_define_const(SwigClassFXSwitcher.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXSwitcher::ID_LAST)));
+  rb_define_method(SwigClassFXSwitcher.klass, "setCurrent", VALUEFUNC(_wrap_FXSwitcher_setCurrent), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "getCurrent", VALUEFUNC(_wrap_FXSwitcher_getCurrent), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "setSwitcherStyle", VALUEFUNC(_wrap_FXSwitcher_setSwitcherStyle), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "getSwitcherStyle", VALUEFUNC(_wrap_FXSwitcher_getSwitcherStyle), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "save", VALUEFUNC(_wrap_FXSwitcher_save), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "load", VALUEFUNC(_wrap_FXSwitcher_load), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "create", VALUEFUNC(_wrap_FXSwitcher_create), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "detach", VALUEFUNC(_wrap_FXSwitcher_detach), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "destroy", VALUEFUNC(_wrap_FXSwitcher_destroy), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "resize", VALUEFUNC(_wrap_FXSwitcher_resize), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXSwitcher_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXSwitcher_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXSwitcher_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXSwitcher_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "canFocus", VALUEFUNC(_wrap_FXSwitcher_canFocus), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "setFocus", VALUEFUNC(_wrap_FXSwitcher_setFocus), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "killFocus", VALUEFUNC(_wrap_FXSwitcher_killFocus), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "changeFocus", VALUEFUNC(_wrap_FXSwitcher_changeFocus), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "setDefault", VALUEFUNC(_wrap_FXSwitcher_setDefault), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "enable", VALUEFUNC(_wrap_FXSwitcher_enable), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "disable", VALUEFUNC(_wrap_FXSwitcher_disable), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "raiseWindow", VALUEFUNC(_wrap_FXSwitcher_raiseWindow), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "lower", VALUEFUNC(_wrap_FXSwitcher_lower), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "move", VALUEFUNC(_wrap_FXSwitcher_move), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "position", VALUEFUNC(_wrap_FXSwitcher_position), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "layout", VALUEFUNC(_wrap_FXSwitcher_layout), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "recalc", VALUEFUNC(_wrap_FXSwitcher_recalc), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "reparent", VALUEFUNC(_wrap_FXSwitcher_reparent), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "show", VALUEFUNC(_wrap_FXSwitcher_show), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "hide", VALUEFUNC(_wrap_FXSwitcher_hide), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "isComposite", VALUEFUNC(_wrap_FXSwitcher_isComposite), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "contains", VALUEFUNC(_wrap_FXSwitcher_contains), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXSwitcher_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "setBackColor", VALUEFUNC(_wrap_FXSwitcher_setBackColor), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "tr", VALUEFUNC(_wrap_FXSwitcher_tr), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "dropEnable", VALUEFUNC(_wrap_FXSwitcher_dropEnable), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "dropDisable", VALUEFUNC(_wrap_FXSwitcher_dropDisable), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "setShape", VALUEFUNC(_wrap_FXSwitcher_setShape), -1);
+  rb_define_method(SwigClassFXSwitcher.klass, "clearShape", VALUEFUNC(_wrap_FXSwitcher_clearShape), -1);
+  SwigClassFXSwitcher.mark = (void (*)(void *)) FXRbSwitcher::markfunc;
+  SwigClassFXSwitcher.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXSwitcher.trackObjects = 0;
+  
+  SwigClassFXShutterItem.klass = rb_define_class_under(mFox, "FXShutterItem", ((swig_class *) SWIGTYPE_p_FXVerticalFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXShutterItem, (void *) &SwigClassFXShutterItem);
+  rb_define_alloc_func(SwigClassFXShutterItem.klass, _wrap_FXShutterItem_allocate);
+  rb_define_method(SwigClassFXShutterItem.klass, "initialize", VALUEFUNC(_wrap_new_FXShutterItem), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "onFocusUp", VALUEFUNC(_wrap_FXShutterItem_onFocusUp), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "onFocusDown", VALUEFUNC(_wrap_FXShutterItem_onFocusDown), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "onCmdButton", VALUEFUNC(_wrap_FXShutterItem_onCmdButton), -1);
+  rb_define_const(SwigClassFXShutterItem.klass, "ID_SHUTTERITEM_BUTTON", SWIG_From_int(static_cast< int >(FXShutterItem::ID_SHUTTERITEM_BUTTON)));
+  rb_define_const(SwigClassFXShutterItem.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXShutterItem::ID_LAST)));
+  rb_define_method(SwigClassFXShutterItem.klass, "getButton", VALUEFUNC(_wrap_FXShutterItem_getButton), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "getContent", VALUEFUNC(_wrap_FXShutterItem_getContent), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "setHelpText", VALUEFUNC(_wrap_FXShutterItem_setHelpText), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "getHelpText", VALUEFUNC(_wrap_FXShutterItem_getHelpText), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "setTipText", VALUEFUNC(_wrap_FXShutterItem_setTipText), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "getTipText", VALUEFUNC(_wrap_FXShutterItem_getTipText), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "save", VALUEFUNC(_wrap_FXShutterItem_save), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "load", VALUEFUNC(_wrap_FXShutterItem_load), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "create", VALUEFUNC(_wrap_FXShutterItem_create), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "detach", VALUEFUNC(_wrap_FXShutterItem_detach), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "destroy", VALUEFUNC(_wrap_FXShutterItem_destroy), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "resize", VALUEFUNC(_wrap_FXShutterItem_resize), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXShutterItem_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXShutterItem_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXShutterItem_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXShutterItem_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "canFocus", VALUEFUNC(_wrap_FXShutterItem_canFocus), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "setFocus", VALUEFUNC(_wrap_FXShutterItem_setFocus), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "killFocus", VALUEFUNC(_wrap_FXShutterItem_killFocus), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "changeFocus", VALUEFUNC(_wrap_FXShutterItem_changeFocus), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "setDefault", VALUEFUNC(_wrap_FXShutterItem_setDefault), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "enable", VALUEFUNC(_wrap_FXShutterItem_enable), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "disable", VALUEFUNC(_wrap_FXShutterItem_disable), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "raiseWindow", VALUEFUNC(_wrap_FXShutterItem_raiseWindow), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "lower", VALUEFUNC(_wrap_FXShutterItem_lower), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "move", VALUEFUNC(_wrap_FXShutterItem_move), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "position", VALUEFUNC(_wrap_FXShutterItem_position), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "layout", VALUEFUNC(_wrap_FXShutterItem_layout), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "recalc", VALUEFUNC(_wrap_FXShutterItem_recalc), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "reparent", VALUEFUNC(_wrap_FXShutterItem_reparent), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "show", VALUEFUNC(_wrap_FXShutterItem_show), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "hide", VALUEFUNC(_wrap_FXShutterItem_hide), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "isComposite", VALUEFUNC(_wrap_FXShutterItem_isComposite), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "contains", VALUEFUNC(_wrap_FXShutterItem_contains), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXShutterItem_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "setBackColor", VALUEFUNC(_wrap_FXShutterItem_setBackColor), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "tr", VALUEFUNC(_wrap_FXShutterItem_tr), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "dropEnable", VALUEFUNC(_wrap_FXShutterItem_dropEnable), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "dropDisable", VALUEFUNC(_wrap_FXShutterItem_dropDisable), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "setShape", VALUEFUNC(_wrap_FXShutterItem_setShape), -1);
+  rb_define_method(SwigClassFXShutterItem.klass, "clearShape", VALUEFUNC(_wrap_FXShutterItem_clearShape), -1);
+  SwigClassFXShutterItem.mark = (void (*)(void *)) FXRbShutterItem::markfunc;
+  SwigClassFXShutterItem.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXShutterItem.trackObjects = 0;
+  
+  SwigClassFXShutter.klass = rb_define_class_under(mFox, "FXShutter", ((swig_class *) SWIGTYPE_p_FXVerticalFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXShutter, (void *) &SwigClassFXShutter);
+  rb_define_alloc_func(SwigClassFXShutter.klass, _wrap_FXShutter_allocate);
+  rb_define_method(SwigClassFXShutter.klass, "initialize", VALUEFUNC(_wrap_new_FXShutter), -1);
+  rb_define_method(SwigClassFXShutter.klass, "onFocusUp", VALUEFUNC(_wrap_FXShutter_onFocusUp), -1);
+  rb_define_method(SwigClassFXShutter.klass, "onFocusDown", VALUEFUNC(_wrap_FXShutter_onFocusDown), -1);
+  rb_define_method(SwigClassFXShutter.klass, "onTimeout", VALUEFUNC(_wrap_FXShutter_onTimeout), -1);
+  rb_define_method(SwigClassFXShutter.klass, "onOpenItem", VALUEFUNC(_wrap_FXShutter_onOpenItem), -1);
+  rb_define_method(SwigClassFXShutter.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXShutter_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXShutter.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXShutter_onCmdSetIntValue), -1);
+  rb_define_method(SwigClassFXShutter.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXShutter_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXShutter.klass, "onCmdOpen", VALUEFUNC(_wrap_FXShutter_onCmdOpen), -1);
+  rb_define_method(SwigClassFXShutter.klass, "onUpdOpen", VALUEFUNC(_wrap_FXShutter_onUpdOpen), -1);
+  rb_define_const(SwigClassFXShutter.klass, "ID_SHUTTER_TIMEOUT", SWIG_From_int(static_cast< int >(FXShutter::ID_SHUTTER_TIMEOUT)));
+  rb_define_const(SwigClassFXShutter.klass, "ID_OPEN_SHUTTERITEM", SWIG_From_int(static_cast< int >(FXShutter::ID_OPEN_SHUTTERITEM)));
+  rb_define_const(SwigClassFXShutter.klass, "ID_OPEN_FIRST", SWIG_From_int(static_cast< int >(FXShutter::ID_OPEN_FIRST)));
+  rb_define_const(SwigClassFXShutter.klass, "ID_OPEN_LAST", SWIG_From_int(static_cast< int >(FXShutter::ID_OPEN_LAST)));
+  rb_define_const(SwigClassFXShutter.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXShutter::ID_LAST)));
+  rb_define_method(SwigClassFXShutter.klass, "getCurrent", VALUEFUNC(_wrap_FXShutter_getCurrent), -1);
+  rb_define_method(SwigClassFXShutter.klass, "save", VALUEFUNC(_wrap_FXShutter_save), -1);
+  rb_define_method(SwigClassFXShutter.klass, "load", VALUEFUNC(_wrap_FXShutter_load), -1);
+  rb_define_method(SwigClassFXShutter.klass, "create", VALUEFUNC(_wrap_FXShutter_create), -1);
+  rb_define_method(SwigClassFXShutter.klass, "detach", VALUEFUNC(_wrap_FXShutter_detach), -1);
+  rb_define_method(SwigClassFXShutter.klass, "destroy", VALUEFUNC(_wrap_FXShutter_destroy), -1);
+  rb_define_method(SwigClassFXShutter.klass, "resize", VALUEFUNC(_wrap_FXShutter_resize), -1);
+  rb_define_method(SwigClassFXShutter.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXShutter_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXShutter.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXShutter_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXShutter.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXShutter_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXShutter.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXShutter_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXShutter.klass, "canFocus", VALUEFUNC(_wrap_FXShutter_canFocus), -1);
+  rb_define_method(SwigClassFXShutter.klass, "setFocus", VALUEFUNC(_wrap_FXShutter_setFocus), -1);
+  rb_define_method(SwigClassFXShutter.klass, "killFocus", VALUEFUNC(_wrap_FXShutter_killFocus), -1);
+  rb_define_method(SwigClassFXShutter.klass, "changeFocus", VALUEFUNC(_wrap_FXShutter_changeFocus), -1);
+  rb_define_method(SwigClassFXShutter.klass, "setDefault", VALUEFUNC(_wrap_FXShutter_setDefault), -1);
+  rb_define_method(SwigClassFXShutter.klass, "enable", VALUEFUNC(_wrap_FXShutter_enable), -1);
+  rb_define_method(SwigClassFXShutter.klass, "disable", VALUEFUNC(_wrap_FXShutter_disable), -1);
+  rb_define_method(SwigClassFXShutter.klass, "raiseWindow", VALUEFUNC(_wrap_FXShutter_raiseWindow), -1);
+  rb_define_method(SwigClassFXShutter.klass, "lower", VALUEFUNC(_wrap_FXShutter_lower), -1);
+  rb_define_method(SwigClassFXShutter.klass, "move", VALUEFUNC(_wrap_FXShutter_move), -1);
+  rb_define_method(SwigClassFXShutter.klass, "position", VALUEFUNC(_wrap_FXShutter_position), -1);
+  rb_define_method(SwigClassFXShutter.klass, "layout", VALUEFUNC(_wrap_FXShutter_layout), -1);
+  rb_define_method(SwigClassFXShutter.klass, "recalc", VALUEFUNC(_wrap_FXShutter_recalc), -1);
+  rb_define_method(SwigClassFXShutter.klass, "reparent", VALUEFUNC(_wrap_FXShutter_reparent), -1);
+  rb_define_method(SwigClassFXShutter.klass, "show", VALUEFUNC(_wrap_FXShutter_show), -1);
+  rb_define_method(SwigClassFXShutter.klass, "hide", VALUEFUNC(_wrap_FXShutter_hide), -1);
+  rb_define_method(SwigClassFXShutter.klass, "isComposite", VALUEFUNC(_wrap_FXShutter_isComposite), -1);
+  rb_define_method(SwigClassFXShutter.klass, "contains", VALUEFUNC(_wrap_FXShutter_contains), -1);
+  rb_define_method(SwigClassFXShutter.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXShutter_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXShutter.klass, "setBackColor", VALUEFUNC(_wrap_FXShutter_setBackColor), -1);
+  rb_define_method(SwigClassFXShutter.klass, "tr", VALUEFUNC(_wrap_FXShutter_tr), -1);
+  rb_define_method(SwigClassFXShutter.klass, "dropEnable", VALUEFUNC(_wrap_FXShutter_dropEnable), -1);
+  rb_define_method(SwigClassFXShutter.klass, "dropDisable", VALUEFUNC(_wrap_FXShutter_dropDisable), -1);
+  rb_define_method(SwigClassFXShutter.klass, "setShape", VALUEFUNC(_wrap_FXShutter_setShape), -1);
+  rb_define_method(SwigClassFXShutter.klass, "clearShape", VALUEFUNC(_wrap_FXShutter_clearShape), -1);
+  rb_define_method(SwigClassFXShutter.klass, "setCurrent", VALUEFUNC(_wrap_FXShutter_setCurrent), -1);
+  SwigClassFXShutter.mark = (void (*)(void *)) FXRbShutter::markfunc;
+  SwigClassFXShutter.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXShutter.trackObjects = 0;
+  rb_define_const(mFox, "SPLITTER_HORIZONTAL", SWIG_From_int(static_cast< int >(SPLITTER_HORIZONTAL)));
+  rb_define_const(mFox, "SPLITTER_VERTICAL", SWIG_From_int(static_cast< int >(SPLITTER_VERTICAL)));
+  rb_define_const(mFox, "SPLITTER_REVERSED", SWIG_From_int(static_cast< int >(SPLITTER_REVERSED)));
+  rb_define_const(mFox, "SPLITTER_TRACKING", SWIG_From_int(static_cast< int >(SPLITTER_TRACKING)));
+  rb_define_const(mFox, "SPLITTER_NORMAL", SWIG_From_int(static_cast< int >(SPLITTER_NORMAL)));
+  
+  SwigClassFXSplitter.klass = rb_define_class_under(mFox, "FXSplitter", ((swig_class *) SWIGTYPE_p_FXComposite->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXSplitter, (void *) &SwigClassFXSplitter);
+  rb_define_alloc_func(SwigClassFXSplitter.klass, _wrap_FXSplitter_allocate);
+  rb_define_method(SwigClassFXSplitter.klass, "initialize", VALUEFUNC(_wrap_new_FXSplitter), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXSplitter_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXSplitter_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "onMotion", VALUEFUNC(_wrap_FXSplitter_onMotion), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "onFocusNext", VALUEFUNC(_wrap_FXSplitter_onFocusNext), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "onFocusPrev", VALUEFUNC(_wrap_FXSplitter_onFocusPrev), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "onFocusUp", VALUEFUNC(_wrap_FXSplitter_onFocusUp), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "onFocusDown", VALUEFUNC(_wrap_FXSplitter_onFocusDown), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "onFocusLeft", VALUEFUNC(_wrap_FXSplitter_onFocusLeft), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "onFocusRight", VALUEFUNC(_wrap_FXSplitter_onFocusRight), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "getSplit", VALUEFUNC(_wrap_FXSplitter_getSplit), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "setSplit", VALUEFUNC(_wrap_FXSplitter_setSplit), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "setSplitterStyle", VALUEFUNC(_wrap_FXSplitter_setSplitterStyle), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "getSplitterStyle", VALUEFUNC(_wrap_FXSplitter_getSplitterStyle), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "setBarSize", VALUEFUNC(_wrap_FXSplitter_setBarSize), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "getBarSize", VALUEFUNC(_wrap_FXSplitter_getBarSize), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "save", VALUEFUNC(_wrap_FXSplitter_save), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "load", VALUEFUNC(_wrap_FXSplitter_load), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "create", VALUEFUNC(_wrap_FXSplitter_create), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "detach", VALUEFUNC(_wrap_FXSplitter_detach), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "destroy", VALUEFUNC(_wrap_FXSplitter_destroy), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "resize", VALUEFUNC(_wrap_FXSplitter_resize), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXSplitter_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXSplitter_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXSplitter_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXSplitter_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "canFocus", VALUEFUNC(_wrap_FXSplitter_canFocus), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "setFocus", VALUEFUNC(_wrap_FXSplitter_setFocus), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "killFocus", VALUEFUNC(_wrap_FXSplitter_killFocus), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "changeFocus", VALUEFUNC(_wrap_FXSplitter_changeFocus), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "setDefault", VALUEFUNC(_wrap_FXSplitter_setDefault), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "enable", VALUEFUNC(_wrap_FXSplitter_enable), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "disable", VALUEFUNC(_wrap_FXSplitter_disable), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "raiseWindow", VALUEFUNC(_wrap_FXSplitter_raiseWindow), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "lower", VALUEFUNC(_wrap_FXSplitter_lower), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "move", VALUEFUNC(_wrap_FXSplitter_move), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "position", VALUEFUNC(_wrap_FXSplitter_position), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "layout", VALUEFUNC(_wrap_FXSplitter_layout), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "recalc", VALUEFUNC(_wrap_FXSplitter_recalc), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "reparent", VALUEFUNC(_wrap_FXSplitter_reparent), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "show", VALUEFUNC(_wrap_FXSplitter_show), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "hide", VALUEFUNC(_wrap_FXSplitter_hide), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "isComposite", VALUEFUNC(_wrap_FXSplitter_isComposite), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "contains", VALUEFUNC(_wrap_FXSplitter_contains), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXSplitter_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "setBackColor", VALUEFUNC(_wrap_FXSplitter_setBackColor), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "tr", VALUEFUNC(_wrap_FXSplitter_tr), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "dropEnable", VALUEFUNC(_wrap_FXSplitter_dropEnable), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "dropDisable", VALUEFUNC(_wrap_FXSplitter_dropDisable), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "setShape", VALUEFUNC(_wrap_FXSplitter_setShape), -1);
+  rb_define_method(SwigClassFXSplitter.klass, "clearShape", VALUEFUNC(_wrap_FXSplitter_clearShape), -1);
+  SwigClassFXSplitter.mark = (void (*)(void *)) FXRbSplitter::markfunc;
+  SwigClassFXSplitter.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXSplitter.trackObjects = 0;
+  rb_define_const(mFox, "FOURSPLITTER_TRACKING", SWIG_From_int(static_cast< int >(FOURSPLITTER_TRACKING)));
+  rb_define_const(mFox, "FOURSPLITTER_NORMAL", SWIG_From_int(static_cast< int >(FOURSPLITTER_NORMAL)));
+  
+  SwigClassFX4Splitter.klass = rb_define_class_under(mFox, "FX4Splitter", ((swig_class *) SWIGTYPE_p_FXComposite->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FX4Splitter, (void *) &SwigClassFX4Splitter);
+  rb_define_alloc_func(SwigClassFX4Splitter.klass, _wrap_FX4Splitter_allocate);
+  rb_define_method(SwigClassFX4Splitter.klass, "initialize", VALUEFUNC(_wrap_new_FX4Splitter), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FX4Splitter_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FX4Splitter_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "onMotion", VALUEFUNC(_wrap_FX4Splitter_onMotion), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "onFocusUp", VALUEFUNC(_wrap_FX4Splitter_onFocusUp), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "onFocusDown", VALUEFUNC(_wrap_FX4Splitter_onFocusDown), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "onFocusLeft", VALUEFUNC(_wrap_FX4Splitter_onFocusLeft), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "onFocusRight", VALUEFUNC(_wrap_FX4Splitter_onFocusRight), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "onCmdExpand", VALUEFUNC(_wrap_FX4Splitter_onCmdExpand), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "onUpdExpand", VALUEFUNC(_wrap_FX4Splitter_onUpdExpand), -1);
+  rb_define_const(SwigClassFX4Splitter.klass, "ExpandNone", SWIG_From_int(static_cast< int >(FX4Splitter::ExpandNone)));
+  rb_define_const(SwigClassFX4Splitter.klass, "ExpandTopLeft", SWIG_From_int(static_cast< int >(FX4Splitter::ExpandTopLeft)));
+  rb_define_const(SwigClassFX4Splitter.klass, "ExpandTopRight", SWIG_From_int(static_cast< int >(FX4Splitter::ExpandTopRight)));
+  rb_define_const(SwigClassFX4Splitter.klass, "ExpandBottomLeft", SWIG_From_int(static_cast< int >(FX4Splitter::ExpandBottomLeft)));
+  rb_define_const(SwigClassFX4Splitter.klass, "ExpandBottomRight", SWIG_From_int(static_cast< int >(FX4Splitter::ExpandBottomRight)));
+  rb_define_const(SwigClassFX4Splitter.klass, "ExpandTop", SWIG_From_int(static_cast< int >(FX4Splitter::ExpandTop)));
+  rb_define_const(SwigClassFX4Splitter.klass, "ExpandBottom", SWIG_From_int(static_cast< int >(FX4Splitter::ExpandBottom)));
+  rb_define_const(SwigClassFX4Splitter.klass, "ExpandLeft", SWIG_From_int(static_cast< int >(FX4Splitter::ExpandLeft)));
+  rb_define_const(SwigClassFX4Splitter.klass, "ExpandRight", SWIG_From_int(static_cast< int >(FX4Splitter::ExpandRight)));
+  rb_define_const(SwigClassFX4Splitter.klass, "ExpandAll", SWIG_From_int(static_cast< int >(FX4Splitter::ExpandAll)));
+  rb_define_const(SwigClassFX4Splitter.klass, "ID_EXPAND_NONE", SWIG_From_int(static_cast< int >(FX4Splitter::ID_EXPAND_NONE)));
+  rb_define_const(SwigClassFX4Splitter.klass, "ID_EXPAND_TOP", SWIG_From_int(static_cast< int >(FX4Splitter::ID_EXPAND_TOP)));
+  rb_define_const(SwigClassFX4Splitter.klass, "ID_EXPAND_BOTTOM", SWIG_From_int(static_cast< int >(FX4Splitter::ID_EXPAND_BOTTOM)));
+  rb_define_const(SwigClassFX4Splitter.klass, "ID_EXPAND_LEFT", SWIG_From_int(static_cast< int >(FX4Splitter::ID_EXPAND_LEFT)));
+  rb_define_const(SwigClassFX4Splitter.klass, "ID_EXPAND_RIGHT", SWIG_From_int(static_cast< int >(FX4Splitter::ID_EXPAND_RIGHT)));
+  rb_define_const(SwigClassFX4Splitter.klass, "ID_EXPAND_TOPLEFT", SWIG_From_int(static_cast< int >(FX4Splitter::ID_EXPAND_TOPLEFT)));
+  rb_define_const(SwigClassFX4Splitter.klass, "ID_EXPAND_TOPRIGHT", SWIG_From_int(static_cast< int >(FX4Splitter::ID_EXPAND_TOPRIGHT)));
+  rb_define_const(SwigClassFX4Splitter.klass, "ID_EXPAND_BOTTOMLEFT", SWIG_From_int(static_cast< int >(FX4Splitter::ID_EXPAND_BOTTOMLEFT)));
+  rb_define_const(SwigClassFX4Splitter.klass, "ID_EXPAND_BOTTOMRIGHT", SWIG_From_int(static_cast< int >(FX4Splitter::ID_EXPAND_BOTTOMRIGHT)));
+  rb_define_const(SwigClassFX4Splitter.klass, "ID_EXPAND_ALL", SWIG_From_int(static_cast< int >(FX4Splitter::ID_EXPAND_ALL)));
+  rb_define_const(SwigClassFX4Splitter.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FX4Splitter::ID_LAST)));
+  rb_define_method(SwigClassFX4Splitter.klass, "getTopLeft", VALUEFUNC(_wrap_FX4Splitter_getTopLeft), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "getTopRight", VALUEFUNC(_wrap_FX4Splitter_getTopRight), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "getBottomLeft", VALUEFUNC(_wrap_FX4Splitter_getBottomLeft), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "getBottomRight", VALUEFUNC(_wrap_FX4Splitter_getBottomRight), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "getHSplit", VALUEFUNC(_wrap_FX4Splitter_getHSplit), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "getVSplit", VALUEFUNC(_wrap_FX4Splitter_getVSplit), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "setHSplit", VALUEFUNC(_wrap_FX4Splitter_setHSplit), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "setVSplit", VALUEFUNC(_wrap_FX4Splitter_setVSplit), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "getSplitterStyle", VALUEFUNC(_wrap_FX4Splitter_getSplitterStyle), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "setSplitterStyle", VALUEFUNC(_wrap_FX4Splitter_setSplitterStyle), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "setBarSize", VALUEFUNC(_wrap_FX4Splitter_setBarSize), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "getBarSize", VALUEFUNC(_wrap_FX4Splitter_getBarSize), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "setExpanded", VALUEFUNC(_wrap_FX4Splitter_setExpanded), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "getExpanded", VALUEFUNC(_wrap_FX4Splitter_getExpanded), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "save", VALUEFUNC(_wrap_FX4Splitter_save), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "load", VALUEFUNC(_wrap_FX4Splitter_load), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "create", VALUEFUNC(_wrap_FX4Splitter_create), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "detach", VALUEFUNC(_wrap_FX4Splitter_detach), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "destroy", VALUEFUNC(_wrap_FX4Splitter_destroy), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "resize", VALUEFUNC(_wrap_FX4Splitter_resize), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "getDefaultWidth", VALUEFUNC(_wrap_FX4Splitter_getDefaultWidth), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "getDefaultHeight", VALUEFUNC(_wrap_FX4Splitter_getDefaultHeight), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "getWidthForHeight", VALUEFUNC(_wrap_FX4Splitter_getWidthForHeight), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "getHeightForWidth", VALUEFUNC(_wrap_FX4Splitter_getHeightForWidth), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "canFocus", VALUEFUNC(_wrap_FX4Splitter_canFocus), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "setFocus", VALUEFUNC(_wrap_FX4Splitter_setFocus), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "killFocus", VALUEFUNC(_wrap_FX4Splitter_killFocus), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "changeFocus", VALUEFUNC(_wrap_FX4Splitter_changeFocus), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "setDefault", VALUEFUNC(_wrap_FX4Splitter_setDefault), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "enable", VALUEFUNC(_wrap_FX4Splitter_enable), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "disable", VALUEFUNC(_wrap_FX4Splitter_disable), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "raiseWindow", VALUEFUNC(_wrap_FX4Splitter_raiseWindow), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "lower", VALUEFUNC(_wrap_FX4Splitter_lower), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "move", VALUEFUNC(_wrap_FX4Splitter_move), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "position", VALUEFUNC(_wrap_FX4Splitter_position), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "layout", VALUEFUNC(_wrap_FX4Splitter_layout), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "recalc", VALUEFUNC(_wrap_FX4Splitter_recalc), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "reparent", VALUEFUNC(_wrap_FX4Splitter_reparent), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "show", VALUEFUNC(_wrap_FX4Splitter_show), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "hide", VALUEFUNC(_wrap_FX4Splitter_hide), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "isComposite", VALUEFUNC(_wrap_FX4Splitter_isComposite), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "contains", VALUEFUNC(_wrap_FX4Splitter_contains), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "doesSaveUnder", VALUEFUNC(_wrap_FX4Splitter_doesSaveUnder), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "setBackColor", VALUEFUNC(_wrap_FX4Splitter_setBackColor), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "tr", VALUEFUNC(_wrap_FX4Splitter_tr), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "dropEnable", VALUEFUNC(_wrap_FX4Splitter_dropEnable), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "dropDisable", VALUEFUNC(_wrap_FX4Splitter_dropDisable), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "setShape", VALUEFUNC(_wrap_FX4Splitter_setShape), -1);
+  rb_define_method(SwigClassFX4Splitter.klass, "clearShape", VALUEFUNC(_wrap_FX4Splitter_clearShape), -1);
+  SwigClassFX4Splitter.mark = (void (*)(void *)) FXRb4Splitter::markfunc;
+  SwigClassFX4Splitter.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFX4Splitter.trackObjects = 0;
+  rb_define_const(mFox, "STATUSBAR_WITH_DRAGCORNER", SWIG_From_int(static_cast< int >(STATUSBAR_WITH_DRAGCORNER)));
+  
+  SwigClassFXStatusBar.klass = rb_define_class_under(mFox, "FXStatusBar", ((swig_class *) SWIGTYPE_p_FXHorizontalFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXStatusBar, (void *) &SwigClassFXStatusBar);
+  rb_define_alloc_func(SwigClassFXStatusBar.klass, _wrap_FXStatusBar_allocate);
+  rb_define_method(SwigClassFXStatusBar.klass, "initialize", VALUEFUNC(_wrap_new_FXStatusBar), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "setCornerStyle", VALUEFUNC(_wrap_FXStatusBar_setCornerStyle), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "getCornerStyle", VALUEFUNC(_wrap_FXStatusBar_getCornerStyle), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "getStatusLine", VALUEFUNC(_wrap_FXStatusBar_getStatusLine), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "getDragCorner", VALUEFUNC(_wrap_FXStatusBar_getDragCorner), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "save", VALUEFUNC(_wrap_FXStatusBar_save), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "load", VALUEFUNC(_wrap_FXStatusBar_load), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "create", VALUEFUNC(_wrap_FXStatusBar_create), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "detach", VALUEFUNC(_wrap_FXStatusBar_detach), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "destroy", VALUEFUNC(_wrap_FXStatusBar_destroy), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "resize", VALUEFUNC(_wrap_FXStatusBar_resize), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXStatusBar_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXStatusBar_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXStatusBar_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXStatusBar_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "canFocus", VALUEFUNC(_wrap_FXStatusBar_canFocus), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "setFocus", VALUEFUNC(_wrap_FXStatusBar_setFocus), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "killFocus", VALUEFUNC(_wrap_FXStatusBar_killFocus), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "changeFocus", VALUEFUNC(_wrap_FXStatusBar_changeFocus), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "setDefault", VALUEFUNC(_wrap_FXStatusBar_setDefault), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "enable", VALUEFUNC(_wrap_FXStatusBar_enable), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "disable", VALUEFUNC(_wrap_FXStatusBar_disable), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "raiseWindow", VALUEFUNC(_wrap_FXStatusBar_raiseWindow), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "lower", VALUEFUNC(_wrap_FXStatusBar_lower), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "move", VALUEFUNC(_wrap_FXStatusBar_move), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "position", VALUEFUNC(_wrap_FXStatusBar_position), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "layout", VALUEFUNC(_wrap_FXStatusBar_layout), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "recalc", VALUEFUNC(_wrap_FXStatusBar_recalc), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "reparent", VALUEFUNC(_wrap_FXStatusBar_reparent), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "show", VALUEFUNC(_wrap_FXStatusBar_show), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "hide", VALUEFUNC(_wrap_FXStatusBar_hide), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "isComposite", VALUEFUNC(_wrap_FXStatusBar_isComposite), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "contains", VALUEFUNC(_wrap_FXStatusBar_contains), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXStatusBar_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "setBackColor", VALUEFUNC(_wrap_FXStatusBar_setBackColor), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "tr", VALUEFUNC(_wrap_FXStatusBar_tr), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "dropEnable", VALUEFUNC(_wrap_FXStatusBar_dropEnable), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "dropDisable", VALUEFUNC(_wrap_FXStatusBar_dropDisable), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "setShape", VALUEFUNC(_wrap_FXStatusBar_setShape), -1);
+  rb_define_method(SwigClassFXStatusBar.klass, "clearShape", VALUEFUNC(_wrap_FXStatusBar_clearShape), -1);
+  SwigClassFXStatusBar.mark = (void (*)(void *)) FXRbStatusBar::markfunc;
+  SwigClassFXStatusBar.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXStatusBar.trackObjects = 0;
+  rb_define_const(mFox, "SCROLLERS_NORMAL", SWIG_From_int(static_cast< int >(SCROLLERS_NORMAL)));
+  rb_define_const(mFox, "HSCROLLER_ALWAYS", SWIG_From_int(static_cast< int >(HSCROLLER_ALWAYS)));
+  rb_define_const(mFox, "HSCROLLER_NEVER", SWIG_From_int(static_cast< int >(HSCROLLER_NEVER)));
+  rb_define_const(mFox, "VSCROLLER_ALWAYS", SWIG_From_int(static_cast< int >(VSCROLLER_ALWAYS)));
+  rb_define_const(mFox, "VSCROLLER_NEVER", SWIG_From_int(static_cast< int >(VSCROLLER_NEVER)));
+  rb_define_const(mFox, "HSCROLLING_ON", SWIG_From_int(static_cast< int >(HSCROLLING_ON)));
+  rb_define_const(mFox, "HSCROLLING_OFF", SWIG_From_int(static_cast< int >(HSCROLLING_OFF)));
+  rb_define_const(mFox, "VSCROLLING_ON", SWIG_From_int(static_cast< int >(VSCROLLING_ON)));
+  rb_define_const(mFox, "VSCROLLING_OFF", SWIG_From_int(static_cast< int >(VSCROLLING_OFF)));
+  rb_define_const(mFox, "SCROLLERS_TRACK", SWIG_From_int(static_cast< int >(SCROLLERS_TRACK)));
+  rb_define_const(mFox, "SCROLLERS_DONT_TRACK", SWIG_From_int(static_cast< int >(SCROLLERS_DONT_TRACK)));
+  
+  SwigClassFXScrollArea.klass = rb_define_class_under(mFox, "FXScrollArea", ((swig_class *) SWIGTYPE_p_FXComposite->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXScrollArea, (void *) &SwigClassFXScrollArea);
+  rb_define_alloc_func(SwigClassFXScrollArea.klass, _wrap_FXScrollArea_allocate);
+  rb_define_method(SwigClassFXScrollArea.klass, "initialize", VALUEFUNC(_wrap_new_FXScrollArea), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "onHMouseWheel", VALUEFUNC(_wrap_FXScrollArea_onHMouseWheel), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "onVMouseWheel", VALUEFUNC(_wrap_FXScrollArea_onVMouseWheel), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "onHScrollerChanged", VALUEFUNC(_wrap_FXScrollArea_onHScrollerChanged), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "onVScrollerChanged", VALUEFUNC(_wrap_FXScrollArea_onVScrollerChanged), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "onHScrollerDragged", VALUEFUNC(_wrap_FXScrollArea_onHScrollerDragged), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "onVScrollerDragged", VALUEFUNC(_wrap_FXScrollArea_onVScrollerDragged), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "onAutoScroll", VALUEFUNC(_wrap_FXScrollArea_onAutoScroll), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "setScrollStyle", VALUEFUNC(_wrap_FXScrollArea_setScrollStyle), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "getScrollStyle", VALUEFUNC(_wrap_FXScrollArea_getScrollStyle), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "isHorizontalScrollable", VALUEFUNC(_wrap_FXScrollArea_isHorizontalScrollable), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "isVerticalScrollable", VALUEFUNC(_wrap_FXScrollArea_isVerticalScrollable), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "horizontalScrollBar", VALUEFUNC(_wrap_FXScrollArea_horizontalScrollBar), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "verticalScrollBar", VALUEFUNC(_wrap_FXScrollArea_verticalScrollBar), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "getXPosition", VALUEFUNC(_wrap_FXScrollArea_getXPosition), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "getYPosition", VALUEFUNC(_wrap_FXScrollArea_getYPosition), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "setPosition", VALUEFUNC(_wrap_FXScrollArea_setPosition), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "save", VALUEFUNC(_wrap_FXScrollArea_save), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "load", VALUEFUNC(_wrap_FXScrollArea_load), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "create", VALUEFUNC(_wrap_FXScrollArea_create), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "detach", VALUEFUNC(_wrap_FXScrollArea_detach), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "destroy", VALUEFUNC(_wrap_FXScrollArea_destroy), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "resize", VALUEFUNC(_wrap_FXScrollArea_resize), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXScrollArea_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXScrollArea_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXScrollArea_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXScrollArea_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "canFocus", VALUEFUNC(_wrap_FXScrollArea_canFocus), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "setFocus", VALUEFUNC(_wrap_FXScrollArea_setFocus), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "killFocus", VALUEFUNC(_wrap_FXScrollArea_killFocus), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "changeFocus", VALUEFUNC(_wrap_FXScrollArea_changeFocus), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "setDefault", VALUEFUNC(_wrap_FXScrollArea_setDefault), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "enable", VALUEFUNC(_wrap_FXScrollArea_enable), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "disable", VALUEFUNC(_wrap_FXScrollArea_disable), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "raiseWindow", VALUEFUNC(_wrap_FXScrollArea_raiseWindow), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "lower", VALUEFUNC(_wrap_FXScrollArea_lower), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "move", VALUEFUNC(_wrap_FXScrollArea_move), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "layout", VALUEFUNC(_wrap_FXScrollArea_layout), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "recalc", VALUEFUNC(_wrap_FXScrollArea_recalc), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "reparent", VALUEFUNC(_wrap_FXScrollArea_reparent), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "show", VALUEFUNC(_wrap_FXScrollArea_show), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "hide", VALUEFUNC(_wrap_FXScrollArea_hide), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "isComposite", VALUEFUNC(_wrap_FXScrollArea_isComposite), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "contains", VALUEFUNC(_wrap_FXScrollArea_contains), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXScrollArea_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "setBackColor", VALUEFUNC(_wrap_FXScrollArea_setBackColor), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "tr", VALUEFUNC(_wrap_FXScrollArea_tr), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "dropEnable", VALUEFUNC(_wrap_FXScrollArea_dropEnable), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "dropDisable", VALUEFUNC(_wrap_FXScrollArea_dropDisable), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "setShape", VALUEFUNC(_wrap_FXScrollArea_setShape), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "clearShape", VALUEFUNC(_wrap_FXScrollArea_clearShape), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "getViewportHeight", VALUEFUNC(_wrap_FXScrollArea_getViewportHeight), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "getViewportWidth", VALUEFUNC(_wrap_FXScrollArea_getViewportWidth), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "getContentHeight", VALUEFUNC(_wrap_FXScrollArea_getContentHeight), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "getContentWidth", VALUEFUNC(_wrap_FXScrollArea_getContentWidth), -1);
+  rb_define_method(SwigClassFXScrollArea.klass, "position", VALUEFUNC(_wrap_FXScrollArea_position), -1);
+  SwigClassFXScrollArea.mark = (void (*)(void *)) FXRbScrollArea::markfunc;
+  SwigClassFXScrollArea.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXScrollArea.trackObjects = 0;
+  
+  SWIGTYPE_p_FXScrollArea->dcast = (swig_dycast_func) FXScrollArea_dynamic_cast;
+  
+  
+  SwigClassFXScrollWindow.klass = rb_define_class_under(mFox, "FXScrollWindow", ((swig_class *) SWIGTYPE_p_FXScrollArea->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXScrollWindow, (void *) &SwigClassFXScrollWindow);
+  rb_define_alloc_func(SwigClassFXScrollWindow.klass, _wrap_FXScrollWindow_allocate);
+  rb_define_method(SwigClassFXScrollWindow.klass, "initialize", VALUEFUNC(_wrap_new_FXScrollWindow), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "onKeyPress", VALUEFUNC(_wrap_FXScrollWindow_onKeyPress), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "onKeyRelease", VALUEFUNC(_wrap_FXScrollWindow_onKeyRelease), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "onFocusSelf", VALUEFUNC(_wrap_FXScrollWindow_onFocusSelf), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "contentWindow", VALUEFUNC(_wrap_FXScrollWindow_contentWindow), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "save", VALUEFUNC(_wrap_FXScrollWindow_save), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "load", VALUEFUNC(_wrap_FXScrollWindow_load), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "create", VALUEFUNC(_wrap_FXScrollWindow_create), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "detach", VALUEFUNC(_wrap_FXScrollWindow_detach), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "destroy", VALUEFUNC(_wrap_FXScrollWindow_destroy), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "resize", VALUEFUNC(_wrap_FXScrollWindow_resize), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXScrollWindow_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXScrollWindow_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXScrollWindow_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXScrollWindow_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "canFocus", VALUEFUNC(_wrap_FXScrollWindow_canFocus), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "setFocus", VALUEFUNC(_wrap_FXScrollWindow_setFocus), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "killFocus", VALUEFUNC(_wrap_FXScrollWindow_killFocus), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "changeFocus", VALUEFUNC(_wrap_FXScrollWindow_changeFocus), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "setDefault", VALUEFUNC(_wrap_FXScrollWindow_setDefault), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "enable", VALUEFUNC(_wrap_FXScrollWindow_enable), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "disable", VALUEFUNC(_wrap_FXScrollWindow_disable), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "raiseWindow", VALUEFUNC(_wrap_FXScrollWindow_raiseWindow), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "lower", VALUEFUNC(_wrap_FXScrollWindow_lower), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "move", VALUEFUNC(_wrap_FXScrollWindow_move), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "layout", VALUEFUNC(_wrap_FXScrollWindow_layout), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "recalc", VALUEFUNC(_wrap_FXScrollWindow_recalc), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "reparent", VALUEFUNC(_wrap_FXScrollWindow_reparent), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "show", VALUEFUNC(_wrap_FXScrollWindow_show), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "hide", VALUEFUNC(_wrap_FXScrollWindow_hide), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "isComposite", VALUEFUNC(_wrap_FXScrollWindow_isComposite), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "contains", VALUEFUNC(_wrap_FXScrollWindow_contains), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXScrollWindow_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "setBackColor", VALUEFUNC(_wrap_FXScrollWindow_setBackColor), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "tr", VALUEFUNC(_wrap_FXScrollWindow_tr), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "dropEnable", VALUEFUNC(_wrap_FXScrollWindow_dropEnable), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "dropDisable", VALUEFUNC(_wrap_FXScrollWindow_dropDisable), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "setShape", VALUEFUNC(_wrap_FXScrollWindow_setShape), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "clearShape", VALUEFUNC(_wrap_FXScrollWindow_clearShape), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "getViewportHeight", VALUEFUNC(_wrap_FXScrollWindow_getViewportHeight), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "getViewportWidth", VALUEFUNC(_wrap_FXScrollWindow_getViewportWidth), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "getContentHeight", VALUEFUNC(_wrap_FXScrollWindow_getContentHeight), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "getContentWidth", VALUEFUNC(_wrap_FXScrollWindow_getContentWidth), -1);
+  rb_define_method(SwigClassFXScrollWindow.klass, "position", VALUEFUNC(_wrap_FXScrollWindow_position), -1);
+  SwigClassFXScrollWindow.mark = (void (*)(void *)) FXRbScrollWindow::markfunc;
+  SwigClassFXScrollWindow.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXScrollWindow.trackObjects = 0;
+}
+
diff --git a/ext/fox16_c/list_wrap.cpp b/ext/fox16_c/list_wrap.cpp
new file mode 100644
index 00000000..3d410b96
--- /dev/null
+++ b/ext/fox16_c/list_wrap.cpp
@@ -0,0 +1,10891 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 3.0.12
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+
+#ifndef SWIGRUBY
+#define SWIGRUBY
+#endif
+
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
+};
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic C API SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "4"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/*  Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN           0x1
+
+
+/*
+   Flags/methods for returning states.
+
+   The SWIG conversion methods, as ConvertPtr, return an integer
+   that tells if the conversion was successful or not. And if not,
+   an error code can be returned (see swigerrors.swg for the codes).
+
+   Use the following macros/flags to set or process the returning
+   states.
+
+   In old versions of SWIG, code such as the following was usually written:
+
+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+       // success code
+     } else {
+       //fail code
+     }
+
+   Now you can be more explicit:
+
+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+    } else {
+      // fail code
+    }
+
+   which is the same really, but now you can also do
+
+    Type *ptr;
+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+      if (SWIG_IsNewObj(res) {
+        ...
+	delete *ptr;
+      } else {
+        ...
+      }
+    } else {
+      // fail code
+    }
+
+   I.e., now SWIG_ConvertPtr can return new objects and you can
+   identify the case and take care of the deallocation. Of course that
+   also requires SWIG_ConvertPtr to return new result values, such as
+
+      int SWIG_ConvertPtr(obj, ptr,...) {
+        if (<obj is ok>) {
+          if (<need new object>) {
+            *ptr = <ptr to new allocated object>;
+            return SWIG_NEWOBJ;
+          } else {
+            *ptr = <ptr to old object>;
+            return SWIG_OLDOBJ;
+          }
+        } else {
+          return SWIG_BADOBJ;
+        }
+      }
+
+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+   SWIG errors code.
+
+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+   allows to return the 'cast rank', for example, if you have this
+
+       int food(double)
+       int fooi(int);
+
+   and you call
+
+      food(1)   // cast rank '1'  (1 -> 1.0)
+      fooi(1)   // cast rank '0'
+
+   just use the SWIG_AddCast()/SWIG_CheckState()
+*/
+
+#define SWIG_OK                    (0)
+#define SWIG_ERROR                 (-1)
+#define SWIG_IsOK(r)               (r >= 0)
+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT         (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ                (SWIG_ERROR)
+#define SWIG_OLDOBJ                (SWIG_OK)
+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+#  ifndef SWIG_TypeRank
+#    define SWIG_TypeRank             unsigned long
+#  endif
+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
+#    define SWIG_MAXCASTRANK          (2)
+#  endif
+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+#  define SWIG_AddCast(r) (r)
+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *, int *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store information on one type */
+typedef struct swig_type_info {
+  const char             *name;			/* mangled name of this type */
+  const char             *str;			/* human readable name of this type */
+  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
+  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
+  void                   *clientdata;		/* language specific type data */
+  int                    owndata;		/* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
+  swig_converter_func     converter;		/* function to cast the void pointers */
+  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
+  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
+  size_t                 size;		        /* Number of types in this module */
+  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
+  swig_type_info         **type_initial;	/* Array of initially generated type structures */
+  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
+  void                    *clientdata;		/* Language specific module data */
+} swig_module_info;
+
+/*
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+  }
+  return (int)((l1 - f1) - (l2 - f2));
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCmp(const char *nb, const char *tb) {
+  int equiv = 1;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (equiv != 0 && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
+}
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
+}
+
+/*
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+  swig_type_info *lastty = ty;
+  if (!ty || !ty->dcast) return ty;
+  while (ty && (ty->dcast)) {
+    ty = (*ty->dcast)(ptr);
+    if (ty) lastty = ty;
+  }
+  return lastty;
+}
+
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+  return ty->name;
+}
+
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (!type) return NULL;
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
+  }
+  else
+    return type->name;
+}
+
+/*
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+  swig_cast_info *cast = ti->cast;
+  /* if (ti->clientdata == clientdata) return; */
+  ti->clientdata = clientdata;
+
+  while (cast) {
+    if (!cast->converter) {
+      swig_type_info *tc = cast->type;
+      if (!tc->clientdata) {
+	SWIG_TypeClientData(tc, clientdata);
+      }
+    }
+    cast = cast->next;
+  }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientData(ti, clientdata);
+  ti->owndata = 1;
+}
+
+/*
+  Search for a swig_type_info structure only by mangled name
+  Search is a O(log #types)
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+                            swig_module_info *end,
+		            const char *name) {
+  swig_module_info *iter = start;
+  do {
+    if (iter->size) {
+      size_t l = 0;
+      size_t r = iter->size - 1;
+      do {
+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
+	size_t i = (l + r) >> 1;
+	const char *iname = iter->types[i]->name;
+	if (iname) {
+	  int compare = strcmp(name, iname);
+	  if (compare == 0) {
+	    return iter->types[i];
+	  } else if (compare < 0) {
+	    if (i) {
+	      r = i - 1;
+	    } else {
+	      break;
+	    }
+	  } else if (compare > 0) {
+	    l = i + 1;
+	  }
+	} else {
+	  break; /* should never happen */
+	}
+      } while (l <= r);
+    }
+    iter = iter->next;
+  } while (iter != end);
+  return 0;
+}
+
+/*
+  Search for a swig_type_info structure for either a mangled name or a human readable name.
+  It first searches the mangled names of the types, which is a O(log #types)
+  If a type is not found it then searches the human readable names, which is O(#types).
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+                     swig_module_info *end,
+		     const char *name) {
+  /* STEP 1: Search the name field using binary search */
+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+  if (ret) {
+    return ret;
+  } else {
+    /* STEP 2: If the type hasn't been found, do a complete search
+       of the str field (the human readable name) */
+    swig_module_info *iter = start;
+    do {
+      size_t i = 0;
+      for (; i < iter->size; ++i) {
+	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+	  return iter->types[i];
+      }
+      iter = iter->next;
+    } while (iter != end);
+  }
+
+  /* neither found a match */
+  return 0;
+}
+
+/*
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+
+/*
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = (unsigned char)((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = (unsigned char)((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (unsigned char)(d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (unsigned char)(d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/*
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/*  Errors in SWIG */
+#define  SWIG_UnknownError    	   -1
+#define  SWIG_IOError        	   -2
+#define  SWIG_RuntimeError   	   -3
+#define  SWIG_IndexError     	   -4
+#define  SWIG_TypeError      	   -5
+#define  SWIG_DivisionByZero 	   -6
+#define  SWIG_OverflowError  	   -7
+#define  SWIG_SyntaxError    	   -8
+#define  SWIG_ValueError     	   -9
+#define  SWIG_SystemError    	   -10
+#define  SWIG_AttributeError 	   -11
+#define  SWIG_MemoryError    	   -12
+#define  SWIG_NullReferenceError   -13
+
+
+
+      #include <ruby.h>
+
+      #if defined(RB_METHOD_DEFINITION_DECL)
+      # define RUBY_VALUE_METHOD_FUNC(func) (func)
+      # define RUBY_INT_METHOD_FUNC(func) (func)
+      # define RUBY_VOID_METHOD_FUNC(func) (func)
+      # define RUBY_VOIDP_METHOD_FUNC(func) (func)
+      #else
+      # define RUBY_VALUE_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
+      # define RUBY_INT_METHOD_FUNC(func) ((int (*)(ANYARGS))(func))
+      # define RUBY_VOID_METHOD_FUNC(func) ((void (*)(ANYARGS))(func))
+      # define RUBY_VOIDP_METHOD_FUNC(func) ((void *(*)(ANYARGS))(func))
+      #endif
+
+
+/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
+ * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
+ * issue for now by disabling this.
+ * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
+ */
+#ifdef rb_intern
+# undef rb_intern
+#endif
+
+/* Remove global macros defined in Ruby's win32.h */
+#ifdef write
+# undef write
+#endif
+#ifdef read
+# undef read
+#endif
+#ifdef bind
+# undef bind
+#endif
+#ifdef close
+# undef close
+#endif
+#ifdef connect
+# undef connect
+#endif
+
+
+/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
+#ifndef NUM2LL
+#define NUM2LL(x) NUM2LONG((x))
+#endif
+#ifndef LL2NUM
+#define LL2NUM(x) INT2NUM((long) (x))
+#endif
+#ifndef ULL2NUM
+#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
+#endif
+
+/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
+#ifndef NUM2ULL
+#ifdef HAVE_LONG_LONG
+#define NUM2ULL(x) rb_num2ull((x))
+#else
+#define NUM2ULL(x) NUM2ULONG(x)
+#endif
+#endif
+
+/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
+/* Define these for older versions so we can just write code the new way */
+#ifndef RSTRING_LEN
+# define RSTRING_LEN(x) RSTRING(x)->len
+#endif
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(x) RSTRING(x)->ptr
+#endif
+#ifndef RSTRING_END
+# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
+#endif
+#ifndef RARRAY_LEN
+# define RARRAY_LEN(x) RARRAY(x)->len
+#endif
+#ifndef RARRAY_PTR
+# define RARRAY_PTR(x) RARRAY(x)->ptr
+#endif
+#ifndef RFLOAT_VALUE
+# define RFLOAT_VALUE(x) RFLOAT(x)->value
+#endif
+#ifndef DOUBLE2NUM
+# define DOUBLE2NUM(x) rb_float_new(x)
+#endif
+#ifndef RHASH_TBL
+# define RHASH_TBL(x) (RHASH(x)->tbl)
+#endif
+#ifndef RHASH_ITER_LEV
+# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
+#endif
+#ifndef RHASH_IFNONE
+# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
+#endif
+#ifndef RHASH_SIZE
+# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
+#endif
+#ifndef RHASH_EMPTY_P
+# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
+#endif
+#ifndef RSTRUCT_LEN
+# define RSTRUCT_LEN(x) RSTRUCT(x)->len
+#endif
+#ifndef RSTRUCT_PTR
+# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
+#endif
+
+
+
+/*
+ * Need to be very careful about how these macros are defined, especially
+ * when compiling C++ code or C code with an ANSI C compiler.
+ *
+ * VALUEFUNC(f) is a macro used to typecast a C function that implements
+ * a Ruby method so that it can be passed as an argument to API functions
+ * like rb_define_method() and rb_define_singleton_method().
+ *
+ * VOIDFUNC(f) is a macro used to typecast a C function that implements
+ * either the "mark" or "free" stuff for a Ruby Data object, so that it
+ * can be passed as an argument to API functions like Data_Wrap_Struct()
+ * and Data_Make_Struct().
+ */
+ 
+#ifdef __cplusplus
+#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
+#    define PROTECTFUNC(f) ((VALUE (*)()) f)
+#    define VALUEFUNC(f) ((VALUE (*)()) f)
+#    define VOIDFUNC(f)  ((void (*)()) f)
+#  else
+#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
+#      define PROTECTFUNC(f) ((VALUE (*)()) f)
+#      define VALUEFUNC(f) ((VALUE (*)()) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    else /* These definitions should work for Ruby 1.7+ */
+#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
+#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    endif
+#  endif
+#else
+#  define VALUEFUNC(f) (f)
+#  define VOIDFUNC(f) (f)
+#endif
+
+/* Don't use for expressions have side effect */
+#ifndef RB_STRING_VALUE
+#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
+#endif
+#ifndef StringValue
+#define StringValue(s) RB_STRING_VALUE(s)
+#endif
+#ifndef StringValuePtr
+#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
+#endif
+#ifndef StringValueLen
+#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
+#endif
+#ifndef SafeStringValue
+#define SafeStringValue(v) do {\
+    StringValue(v);\
+    rb_check_safe_str(v);\
+} while (0)
+#endif
+
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
+#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
+#endif
+
+static VALUE _mSWIG = Qnil;
+
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+
+/* Define some additional error types */
+#define SWIG_ObjectPreviouslyDeletedError  -100
+
+
+/* Define custom exceptions for errors that do not map to existing Ruby
+   exceptions.  Note this only works for C++ since a global cannot be
+   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/
+
+SWIGINTERN VALUE 
+getNullReferenceError(void) {
+  static int init = 0;
+  static VALUE rb_eNullReferenceError ;
+  if (!init) {
+    init = 1;
+    rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
+  }
+  return rb_eNullReferenceError;
+} 
+
+SWIGINTERN VALUE 
+getObjectPreviouslyDeletedError(void) {
+  static int init = 0;
+  static VALUE rb_eObjectPreviouslyDeleted ;
+  if (!init) {
+    init = 1;
+    rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
+  }
+  return rb_eObjectPreviouslyDeleted;
+} 
+
+
+SWIGINTERN VALUE
+SWIG_Ruby_ErrorType(int SWIG_code) {
+  VALUE type;
+  switch (SWIG_code) {
+  case SWIG_MemoryError:
+    type = rb_eNoMemError;
+    break;
+  case SWIG_IOError:
+    type = rb_eIOError;
+    break;
+  case SWIG_RuntimeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_IndexError:
+    type = rb_eIndexError;
+    break;
+  case SWIG_TypeError:
+    type = rb_eTypeError;
+    break;
+  case SWIG_DivisionByZero:
+    type = rb_eZeroDivError;
+    break;
+  case SWIG_OverflowError:
+    type = rb_eRangeError;
+    break;
+  case SWIG_SyntaxError:
+    type = rb_eSyntaxError;
+    break;
+  case SWIG_ValueError:
+    type = rb_eArgError;
+    break;
+  case SWIG_SystemError:
+    type = rb_eFatal;
+    break;
+  case SWIG_AttributeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_NullReferenceError:
+    type = getNullReferenceError();
+    break;
+  case SWIG_ObjectPreviouslyDeletedError:
+    type = getObjectPreviouslyDeletedError();
+    break;
+  case SWIG_UnknownError:
+    type = rb_eRuntimeError;
+    break;
+  default:
+    type = rb_eRuntimeError;
+  }
+  return type;
+}
+
+
+/* This function is called when a user inputs a wrong argument to
+   a method.
+ */
+SWIGINTERN 
+const char* Ruby_Format_TypeError( const char* msg,
+				   const char* type, 
+				   const char* name, 
+				   const int argn,
+				   VALUE input )
+{
+  char buf[128];
+  VALUE str;
+  VALUE asStr;
+  if ( msg && *msg )
+    {
+      str = rb_str_new2(msg);
+    }
+  else
+    {
+      str = rb_str_new(NULL, 0);
+    }
+
+  str = rb_str_cat2( str, "Expected argument " );
+  sprintf( buf, "%d of type ", argn-1 );
+  str = rb_str_cat2( str, buf );
+  str = rb_str_cat2( str, type );
+  str = rb_str_cat2( str, ", but got " );
+  str = rb_str_cat2( str, rb_obj_classname(input) );
+  str = rb_str_cat2( str, " " );
+  asStr = rb_inspect(input);
+  if ( RSTRING_LEN(asStr) > 30 )
+    {
+      str = rb_str_cat( str, StringValuePtr(asStr), 30 );
+      str = rb_str_cat2( str, "..." );
+    }
+  else
+    {
+      str = rb_str_append( str, asStr );
+    }
+
+  if ( name )
+    {
+      str = rb_str_cat2( str, "\n\tin SWIG method '" );
+      str = rb_str_cat2( str, name );
+      str = rb_str_cat2( str, "'" );
+    }
+
+  return StringValuePtr( str );
+}
+
+/* This function is called when an overloaded method fails */
+SWIGINTERN 
+void Ruby_Format_OverloadedError(
+				 const int argc,
+				 const int maxargs,
+				 const char* method, 
+				 const char* prototypes 
+				 )
+{
+  const char* msg = "Wrong # of arguments";
+  if ( argc <= maxargs ) msg = "Wrong arguments";
+  rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
+	   "Possible C/C++ prototypes are:\n%s",
+	   msg, method, prototypes);
+}
+
+/* -----------------------------------------------------------------------------
+ * rubytracking.swg
+ *
+ * This file contains support for tracking mappings from 
+ * Ruby objects to C++ objects.  This functionality is needed
+ * to implement mark functions for Ruby's mark and sweep
+ * garbage collector.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(ST_DATA_T_DEFINED)
+/* Needs to be explicitly included for Ruby 1.8 and earlier */
+#include <st.h>
+#endif
+
+/* Ruby 1.8 actually assumes the first case. */
+#if SIZEOF_VOIDP == SIZEOF_LONG
+#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
+#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
+#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
+#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
+#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
+#else
+#  error sizeof(void*) is not the same as long or long long
+#endif
+
+/* Global hash table to store Trackings from C/C++
+   structs to Ruby Objects. 
+*/
+static st_table* swig_ruby_trackings = NULL;
+
+static VALUE swig_ruby_trackings_count(ID id, VALUE *var) {
+  return SWIG2NUM(swig_ruby_trackings->num_entries);
+}
+
+
+/* Setup a hash table to store Trackings */
+SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
+  /* Create a hash table to store Trackings from C++
+     objects to Ruby objects. */
+
+  /* Try to see if some other .so has already created a 
+     tracking hash table, which we keep hidden in an instance var
+     in the SWIG module.
+     This is done to allow multiple DSOs to share the same
+     tracking table.
+  */
+  VALUE trackings_value = Qnil;
+  /* change the variable name so that we can mix modules
+     compiled with older SWIG's - this used to be called "@__trackings__" */
+  ID trackings_id = rb_intern( "@__safetrackings__" );
+  VALUE verbose = rb_gv_get("VERBOSE");
+  rb_gv_set("VERBOSE", Qfalse);
+  trackings_value = rb_ivar_get( _mSWIG, trackings_id );
+  rb_gv_set("VERBOSE", verbose);
+
+  /* The trick here is that we have to store the hash table
+  pointer in a Ruby variable. We do not want Ruby's GC to
+  treat this pointer as a Ruby object, so we convert it to
+  a Ruby numeric value. */
+  if (trackings_value == Qnil) {
+    /* No, it hasn't.  Create one ourselves */
+    swig_ruby_trackings = st_init_numtable();
+    rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
+  } else {
+    swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
+  }
+
+        rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", RUBY_VALUE_METHOD_FUNC(swig_ruby_trackings_count), RUBY_VOID_METHOD_FUNC((rb_gvar_setter_t*)NULL))
+;
+}
+
+/* Add a Tracking from a C/C++ struct to a Ruby object */
+SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
+  /* Store the mapping to the global hash table. */
+  st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
+}
+
+/* Get the Ruby object that owns the specified C/C++ struct */
+SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
+  /* Now lookup the value stored in the global hash table */
+  VALUE value;
+
+  if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
+    return value;
+  } else {
+    return Qnil;
+  }
+}
+
+/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
+   is very important to remove objects once they are destroyed
+   since the same memory address may be reused later to create
+   a new object. */
+SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
+  /* Delete the object from the hash table */
+  st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
+}
+
+/* This is a helper method that unlinks a Ruby object from its
+   underlying C++ object.  This is needed if the lifetime of the
+   Ruby object is longer than the C++ object */
+SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
+  VALUE object = SWIG_RubyInstanceFor(ptr);
+
+  if (object != Qnil) {
+    if (TYPE(object) != T_DATA)
+      abort();
+    DATA_PTR(object) = 0;
+  }
+}
+
+/* This is a helper method that iterates over all the trackings
+   passing the C++ object pointer and its related Ruby object
+   to the passed callback function. */
+
+/* Proxy method to abstract the internal trackings datatype */
+      static int swig_ruby_internal_iterate_callback(st_data_t ptr, st_data_t obj, st_data_t meth) {
+        ((void(*)(void*, VALUE))meth)((void*)ptr, (VALUE)obj);
+
+  return ST_CONTINUE;
+}
+
+SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
+  st_foreach(swig_ruby_trackings, RUBY_INT_METHOD_FUNC(swig_ruby_internal_iterate_callback), (st_data_t)meth);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Ruby API portion that goes into the runtime
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGINTERN VALUE
+SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
+  if (NIL_P(target)) {
+    target = o;
+  } else {
+    if (TYPE(target) != T_ARRAY) {
+      VALUE o2 = target;
+      target = rb_ary_new();
+      rb_ary_push(target, o2);
+    }
+    rb_ary_push(target, o);
+  }
+  return target;
+}
+
+/* For ruby1.8.4 and earlier. */
+#ifndef RUBY_INIT_STACK
+   RUBY_EXTERN void Init_stack(VALUE* addr);
+#  define RUBY_INIT_STACK \
+   VALUE variable_in_this_stack_frame; \
+   Init_stack(&variable_in_this_stack_frame);
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* -----------------------------------------------------------------------------
+ * rubyrun.swg
+ *
+ * This file contains the runtime support for Ruby modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
+#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
+#define swig_owntype                                    swig_ruby_owntype
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) 		SWIG_Ruby_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
+#define SWIG_Error(code, msg)            		rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
+#define SWIG_fail                        		goto fail				 
+
+
+/* Ruby-specific SWIG API */
+
+#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
+#define SWIG_define_class(ty)                        	SWIG_Ruby_define_class(ty)
+#define SWIG_NewClassInstance(value, ty)             	SWIG_Ruby_NewClassInstance(value, ty)
+#define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
+#define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  
+
+#include "assert.h"
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  VALUE klass;
+  VALUE mImpl;
+  void  (*mark)(void *);
+  void  (*destroy)(void *);
+  int trackObjects;
+} swig_class;
+
+
+/* Global pointer used to keep some internal SWIG stuff */
+static VALUE _cSWIG_Pointer = Qnil;
+static VALUE swig_runtime_data_type_pointer = Qnil;
+
+/* Global IDs used to keep some internal SWIG stuff */
+static ID swig_arity_id = 0;
+static ID swig_call_id  = 0;
+
+/*
+  If your swig extension is to be run within an embedded ruby and has
+  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
+  This will reset ruby's stack frame on each entry point from the main 
+  program the first time a virtual director function is invoked (in a 
+  non-recursive way).
+  If this is not done, you run the risk of Ruby trashing the stack.
+*/
+
+#ifdef RUBY_EMBEDDED
+
+#  define SWIG_INIT_STACK                            \
+      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
+      ++swig_virtual_calls;
+#  define SWIG_RELEASE_STACK --swig_virtual_calls;
+#  define Ruby_DirectorTypeMismatchException(x) \
+          rb_raise( rb_eTypeError, "%s", x ); return c_result;
+
+      static unsigned int swig_virtual_calls = 0;
+
+#else  /* normal non-embedded extension */
+
+#  define SWIG_INIT_STACK
+#  define SWIG_RELEASE_STACK
+#  define Ruby_DirectorTypeMismatchException(x) \
+          throw Swig::DirectorTypeMismatchException( x );
+
+#endif  /* RUBY_EMBEDDED */
+
+
+SWIGRUNTIME VALUE 
+getExceptionClass(void) {
+  static int init = 0;
+  static VALUE rubyExceptionClass ;
+  if (!init) {
+    init = 1;
+    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
+  }
+  return rubyExceptionClass;
+} 
+
+/* This code checks to see if the Ruby object being raised as part
+   of an exception inherits from the Ruby class Exception.  If so,
+   the object is simply returned.  If not, then a new Ruby exception
+   object is created and that will be returned to Ruby.*/
+SWIGRUNTIME VALUE
+SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
+  VALUE exceptionClass = getExceptionClass();
+  if (rb_obj_is_kind_of(obj, exceptionClass)) {
+    return obj;
+  }  else {
+    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
+  }
+}
+
+/* Initialize Ruby runtime support */
+SWIGRUNTIME void
+SWIG_Ruby_InitRuntime(void)
+{
+  if (_mSWIG == Qnil) {
+    _mSWIG = rb_define_module("SWIG");
+    swig_call_id  = rb_intern("call");
+    swig_arity_id = rb_intern("arity");
+  }
+}
+
+/* Define Ruby class for C type */
+SWIGRUNTIME void
+SWIG_Ruby_define_class(swig_type_info *type)
+{
+  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+  sprintf(klass_name, "TYPE%s", type->name);
+  if (NIL_P(_cSWIG_Pointer)) {
+    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
+    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
+  }
+  rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
+  free((void *) klass_name);
+}
+
+/* Create a new pointer object */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
+{
+  int own =  flags & SWIG_POINTER_OWN; 
+  int track;
+  char *klass_name;
+  swig_class *sklass;
+  VALUE klass;
+  VALUE obj;
+  
+  if (!ptr)
+    return Qnil;
+  
+  if (type->clientdata) {
+    sklass = (swig_class *) type->clientdata;
+		
+    /* Are we tracking this class and have we already returned this Ruby object? */
+    track = sklass->trackObjects;
+    if (track) {
+      obj = SWIG_RubyInstanceFor(ptr);
+      
+      /* Check the object's type and make sure it has the correct type.
+        It might not in cases where methods do things like 
+        downcast methods. */
+      if (obj != Qnil) {
+        VALUE value = rb_iv_get(obj, "@__swigtype__");
+        const char* type_name = RSTRING_PTR(value);
+				
+        if (strcmp(type->name, type_name) == 0) {
+          return obj;
+        }
+      }
+    }
+
+    /* Create a new Ruby object */
+    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
+			   ( own ? VOIDFUNC(sklass->destroy) : 
+			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
+			     ), ptr);
+
+    /* If tracking is on for this class then track this object. */
+    if (track) {
+      SWIG_RubyAddTracking(ptr, obj);
+    }
+  } else {
+    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+    sprintf(klass_name, "TYPE%s", type->name);
+    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
+    free((void *) klass_name);
+    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
+  }
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  
+  return obj;
+}
+
+/* Create a new class instance (always owned) */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
+{
+  VALUE obj;
+  swig_class *sklass = (swig_class *) type->clientdata;
+  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  return obj;
+}
+
+/* Get type mangle from class name */
+SWIGRUNTIMEINLINE char *
+SWIG_Ruby_MangleStr(VALUE obj)
+{
+  VALUE stype = rb_iv_get(obj, "@__swigtype__");
+  return StringValuePtr(stype);
+}
+
+/* Acquire a pointer value */
+typedef struct {
+  void (*datafree)(void *);
+  int own;
+} swig_ruby_owntype;
+
+SWIGRUNTIME swig_ruby_owntype
+SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
+  swig_ruby_owntype oldown = {0, 0};
+  if (obj) {
+    oldown.datafree = RDATA(obj)->dfree;
+    RDATA(obj)->dfree = own.datafree;
+  }
+  return oldown;
+}
+
+/* Convert a pointer value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
+{
+  char *c;
+  swig_cast_info *tc;
+  void *vptr = 0;
+
+  /* Grab the pointer */
+  if (NIL_P(obj)) {
+    if (ptr)
+      *ptr = 0;
+    return SWIG_OK;
+  } else {
+    if (TYPE(obj) != T_DATA) {
+      return SWIG_ERROR;
+    }
+    Data_Get_Struct(obj, void, vptr);
+  }
+  
+  if (own) {
+    own->datafree = RDATA(obj)->dfree;
+    own->own = 0;
+  }
+    
+  /* Check to see if the input object is giving up ownership
+     of the underlying C struct or C++ object.  If so then we
+     need to reset the destructor since the Ruby object no 
+     longer owns the underlying C++ object.*/ 
+  if (flags & SWIG_POINTER_DISOWN) {
+    /* Is tracking on for this class? */
+    int track = 0;
+    if (ty && ty->clientdata) {
+      swig_class *sklass = (swig_class *) ty->clientdata;
+      track = sklass->trackObjects;
+    }
+		
+    if (track) {
+      /* We are tracking objects for this class.  Thus we change the destructor
+       * to SWIG_RubyRemoveTracking.  This allows us to
+       * remove the mapping from the C++ to Ruby object
+       * when the Ruby object is garbage collected.  If we don't
+       * do this, then it is possible we will return a reference 
+       * to a Ruby object that no longer exists thereby crashing Ruby. */
+      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
+    } else {    
+      RDATA(obj)->dfree = 0;
+    }
+  }
+
+  /* Do type-checking if type info was provided */
+  if (ty) {
+    if (ty->clientdata) {
+      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
+        if (vptr == 0) {
+          /* The object has already been deleted */
+          return SWIG_ObjectPreviouslyDeletedError;
+        }
+      }
+    }
+    if ((c = SWIG_MangleStr(obj)) == NULL) {
+      return SWIG_ERROR;
+    }
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) {
+      return SWIG_ERROR;
+    } else {
+      if (ptr) {
+        if (tc->type == ty) {
+          *ptr = vptr;
+        } else {
+          int newmemory = 0;
+          *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
+          if (newmemory == SWIG_CAST_NEW_MEMORY) {
+            assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+            if (own)
+              own->own = own->own | SWIG_CAST_NEW_MEMORY;
+          }
+        }
+      }
+    }
+  } else {
+    if (ptr)
+      *ptr = vptr;
+  }
+  
+  return SWIG_OK;
+}
+
+/* Check convert */
+SWIGRUNTIMEINLINE int
+SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
+{
+  char *c = SWIG_MangleStr(obj);
+  if (!c) return 0;
+  return SWIG_TypeCheck(c,ty) != 0;
+}
+
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r, ptr, sz);
+  strcpy(r, type->name);
+  return rb_str_new2(result);
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c;
+
+  if (TYPE(obj) != T_STRING) goto type_error;
+  c = StringValuePtr(obj);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') goto type_error;
+  c++;
+  c = SWIG_UnpackData(c, ptr, sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) goto type_error;
+  }
+  return SWIG_OK;
+
+ type_error:
+  return SWIG_ERROR;
+}
+
+SWIGRUNTIME swig_module_info *
+SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
+{
+  VALUE pointer;
+  swig_module_info *ret = 0;
+  VALUE verbose = rb_gv_get("VERBOSE");
+
+ /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
+  rb_gv_set("VERBOSE", Qfalse);
+  
+  /* first check if pointer already created */
+  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  if (pointer != Qnil) {
+    Data_Get_Struct(pointer, swig_module_info, ret);
+  }
+
+  /* reinstate warnings */
+  rb_gv_set("VERBOSE", verbose);
+  return ret;
+}
+
+SWIGRUNTIME void 
+SWIG_Ruby_SetModule(swig_module_info *pointer)
+{
+  /* register a new class */
+  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
+  /* create and store the structure pointer to a global variable */
+  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
+  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
+}
+
+/* This function can be used to check whether a proc or method or similarly
+   callable function has been passed.  Usually used in a %typecheck, like:
+
+   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
+        $result = SWIG_Ruby_isCallable( $input );
+   }
+ */
+SWIGINTERN
+int SWIG_Ruby_isCallable( VALUE proc )
+{
+  if ( rb_respond_to( proc, swig_call_id ) )
+    return 1;
+  return 0;
+}
+
+/* This function can be used to check the arity (number of arguments)
+   a proc or method can take.  Usually used in a %typecheck.
+   Valid arities will be that equal to minimal or those < 0
+   which indicate a variable number of parameters at the end.
+ */
+SWIGINTERN
+int SWIG_Ruby_arity( VALUE proc, int minimal )
+{
+  if ( rb_respond_to( proc, swig_arity_id ) )
+    {
+      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
+      int arity = NUM2INT(num);
+      if ( arity < 0 && (arity+1) < -minimal ) return 1;
+      if ( arity == minimal ) return 1;
+      return 1;
+    }
+  return 0;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
+
+
+
+  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) 
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_p_FX4Splitter swig_types[0]
+#define SWIGTYPE_p_FXAccelTable swig_types[1]
+#define SWIGTYPE_p_FXApp swig_types[2]
+#define SWIGTYPE_p_FXBitmap swig_types[3]
+#define SWIGTYPE_p_FXCURCursor swig_types[4]
+#define SWIGTYPE_p_FXColorItem swig_types[5]
+#define SWIGTYPE_p_FXColorList swig_types[6]
+#define SWIGTYPE_p_FXComposite swig_types[7]
+#define SWIGTYPE_p_FXCursor swig_types[8]
+#define SWIGTYPE_p_FXDataTarget swig_types[9]
+#define SWIGTYPE_p_FXDebugTarget swig_types[10]
+#define SWIGTYPE_p_FXDelegator swig_types[11]
+#define SWIGTYPE_p_FXDict swig_types[12]
+#define SWIGTYPE_p_FXDockSite swig_types[13]
+#define SWIGTYPE_p_FXDocument swig_types[14]
+#define SWIGTYPE_p_FXDrawable swig_types[15]
+#define SWIGTYPE_p_FXFileDict swig_types[16]
+#define SWIGTYPE_p_FXFileStream swig_types[17]
+#define SWIGTYPE_p_FXFont swig_types[18]
+#define SWIGTYPE_p_FXFrame swig_types[19]
+#define SWIGTYPE_p_FXGIFCursor swig_types[20]
+#define SWIGTYPE_p_FXGroupBox swig_types[21]
+#define SWIGTYPE_p_FXHorizontalFrame swig_types[22]
+#define SWIGTYPE_p_FXIcon swig_types[23]
+#define SWIGTYPE_p_FXIconDict swig_types[24]
+#define SWIGTYPE_p_FXId swig_types[25]
+#define SWIGTYPE_p_FXList swig_types[26]
+#define SWIGTYPE_p_FXListItem swig_types[27]
+#define SWIGTYPE_p_FXMainWindow swig_types[28]
+#define SWIGTYPE_p_FXMatrix swig_types[29]
+#define SWIGTYPE_p_FXMemoryStream swig_types[30]
+#define SWIGTYPE_p_FXObject swig_types[31]
+#define SWIGTYPE_p_FXPacker swig_types[32]
+#define SWIGTYPE_p_FXPopup swig_types[33]
+#define SWIGTYPE_p_FXRecentFiles swig_types[34]
+#define SWIGTYPE_p_FXRegion swig_types[35]
+#define SWIGTYPE_p_FXRegistry swig_types[36]
+#define SWIGTYPE_p_FXRootWindow swig_types[37]
+#define SWIGTYPE_p_FXScrollArea swig_types[38]
+#define SWIGTYPE_p_FXScrollWindow swig_types[39]
+#define SWIGTYPE_p_FXSettings swig_types[40]
+#define SWIGTYPE_p_FXShell swig_types[41]
+#define SWIGTYPE_p_FXShutter swig_types[42]
+#define SWIGTYPE_p_FXShutterItem swig_types[43]
+#define SWIGTYPE_p_FXSplashWindow swig_types[44]
+#define SWIGTYPE_p_FXSplitter swig_types[45]
+#define SWIGTYPE_p_FXSpring swig_types[46]
+#define SWIGTYPE_p_FXStatusBar swig_types[47]
+#define SWIGTYPE_p_FXStream swig_types[48]
+#define SWIGTYPE_p_FXStringDict swig_types[49]
+#define SWIGTYPE_p_FXSwitcher swig_types[50]
+#define SWIGTYPE_p_FXTopWindow swig_types[51]
+#define SWIGTYPE_p_FXTranslator swig_types[52]
+#define SWIGTYPE_p_FXVerticalFrame swig_types[53]
+#define SWIGTYPE_p_FXVisual swig_types[54]
+#define SWIGTYPE_p_FXWindow swig_types[55]
+#define SWIGTYPE_p_char swig_types[56]
+#define SWIGTYPE_p_double swig_types[57]
+#define SWIGTYPE_p_float swig_types[58]
+#define SWIGTYPE_p_int swig_types[59]
+#define SWIGTYPE_p_long swig_types[60]
+#define SWIGTYPE_p_short swig_types[61]
+#define SWIGTYPE_p_unsigned_char swig_types[62]
+#define SWIGTYPE_p_unsigned_int swig_types[63]
+#define SWIGTYPE_p_unsigned_long swig_types[64]
+#define SWIGTYPE_p_unsigned_short swig_types[65]
+static swig_type_info *swig_types[67];
+static swig_module_info swig_module = {swig_types, 66, 0, 0, 0, 0};
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
+
+/* -------- TYPES TABLE (END) -------- */
+
+#define SWIG_init    Init_list
+#define SWIG_name    "List"
+
+
+
+#define SWIG_RUBY_THREAD_BEGIN_BLOCK
+#define SWIG_RUBY_THREAD_END_BLOCK
+
+
+#define SWIGVERSION 0x030012 
+#define SWIG_VERSION SWIGVERSION
+
+
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
+
+
+#include <stdexcept>
+
+
+#include "FXRbCommon.h"
+
+
+inline FXColor to_FXColor(VALUE obj){
+  if(TYPE(obj)==T_STRING){
+    return fxcolorfromname(StringValuePtr(obj));
+    }
+  else if(TYPE(obj)==T_SYMBOL){
+    return fxcolorfromname(rb_id2name(SYM2ID(obj)));
+    }
+  else{
+    return NUM2ULONG(obj);
+    }
+  }
+
+
+inline FXString to_FXString(VALUE obj){
+  if(!NIL_P(obj)){
+    Check_Type(obj,T_STRING);
+    return FXString(StringValuePtr(obj));
+    }
+  else{
+    return FXString::null;
+    }
+  }
+
+
+inline FXbool to_FXbool(VALUE obj){
+  if (obj == Qtrue || obj == Qfalse){
+    return (obj == Qtrue) ? TRUE : FALSE;
+    }
+  else{
+    return static_cast<FXbool>(NUM2UINT(obj));
+    }
+  }
+
+
+static swig_type_info* FXEventTypeInfo=0;
+
+inline void* to_FXEvent(VALUE obj){
+  void* ptr;
+  if(!FXEventTypeInfo){
+    FXEventTypeInfo=SWIG_TypeQuery("FXEvent *");
+    FXASSERT(FXEventTypeInfo!=0);
+    }
+  SWIG_ConvertPtr(obj,&ptr,FXEventTypeInfo,1);
+  return ptr;
+  }
+
+
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
+
+
+  #define SWIG_From_long   LONG2NUM 
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_int  (int value)
+{    
+  return SWIG_From_long  (value);
+}
+
+SWIGINTERN FXListItem *new_FXListItem(FXString const &text,FXIcon *ic=0,void *ITEMDATA=0){
+      return new FXRbListItem(text,ic,ITEMDATA);
+      }
+SWIGINTERN void FXListItem_setData(FXListItem *self,VALUE ptr){
+      self->setData((void*) ptr);
+      }
+SWIGINTERN VALUE FXListItem_getData(FXListItem const *self){
+      return self->getData() ? (VALUE) self->getData() : Qnil;
+      }
+
+static swig_type_info *FXListItem_dynamic_cast(void **ptr) {
+    FXListItem **ppListItem = reinterpret_cast<FXListItem **>(ptr);
+    FXColorItem *pColorItem=dynamic_cast<FXColorItem*>(*ppListItem);
+    if(pColorItem){
+      *ptr=reinterpret_cast<void*>(pColorItem);
+      return SWIG_TypeQuery("FXColorItem *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXList *new_FXList(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=LIST_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbList(p,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN FXint FXList_setItem__SWIG_0(FXList *self,FXint index,FXListItem *item,FXbool notify=0){
+      // Save pointer to the soon-to-be-destroyed item
+      FXListItem* oldItem=self->getItem(index);
+
+      // Do the deed
+      if(item->isMemberOf(FXMETACLASS(FXRbListItem)))
+        dynamic_cast<FXRbListItem*>(item)->owned=1;
+      FXint result=self->setItem(index,item,notify);
+
+      // Now zero-out pointers held by still-alive Ruby objects
+      FXRbUnregisterRubyObj(oldItem);
+
+      // Done
+      return result;
+      }
+SWIGINTERN FXint FXList_setItem__SWIG_1(FXList *self,FXint index,FXString const &text,FXIcon *icon=0,void *ITEMDATA=0,FXbool notify=0){
+      // Save pointer to the soon-to-be-destroyed item
+      FXListItem* oldItem=self->getItem(index);
+
+      // Do the deed
+      FXint result=self->setItem(index,text,icon,ITEMDATA,notify);
+
+      // Now zero-out pointers held by still-alive Ruby objects
+      FXRbUnregisterRubyObj(oldItem);
+
+      // Done
+      return result;
+      }
+SWIGINTERN FXint FXList_insertItem__SWIG_0(FXList *self,FXint index,FXListItem *item,FXbool notify=0){
+      if(item->isMemberOf(FXMETACLASS(FXRbListItem)))
+        dynamic_cast<FXRbListItem*>(item)->owned=1;
+      return self->insertItem(index,item,notify);
+      }
+SWIGINTERN FXint FXList_appendItem__SWIG_0(FXList *self,FXListItem *item,FXbool notify=0){
+      if(item->isMemberOf(FXMETACLASS(FXRbListItem)))
+        dynamic_cast<FXRbListItem*>(item)->owned=1;
+      return self->appendItem(item,notify);
+      }
+SWIGINTERN FXint FXList_prependItem__SWIG_0(FXList *self,FXListItem *item,FXbool notify=0){
+      if(item->isMemberOf(FXMETACLASS(FXRbListItem)))
+        dynamic_cast<FXRbListItem*>(item)->owned=1;
+      return self->prependItem(item,notify);
+      }
+SWIGINTERN void FXList_removeItem(FXList *self,FXint index,FXbool notify=0){
+      // Save pointer to the soon-to-be-destroyed item
+      FXListItem* item=self->getItem(index);
+
+      // Do the deed
+      self->removeItem(index,notify);
+
+      // Now zero-out pointers held by still-alive Ruby objects
+      FXRbUnregisterRubyObj(item);
+      }
+SWIGINTERN void FXList_clearItems(FXList *self,FXbool notify=0){
+      // Save pointers to the soon-to-be-destroyed items
+      FXObjectListOf<FXListItem> items;
+      for(FXint i=0; i<self->getNumItems(); i++) items.append(self->getItem(i));
+
+      // Do the deed
+      self->clearItems(notify);
+
+      // Now zero-out pointers held by still-alive Ruby objects
+      for(FXint j=0; j<items.no(); j++) FXRbUnregisterRubyObj(items[j]);
+      }
+SWIGINTERN void FXList_makeItemVisible__SWIG_0(FXList *self,FXListItem *item){
+      FXint numItems=self->getNumItems();
+      for(FXint i=0; i<numItems; i++){
+        if(self->getItem(i)==item){
+          self->makeItemVisible(i);
+	  break;
+	  }
+	}
+      }
+SWIGINTERN void FXList_setItemData(FXList *self,FXint index,VALUE ptr){
+      self->setItemData(index, (void*) ptr);
+      }
+SWIGINTERN VALUE FXList_getItemData(FXList const *self,FXint index){
+      return self->getItemData(index) ? (VALUE) self->getItemData(index) : Qnil;
+      }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_long  (unsigned long value)
+{
+  return ULONG2NUM(value); 
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_int  (unsigned int value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_bool  (bool value)
+{
+  return value ? Qtrue : Qfalse;
+}
+
+
+SWIGINTERN swig_type_info*
+SWIG_pchar_descriptor(void)
+{
+  static int init = 0;
+  static swig_type_info* info = 0;
+  if (!init) {
+    info = SWIG_TypeQuery("_p_char");
+    init = 1;
+  }
+  return info;
+}
+
+
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
+{
+  if (TYPE(obj) == T_STRING) {
+    char *cstr = StringValuePtr(obj); 
+    size_t size = RSTRING_LEN(obj) + 1;
+    if (cptr)  {
+      if (alloc) {
+	if (*alloc == SWIG_NEWOBJ) {
+	  *cptr = reinterpret_cast< char* >(memcpy(new char[size], cstr, sizeof(char)*(size)));
+	} else {
+	  *cptr = cstr;
+	  *alloc = SWIG_OLDOBJ;
+	}
+      }
+    }
+    if (psize) *psize = size;
+    return SWIG_OK;
+  } else {
+    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+    if (pchar_descriptor) {
+      void* vptr = 0;
+      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
+	if (cptr) *cptr = (char *)vptr;
+	if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
+	if (alloc) *alloc = SWIG_OLDOBJ;
+	return SWIG_OK;
+      }
+    }
+  }  
+  return SWIG_TypeError;
+}
+
+
+
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+  if (carray) {
+    if (size > LONG_MAX) {
+      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+      return pchar_descriptor ? 
+	SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : Qnil;
+    } else {
+      return rb_str_new(carray, static_cast< long >(size));
+    }
+  } else {
+    return Qnil;
+  }
+}
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtr(const char *cptr)
+{ 
+  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
+}
+
+SWIGINTERN VALUE FXList_position__SWIG_1(FXList const *self){
+    FXint x, y;
+    self->getPosition(x, y);
+    VALUE pos = rb_ary_new();
+    rb_ary_push(pos, INT2NUM(x));
+    rb_ary_push(pos, INT2NUM(y));
+    return pos;
+  }
+
+static swig_type_info *FXList_dynamic_cast(void **ptr) {
+    FXList **ppList = reinterpret_cast<FXList **>(ptr);
+    FXColorList *pColorList=dynamic_cast<FXColorList*>(*ppList);
+    if(pColorList){
+      *ptr=reinterpret_cast<void*>(pColorList);
+      return SWIG_TypeQuery("FXColorList *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXColorItem *new_FXColorItem(FXString const &text,FXColor clr,void *ITEMDATA=0){
+      return new FXRbColorItem(text,clr,ITEMDATA);
+      }
+SWIGINTERN FXColorList *new_FXColorList(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=LIST_BROWSESELECT,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbColorList(p,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN VALUE FXColorList_position__SWIG_1(FXColorList const *self){
+    FXint x, y;
+    self->getPosition(x, y);
+    VALUE pos = rb_ary_new();
+    rb_ary_push(pos, INT2NUM(x));
+    rb_ary_push(pos, INT2NUM(y));
+    return pos;
+  }
+static swig_class SwigClassFXListItem;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXListItem_allocate(VALUE self)
+#else
+_wrap_FXListItem_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXListItem);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXListItem(int argc, VALUE *argv, VALUE self) {
+  FXString *arg1 = 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *arg3 = (void *) 0 ;
+  SwigValueWrapper< FXString > p1 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXListItem *result = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  p1 = to_FXString(argv[0]); arg1 = &p1;
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","FXListItem", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXIcon * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = (argv[2] == Qnil) ? NULL : (void *) argv[2];
+  }
+  {
+    result = (FXListItem *)new_FXListItem((FXString const &)*arg1,arg2,arg3);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListItem_getText(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem const *","getText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  result = (FXString *) &((FXListItem const *)arg1)->getText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListItem_getIcon(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem const *","getIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  result = (FXIcon *)((FXListItem const *)arg1)->getIcon();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListItem_setData(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem *","setData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  arg2 = argv[0];
+  FXListItem_setData(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListItem_getData(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem const *","getData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  result = (VALUE)FXListItem_getData((FXListItem const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListItem_hasFocus(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem const *","hasFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  result = (FXbool)((FXListItem const *)arg1)->hasFocus();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListItem_isSelected(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem const *","isSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  result = (FXbool)((FXListItem const *)arg1)->isSelected();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListItem_isEnabled(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem const *","isEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  result = (FXbool)((FXListItem const *)arg1)->isEnabled();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListItem_isDraggable(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem const *","isDraggable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  result = (FXbool)((FXListItem const *)arg1)->isDraggable();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListItem_save(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXListItem_save((FXListItem const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListItem_load(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXListItem_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListItem_setText(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem *","setText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  FXListItem_setText(arg1,(FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListItem_setIcon(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem *","setIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXListItem_setIcon(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListItem_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXListItem_setFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListItem_setSelected(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem *","setSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXListItem_setSelected(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListItem_setEnabled(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem *","setEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXListItem_setEnabled(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListItem_setDraggable(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem *","setDraggable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXListItem_setDraggable(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListItem_getWidth(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  FXList *arg2 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem const *","getWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXList const *","getWidth", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXList * >(argp2);
+  result = (FXint)FXListItem_getWidth((FXListItem const *)arg1,(FXList const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListItem_getHeight(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  FXList *arg2 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem const *","getHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXList const *","getHeight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXList * >(argp2);
+  result = (FXint)FXListItem_getHeight((FXListItem const *)arg1,(FXList const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListItem_create(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  FXListItem_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListItem_detach(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  FXListItem_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListItem_destroy(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  FXListItem_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXList;
+
+SWIGINTERN VALUE
+_wrap_FXList_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onEnter(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onLeave(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onRightBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onRightBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onRightBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onRightBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onRightBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onRightBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onFocusIn(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onFocusIn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusIn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusIn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onFocusOut(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onFocusOut", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusOut", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusOut(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onAutoScroll(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onAutoScroll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onAutoScroll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onAutoScroll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onClicked(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onDoubleClicked(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onDoubleClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDoubleClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onDoubleClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onTripleClicked(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onTripleClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTripleClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onTripleClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onCommand(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onCommand", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCommand", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCommand(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onTipTimer(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onTipTimer", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTipTimer", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onTipTimer(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onLookupTimer(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onLookupTimer", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLookupTimer", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onLookupTimer(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXint) NUM2INT(argv[2]);
+    arg4 = static_cast<void*>(&value4);
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_ascending(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  FXListItem *arg2 = (FXListItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem const *","FXList::ascending", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXListItem const *","FXList::ascending", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXListItem * >(argp2);
+  result = (FXint)FXList::ascending((FXListItem const *)arg1,(FXListItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_descending(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  FXListItem *arg2 = (FXListItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem const *","FXList::descending", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXListItem const *","FXList::descending", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXListItem * >(argp2);
+  result = (FXint)FXList::descending((FXListItem const *)arg1,(FXListItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_ascendingCase(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  FXListItem *arg2 = (FXListItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem const *","FXList::ascendingCase", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXListItem const *","FXList::ascendingCase", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXListItem * >(argp2);
+  result = (FXint)FXList::ascendingCase((FXListItem const *)arg1,(FXListItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_descendingCase(int argc, VALUE *argv, VALUE self) {
+  FXListItem *arg1 = (FXListItem *) 0 ;
+  FXListItem *arg2 = (FXListItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListItem const *","FXList::descendingCase", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXListItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXListItem const *","FXList::descendingCase", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXListItem * >(argp2);
+  result = (FXint)FXList::descendingCase((FXListItem const *)arg1,(FXListItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXList_allocate(VALUE self)
+#else
+_wrap_FXList_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXList);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXList(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) LIST_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXList *result = 0 ;
+  
+  if ((argc < 1) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXList", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXList", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXList *)new_FXList(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getNumItems(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","getNumItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  result = (FXint)((FXList const *)arg1)->getNumItems();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getNumVisible(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","getNumVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  result = (FXint)((FXList const *)arg1)->getNumVisible();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_setNumVisible(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","setNumVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setNumVisible(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getItem(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXListItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","getItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  result = (FXListItem *)((FXList const *)arg1)->getItem(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXListItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_setItem__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  FXListItem *arg3 = (FXListItem *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","setItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXListItem *","setItem", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXListItem * >(argp3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  result = (FXint)FXList_setItem__SWIG_0(arg1,arg2,arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_setItem__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  void *arg5 = (void *) 0 ;
+  FXbool arg6 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","setItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  if (argc > 2) {
+    res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","setItem", 4, argv[2] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 3) {
+    arg5 = (argv[3] == Qnil) ? NULL : (void *) argv[3];
+  }
+  if (argc > 4) {
+    arg6 = to_FXbool(argv[4]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  result = (FXint)FXList_setItem__SWIG_1(arg1,arg2,(FXString const &)*arg3,arg4,arg5,arg6);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXList_setItem(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[7];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 7) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 3) && (argc <= 4)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXListItem, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXList_setItem__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (argv[3] == Qtrue || argv[3] == Qfalse) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_FXList_setItem__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 3) && (argc <= 6)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXList_setItem__SWIG_1(nargs, args, self);
+          }
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXList_setItem__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = 1;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_FXList_setItem__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = (argv[5] == Qtrue || argv[5] == Qfalse) ? 1 : 0;
+              }
+              if (_v) {
+                return _wrap_FXList_setItem__SWIG_1(nargs, args, self);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 7, "setItem", 
+    "    FXint setItem(FXint index, FXListItem *item, FXbool notify)\n"
+    "    FXint setItem(FXint index, FXString const &text, FXIcon *icon, void *ITEMDATA, FXbool notify)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_fillItems(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXchar **arg2 = (FXchar **) 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  void *arg4 = (void *) 0 ;
+  FXbool arg5 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  int res4 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","fillItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  {
+    arg2 = NULL;
+    if(!NIL_P(argv[0])){
+      Check_Type(argv[0], T_ARRAY);
+      if (FXMALLOC(&arg2, FXchar *, RARRAY_LEN(argv[0])+1)) {
+        for (long i = 0; i < RARRAY_LEN(argv[0]); i++) {
+          VALUE e = rb_ary_entry(argv[0], i);
+          arg2[i] = (FXchar *) StringValuePtr(e);
+        }
+        arg2[RARRAY_LEN(argv[0])] = 0;
+      }
+    }
+  }
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","fillItems", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 2) {
+    res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","fillItems", 4, argv[2] )); 
+    }
+  }
+  if (argc > 3) {
+    arg5 = to_FXbool(argv[3]);
+  }
+  result = (FXint)(arg1)->fillItems((FXchar const **)arg2,arg3,arg4,arg5);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  FXFREE(&arg2);
+  return vresult;
+fail:
+  FXFREE(&arg2);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_insertItem__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  FXListItem *arg3 = (FXListItem *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","insertItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXListItem *","insertItem", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXListItem * >(argp3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  result = (FXint)FXList_insertItem__SWIG_0(arg1,arg2,arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_insertItem__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  void *arg5 = (void *) 0 ;
+  FXbool arg6 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","insertItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  if (argc > 2) {
+    res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","insertItem", 4, argv[2] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 3) {
+    arg5 = (argv[3] == Qnil) ? NULL : (void *) argv[3];
+  }
+  if (argc > 4) {
+    arg6 = to_FXbool(argv[4]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  result = (FXint)(arg1)->insertItem(arg2,(FXString const &)*arg3,arg4,arg5,arg6);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXList_insertItem(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[7];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 7) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 3) && (argc <= 4)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXListItem, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXList_insertItem__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (argv[3] == Qtrue || argv[3] == Qfalse) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_FXList_insertItem__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 3) && (argc <= 6)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXList_insertItem__SWIG_1(nargs, args, self);
+          }
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXList_insertItem__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = 1;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_FXList_insertItem__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = (argv[5] == Qtrue || argv[5] == Qfalse) ? 1 : 0;
+              }
+              if (_v) {
+                return _wrap_FXList_insertItem__SWIG_1(nargs, args, self);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 7, "insertItem", 
+    "    FXint insertItem(FXint index, FXListItem *item, FXbool notify)\n"
+    "    FXint insertItem(FXint index, FXString const &text, FXIcon *icon, void *ITEMDATA, FXbool notify)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_appendItem__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXListItem *arg2 = (FXListItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","appendItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXListItem *","appendItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXListItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXint)FXList_appendItem__SWIG_0(arg1,arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_appendItem__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  void *arg4 = (void *) 0 ;
+  FXbool arg5 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","appendItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","appendItem", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 2) {
+    arg4 = (argv[2] == Qnil) ? NULL : (void *) argv[2];
+  }
+  if (argc > 3) {
+    arg5 = to_FXbool(argv[3]);
+  }
+  result = (FXint)(arg1)->appendItem((FXString const &)*arg2,arg3,arg4,arg5);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXList_appendItem(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 2) && (argc <= 3)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXListItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_FXList_appendItem__SWIG_0(nargs, args, self);
+        }
+        {
+          _v = (argv[2] == Qtrue || argv[2] == Qfalse) ? 1 : 0;
+        }
+        if (_v) {
+          return _wrap_FXList_appendItem__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  if ((argc >= 2) && (argc <= 5)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_FXList_appendItem__SWIG_1(nargs, args, self);
+        }
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXIcon, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXList_appendItem__SWIG_1(nargs, args, self);
+          }
+          {
+            _v = 1;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXList_appendItem__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = (argv[4] == Qtrue || argv[4] == Qfalse) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXList_appendItem__SWIG_1(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "appendItem", 
+    "    FXint appendItem(FXListItem *item, FXbool notify)\n"
+    "    FXint appendItem(FXString const &text, FXIcon *icon, void *ITEMDATA, FXbool notify)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_prependItem__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXListItem *arg2 = (FXListItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","prependItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXListItem *","prependItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXListItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXint)FXList_prependItem__SWIG_0(arg1,arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_prependItem__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  void *arg4 = (void *) 0 ;
+  FXbool arg5 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","prependItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","prependItem", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 2) {
+    arg4 = (argv[2] == Qnil) ? NULL : (void *) argv[2];
+  }
+  if (argc > 3) {
+    arg5 = to_FXbool(argv[3]);
+  }
+  result = (FXint)(arg1)->prependItem((FXString const &)*arg2,arg3,arg4,arg5);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXList_prependItem(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 2) && (argc <= 3)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXListItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_FXList_prependItem__SWIG_0(nargs, args, self);
+        }
+        {
+          _v = (argv[2] == Qtrue || argv[2] == Qfalse) ? 1 : 0;
+        }
+        if (_v) {
+          return _wrap_FXList_prependItem__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  if ((argc >= 2) && (argc <= 5)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (NIL_P(argv[1]) || TYPE(argv[1]) == T_STRING) ? 1 : 0;
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_FXList_prependItem__SWIG_1(nargs, args, self);
+        }
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXIcon, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXList_prependItem__SWIG_1(nargs, args, self);
+          }
+          {
+            _v = 1;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXList_prependItem__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = (argv[4] == Qtrue || argv[4] == Qfalse) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXList_prependItem__SWIG_1(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "prependItem", 
+    "    FXint prependItem(FXListItem *item, FXbool notify)\n"
+    "    FXint prependItem(FXString const &text, FXIcon *icon, void *ITEMDATA, FXbool notify)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_moveItem(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","moveItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  result = (FXint)(arg1)->moveItem(arg2,arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_extractItem(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXListItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","extractItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  result = (FXListItem *)(arg1)->extractItem(arg2,arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXListItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_removeItem(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","removeItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  FXList_removeItem(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_clearItems(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","clearItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXList_clearItems(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getItemWidth(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","getItemWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  result = (FXint)((FXList const *)arg1)->getItemWidth(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getItemHeight(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","getItemHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  result = (FXint)((FXList const *)arg1)->getItemHeight(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_hitItem(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","hitItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  result = (FXint)((FXList const *)arg1)->hitItem(arg2,arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_findItem(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXString *arg2 = 0 ;
+  FXint arg3 = (FXint) -1 ;
+  FXuint arg4 = (FXuint) SEARCH_FORWARD|SEARCH_WRAP ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","findItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2UINT(argv[2]);
+  }
+  result = (FXint)((FXList const *)arg1)->findItem((FXString const &)*arg2,arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_findItemByData(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXint arg3 = (FXint) -1 ;
+  FXuint arg4 = (FXuint) SEARCH_FORWARD|SEARCH_WRAP ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","findItemByData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = (argv[0] == Qnil) ? NULL : (void *) argv[0];
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2UINT(argv[2]);
+  }
+  result = (FXint)((FXList const *)arg1)->findItemByData((void const *)arg2,arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_makeItemVisible__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXListItem *arg2 = (FXListItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","makeItemVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXListItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXListItem *","makeItemVisible", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXListItem * >(argp2);
+  FXList_makeItemVisible__SWIG_0(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_setItemText(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","setItemText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  (arg1)->setItemText(arg2,(FXString const &)*arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getItemText(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","getItemText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  result = ((FXList const *)arg1)->getItemText(arg2);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_setItemIcon(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","setItemIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","setItemIcon", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXIcon * >(argp3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  (arg1)->setItemIcon(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getItemIcon(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","getItemIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  result = (FXIcon *)((FXList const *)arg1)->getItemIcon(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_setItemData(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  VALUE arg3 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","setItemData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = argv[1];
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  FXList_setItemData(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getItemData(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","getItemData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  result = (VALUE)FXList_getItemData((FXList const *)arg1,arg2);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_isItemSelected(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","isItemSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  result = (FXbool)((FXList const *)arg1)->isItemSelected(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_isItemCurrent(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","isItemCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  result = (FXbool)((FXList const *)arg1)->isItemCurrent(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_isItemVisible(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","isItemVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  result = (FXbool)((FXList const *)arg1)->isItemVisible(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_isItemEnabled(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","isItemEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  result = (FXbool)((FXList const *)arg1)->isItemEnabled(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_updateItem(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","updateItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  ((FXList const *)arg1)->updateItem(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getCurrentItem(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","getCurrentItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  result = (FXint)((FXList const *)arg1)->getCurrentItem();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_setAnchorItem(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","setAnchorItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  (arg1)->setAnchorItem(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getAnchorItem(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","getAnchorItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  result = (FXint)((FXList const *)arg1)->getAnchorItem();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getCursorItem(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","getCursorItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  result = (FXint)((FXList const *)arg1)->getCursorItem();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_sortItems(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","sortItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  (arg1)->sortItems();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_setFont(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  (arg1)->setFont(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getFont(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  result = (FXFont *)((FXList const *)arg1)->getFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getTextColor(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","getTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  result = (FXColor)((FXList const *)arg1)->getTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_setTextColor(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","setTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","getSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  result = (FXColor)((FXList const *)arg1)->getSelBackColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_setSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","setSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelBackColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","getSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  result = (FXColor)((FXList const *)arg1)->getSelTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_setSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","setSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getListStyle(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","getListStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  result = (FXuint)((FXList const *)arg1)->getListStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_setListStyle(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","setListStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setListStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  result = (FXString *) &((FXList const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_save(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXList_save((FXList const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_load(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXList_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_create(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  FXList_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_detach(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  FXList_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_destroy(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  FXList_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_resize(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXList_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  result = (FXint)FXList_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  result = (FXint)FXList_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXList_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXList_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  result = (bool)FXList_canFocus((FXList const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  FXList_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  FXList_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXList_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXList_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_enable(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  FXList_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_disable(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  FXList_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  FXList_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_lower(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  FXList_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_move(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXList_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXList_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_layout(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  FXList_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_recalc(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  FXList_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_reparent(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXList_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_show(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  FXList_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_hide(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  FXList_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  result = (bool)FXList_isComposite((FXList const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_contains(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXList_contains((FXList const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  result = (bool)FXList_doesSaveUnder((FXList const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXList_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_tr(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXList_tr((FXList const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  FXList_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  FXList_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXList_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXList_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXList_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXList_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXList_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXList_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXList_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  FXList_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getViewportHeight(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","getViewportHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  result = (FXint)FXList_getViewportHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getViewportWidth(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","getViewportWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  result = (FXint)FXList_getViewportWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getContentHeight(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","getContentHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  result = (FXint)FXList_getContentHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getContentWidth(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","getContentWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  result = (FXint)FXList_getContentWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  result = (VALUE)FXList_position__SWIG_1((FXList const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXList_position(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXList_position__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXList_position__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "position", 
+    "    void position(FXint x, FXint y, FXint w, FXint h)\n"
+    "    VALUE position()\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_enableItem(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","enableItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  result = (FXbool)FXList_enableItem(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_disableItem(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","disableItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  result = (FXbool)FXList_disableItem(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_makeItemVisible__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","makeItemVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  FXList_makeItemVisible(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXList_makeItemVisible(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXListItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXList_makeItemVisible__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXList_makeItemVisible__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "makeItemVisible", 
+    "    void makeItemVisible(FXListItem *item)\n"
+    "    void makeItemVisible(FXint index)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_getItemAt(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList const *","getItemAt", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXint)FXList_getItemAt((FXList const *)arg1,arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_selectItem(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","selectItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  result = (FXbool)FXList_selectItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_deselectItem(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","deselectItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  result = (FXbool)FXList_deselectItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_toggleItem(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","toggleItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  result = (FXbool)FXList_toggleItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_extendSelection(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","extendSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  result = (FXbool)FXList_extendSelection(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_killSelection(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","killSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXList_killSelection(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXList_setCurrentItem(int argc, VALUE *argv, VALUE self) {
+  FXList *arg1 = (FXList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXList *","setCurrentItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list item index out of bounds");
+    }
+  }
+  FXList_setCurrentItem(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXColorItem;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXColorItem_allocate(VALUE self)
+#else
+_wrap_FXColorItem_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXColorItem);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXColorItem(int argc, VALUE *argv, VALUE self) {
+  FXString *arg1 = 0 ;
+  FXColor arg2 ;
+  void *arg3 = (void *) 0 ;
+  SwigValueWrapper< FXString > p1 ;
+  FXColorItem *result = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  p1 = to_FXString(argv[0]); arg1 = &p1;
+  arg2 = to_FXColor(argv[1]);
+  if (argc > 2) {
+    arg3 = (argv[2] == Qnil) ? NULL : (void *) argv[2];
+  }
+  {
+    result = (FXColorItem *)new_FXColorItem((FXString const &)*arg1,arg2,arg3);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorItem_colore___(int argc, VALUE *argv, VALUE self) {
+  FXColorItem *arg1 = (FXColorItem *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorItem *","setColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorItem * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorItem_color(int argc, VALUE *argv, VALUE self) {
+  FXColorItem *arg1 = (FXColorItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorItem const *","getColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorItem * >(argp1);
+  result = (FXColor)((FXColorItem const *)arg1)->getColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorItem_save(int argc, VALUE *argv, VALUE self) {
+  FXColorItem *arg1 = (FXColorItem *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorItem const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXColorItem_save((FXColorItem const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorItem_load(int argc, VALUE *argv, VALUE self) {
+  FXColorItem *arg1 = (FXColorItem *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorItem *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXColorItem_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorItem_setText(int argc, VALUE *argv, VALUE self) {
+  FXColorItem *arg1 = (FXColorItem *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorItem *","setText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorItem * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  FXColorItem_setText(arg1,(FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorItem_setIcon(int argc, VALUE *argv, VALUE self) {
+  FXColorItem *arg1 = (FXColorItem *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorItem *","setIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXColorItem_setIcon(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorItem_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorItem *arg1 = (FXColorItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorItem *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXColorItem_setFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorItem_setSelected(int argc, VALUE *argv, VALUE self) {
+  FXColorItem *arg1 = (FXColorItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorItem *","setSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXColorItem_setSelected(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorItem_setEnabled(int argc, VALUE *argv, VALUE self) {
+  FXColorItem *arg1 = (FXColorItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorItem *","setEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXColorItem_setEnabled(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorItem_setDraggable(int argc, VALUE *argv, VALUE self) {
+  FXColorItem *arg1 = (FXColorItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorItem *","setDraggable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXColorItem_setDraggable(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorItem_getWidth(int argc, VALUE *argv, VALUE self) {
+  FXColorItem *arg1 = (FXColorItem *) 0 ;
+  FXList *arg2 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorItem const *","getWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXList const *","getWidth", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXList * >(argp2);
+  result = (FXint)FXColorItem_getWidth((FXColorItem const *)arg1,(FXList const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorItem_getHeight(int argc, VALUE *argv, VALUE self) {
+  FXColorItem *arg1 = (FXColorItem *) 0 ;
+  FXList *arg2 = (FXList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorItem const *","getHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXList const *","getHeight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXList * >(argp2);
+  result = (FXint)FXColorItem_getHeight((FXColorItem const *)arg1,(FXList const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorItem_create(int argc, VALUE *argv, VALUE self) {
+  FXColorItem *arg1 = (FXColorItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorItem *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorItem * >(argp1);
+  FXColorItem_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorItem_detach(int argc, VALUE *argv, VALUE self) {
+  FXColorItem *arg1 = (FXColorItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorItem *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorItem * >(argp1);
+  FXColorItem_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorItem_destroy(int argc, VALUE *argv, VALUE self) {
+  FXColorItem *arg1 = (FXColorItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorItem *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorItem * >(argp1);
+  FXColorItem_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXColorList;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXColorList_allocate(VALUE self)
+#else
+_wrap_FXColorList_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXColorList);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXColorList(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) LIST_BROWSESELECT ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXColorList *result = 0 ;
+  
+  if ((argc < 1) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXColorList", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXColorList", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXColorList *)new_FXColorList(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_fillItems(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXchar **arg2 = (FXchar **) 0 ;
+  FXColor *arg3 = (FXColor *) 0 ;
+  void *arg4 = (void *) 0 ;
+  FXbool arg5 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","fillItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  {
+    arg2 = NULL;
+    if(!NIL_P(argv[0])){
+      Check_Type(argv[0], T_ARRAY);
+      if (FXMALLOC(&arg2, FXchar *, RARRAY_LEN(argv[0])+1)) {
+        for (long i = 0; i < RARRAY_LEN(argv[0]); i++) {
+          VALUE e = rb_ary_entry(argv[0], i);
+          arg2[i] = (FXchar *) StringValuePtr(e);
+        }
+        arg2[RARRAY_LEN(argv[0])] = 0;
+      }
+    }
+  }
+  if (argc > 1) {
+    {
+      arg3 = NULL;
+      if(!NIL_P(argv[1])){
+        Check_Type(argv[1], T_ARRAY);
+        if (FXMALLOC(&arg3, FXColor, RARRAY_LEN(argv[1])+1)) {
+          for (long i = 0; i < RARRAY_LEN(argv[1]); i++) {
+            arg3[i] = static_cast<FXColor>(NUM2ULONG(rb_ary_entry(argv[1], i)));
+          }
+          arg3[RARRAY_LEN(argv[1])] = 0;
+        }
+      }
+    }
+  }
+  if (argc > 2) {
+    arg4 = (argv[2] == Qnil) ? NULL : (void *) argv[2];
+  }
+  if (argc > 3) {
+    arg5 = to_FXbool(argv[3]);
+  }
+  result = (FXint)(arg1)->fillItems((FXchar const **)arg2,arg3,arg4,arg5);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  FXFREE(&arg2);
+  FXFREE(&arg3);
+  return vresult;
+fail:
+  FXFREE(&arg2);
+  FXFREE(&arg3);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_insertItem(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  FXColor arg4 = (FXColor) 0 ;
+  void *arg5 = (void *) 0 ;
+  FXbool arg6 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","insertItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  if (argc > 2) {
+    arg4 = to_FXColor(argv[2]);
+  }
+  if (argc > 3) {
+    arg5 = (argv[3] == Qnil) ? NULL : (void *) argv[3];
+  }
+  if (argc > 4) {
+    arg6 = to_FXbool(argv[4]);
+  }
+  result = (FXint)(arg1)->insertItem(arg2,(FXString const &)*arg3,arg4,arg5,arg6);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_appendItem(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXString *arg2 = 0 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *arg4 = (void *) 0 ;
+  FXbool arg5 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","appendItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = (argv[2] == Qnil) ? NULL : (void *) argv[2];
+  }
+  if (argc > 3) {
+    arg5 = to_FXbool(argv[3]);
+  }
+  result = (FXint)(arg1)->appendItem((FXString const &)*arg2,arg3,arg4,arg5);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_prependItem(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXString *arg2 = 0 ;
+  FXColor arg3 = (FXColor) 0 ;
+  void *arg4 = (void *) 0 ;
+  FXbool arg5 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","prependItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    arg3 = to_FXColor(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = (argv[2] == Qnil) ? NULL : (void *) argv[2];
+  }
+  if (argc > 3) {
+    arg5 = to_FXbool(argv[3]);
+  }
+  result = (FXint)(arg1)->prependItem((FXString const &)*arg2,arg3,arg4,arg5);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_setItemColor(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXint arg2 ;
+  FXColor arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","setItemColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = to_FXColor(argv[1]);
+  (arg1)->setItemColor(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_getItemColor(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList const *","getItemColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXColor)((FXColorList const *)arg1)->getItemColor(arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_save(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXColorList_save((FXColorList const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_load(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXColorList_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_create(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  FXColorList_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_detach(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  FXColorList_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_destroy(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  FXColorList_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_resize(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXColorList_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  result = (FXint)FXColorList_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  result = (FXint)FXColorList_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXColorList_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXColorList_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  result = (bool)FXColorList_canFocus((FXColorList const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  FXColorList_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  FXColorList_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXColorList_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXColorList_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_enable(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  FXColorList_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_disable(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  FXColorList_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  FXColorList_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_lower(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  FXColorList_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_move(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXColorList_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXColorList_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_layout(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  FXColorList_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_recalc(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  FXColorList_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_reparent(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXColorList_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_show(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  FXColorList_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_hide(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  FXColorList_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  result = (bool)FXColorList_isComposite((FXColorList const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_contains(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXColorList_contains((FXColorList const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  result = (bool)FXColorList_doesSaveUnder((FXColorList const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXColorList_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_tr(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXColorList_tr((FXColorList const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  FXColorList_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  FXColorList_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXColorList_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXColorList_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXColorList_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXColorList_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXColorList_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXColorList_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXColorList_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  FXColorList_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_getViewportHeight(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","getViewportHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  result = (FXint)FXColorList_getViewportHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_getViewportWidth(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","getViewportWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  result = (FXint)FXColorList_getViewportWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_getContentHeight(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","getContentHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  result = (FXint)FXColorList_getContentHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_getContentWidth(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","getContentWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  result = (FXint)FXColorList_getContentWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList const *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  result = (VALUE)FXColorList_position__SWIG_1((FXColorList const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXColorList_position(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXColorList_position__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXColorList_position__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "position", 
+    "    void position(FXint x, FXint y, FXint w, FXint h)\n"
+    "    VALUE position()\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_enableItem(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","enableItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXbool)FXColorList_enableItem(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_disableItem(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","disableItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXbool)FXColorList_disableItem(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_makeItemVisible(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","makeItemVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  FXColorList_makeItemVisible(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_getItemAt(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList const *","getItemAt", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXint)FXColorList_getItemAt((FXColorList const *)arg1,arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_selectItem(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","selectItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXColorList_selectItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_deselectItem(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","deselectItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXColorList_deselectItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_toggleItem(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","toggleItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXColorList_toggleItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_extendSelection(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","extendSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXColorList_extendSelection(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_killSelection(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","killSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXColorList_killSelection(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorList_setCurrentItem(int argc, VALUE *argv, VALUE self) {
+  FXColorList *arg1 = (FXColorList *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorList *","setCurrentItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXColorList_setCurrentItem(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_FXFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FXDockSiteTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXPopupTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXColorListTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *)(FXList *) ((FXColorList *) x));
+}
+static void *_p_FXShutterItemTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXStatusBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXMainWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXCompositeTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXCursor *) x));
+}
+static void *_p_FXDrawableTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXDrawable *) x));
+}
+static void *_p_FXSplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXFontTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXFont *) x));
+}
+static void *_p_FXPackerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXShutterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXVisualTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXVisual *) x));
+}
+static void *_p_FXMatrixTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXListTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXList *) x));
+}
+static void *_p_FXSpringTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXSwitcherTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXSettingsTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXSettings *) x));
+}
+static void *_p_FXAccelTableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXAccelTable *) x));
+}
+static void *_p_FXCompositeTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXColorItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXListItem *) ((FXColorItem *) x));
+}
+static void *_p_FXRegistryTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *)(FXSettings *) ((FXRegistry *) x));
+}
+static void *_p_FXIconDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXIconDict *) x));
+}
+static void *_p_FXShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXPopupTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXStatusBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXRecentFilesTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXRecentFiles *) x));
+}
+static void *_p_FXDocumentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDocument *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXSplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXStringDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXStringDict *) x));
+}
+static void *_p_FXPackerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXFontTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXFont *) x));
+}
+static void *_p_FXListTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXList *) x));
+}
+static void *_p_FXFileDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXFileDict *) x));
+}
+static void *_p_FXDataTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDataTarget *) x));
+}
+static void *_p_FXDebugTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDebugTarget *) x));
+}
+static void *_p_FXSwitcherTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXShutterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXDelegatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDelegator *) x));
+}
+static void *_p_FXDrawableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXDrawable *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXCursor *) x));
+}
+static void *_p_FXTranslatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXTranslator *) x));
+}
+static void *_p_FXDockSiteTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDict *) x));
+}
+static void *_p_FXMatrixTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXShutterItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXListItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXListItem *) x));
+}
+static void *_p_FXIdTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXId *) x));
+}
+static void *_p_FXFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FXColorListTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *)(FXList *) ((FXColorList *) x));
+}
+static void *_p_FXSpringTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXVisualTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXVisual *) x));
+}
+static void *_p_FXAppTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXApp *) x));
+}
+static void *_p_FXListTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXList *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXScrollWindow *) x));
+}
+static void *_p_FXColorListTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *) (FXList *) ((FXColorList *) x));
+}
+static void *_p_FXDockSiteTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXFrame *) x));
+}
+static void *_p_FXPopupTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXColorListTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *)(FXList *) ((FXColorList *) x));
+}
+static void *_p_FXShutterItemTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXStatusBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXCompositeTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXComposite *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXSplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXPackerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXShutterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXMatrixTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXListTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXList *) x));
+}
+static void *_p_FXSpringTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXSwitcherTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXDockSiteTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXPopupTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXColorListTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *)(FXList *) ((FXColorList *) x));
+}
+static void *_p_FXShutterItemTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXScrollArea *) x));
+}
+static void *_p_FXStatusBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXRootWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXShell *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXSplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FX4Splitter *) x));
+}
+static void *_p_FXPackerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXPacker *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXShutterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXMatrixTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXListTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXList *) x));
+}
+static void *_p_FXSpringTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXSwitcherTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXDockSiteTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FXPopupTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXColorListTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *)(FXList *) ((FXColorList *) x));
+}
+static void *_p_FXShutterItemTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXStatusBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *)  ((FXWindow *) x));
+}
+static void *_p_FXCompositeTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXSplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXPackerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXShutterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXMatrixTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXListTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXList *) x));
+}
+static void *_p_FXSpringTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXSwitcherTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXFileStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXFileStream *) x));
+}
+static void *_p_FXMemoryStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXMemoryStream *) x));
+}
+static void *_p_FXColorListTo_p_FXList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXList *)  ((FXColorList *) x));
+}
+static void *_p_FXColorItemTo_p_FXListItem(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXListItem *)  ((FXColorItem *) x));
+}
+static swig_type_info _swigt__p_FXBitmap = {"_p_FXBitmap", "FXBitmap *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXColorItem = {"_p_FXColorItem", "FXColorItem *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXColorList = {"_p_FXColorList", "FXColorList *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXComposite = {"_p_FXComposite", "FXComposite *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDockSite = {"_p_FXDockSite", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPopup = {"_p_FXPopup", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutterItem = {"_p_FXShutterItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusBar = {"_p_FXStatusBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplashWindow = {"_p_FXSplashWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMainWindow = {"_p_FXMainWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTopWindow = {"_p_FXTopWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRootWindow = {"_p_FXRootWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollWindow = {"_p_FXScrollWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShell = {"_p_FXShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGroupBox = {"_p_FXGroupBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplitter = {"_p_FXSplitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FX4Splitter = {"_p_FX4Splitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPacker = {"_p_FXPacker", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalFrame = {"_p_FXVerticalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalFrame = {"_p_FXHorizontalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutter = {"_p_FXShutter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMatrix = {"_p_FXMatrix", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSpring = {"_p_FXSpring", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSwitcher = {"_p_FXSwitcher", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDrawable = {"_p_FXDrawable", "FXDrawable *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFrame = {"_p_FXFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFont = {"_p_FXFont", "FXFont *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXIcon = {"_p_FXIcon", "FXIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXId = {"_p_FXId", "FXId *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGIFCursor = {"_p_FXGIFCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCURCursor = {"_p_FXCURCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCursor = {"_p_FXCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVisual = {"_p_FXVisual", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXList = {"_p_FXList", "FXList *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXListItem = {"_p_FXListItem", "FXListItem *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXObject = {"_p_FXObject", "FXObject *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDict = {"_p_FXDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSettings = {"_p_FXSettings", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXAccelTable = {"_p_FXAccelTable", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRegistry = {"_p_FXRegistry", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXIconDict = {"_p_FXIconDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRecentFiles = {"_p_FXRecentFiles", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDocument = {"_p_FXDocument", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStringDict = {"_p_FXStringDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileDict = {"_p_FXFileDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDebugTarget = {"_p_FXDebugTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDataTarget = {"_p_FXDataTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDelegator = {"_p_FXDelegator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTranslator = {"_p_FXTranslator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXApp = {"_p_FXApp", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRegion = {"_p_FXRegion", "FXRegion *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXScrollArea = {"_p_FXScrollArea", "FXScrollArea *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXStream = {"_p_FXStream", "FXStream *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFileStream = {"_p_FXFileStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMemoryStream = {"_p_FXMemoryStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXWindow = {"_p_FXWindow", "FXWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_char = {"_p_char", "char *|FXchar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "double *|FXdouble *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_float = {"_p_float", "float *|FXfloat *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "FXint *|int *|FXInputHandle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_long = {"_p_long", "long *|FXTime *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_short = {"_p_short", "short *|FXshort *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "FXuchar *|unsigned char *|FXbool *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "FXwchar *|FXDragType *|unsigned int *|FXuint *|FXColor *|FXSelector *|FXHotKey *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|FXuval *|FXPixel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|FXushort *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_FX4Splitter,
+  &_swigt__p_FXAccelTable,
+  &_swigt__p_FXApp,
+  &_swigt__p_FXBitmap,
+  &_swigt__p_FXCURCursor,
+  &_swigt__p_FXColorItem,
+  &_swigt__p_FXColorList,
+  &_swigt__p_FXComposite,
+  &_swigt__p_FXCursor,
+  &_swigt__p_FXDataTarget,
+  &_swigt__p_FXDebugTarget,
+  &_swigt__p_FXDelegator,
+  &_swigt__p_FXDict,
+  &_swigt__p_FXDockSite,
+  &_swigt__p_FXDocument,
+  &_swigt__p_FXDrawable,
+  &_swigt__p_FXFileDict,
+  &_swigt__p_FXFileStream,
+  &_swigt__p_FXFont,
+  &_swigt__p_FXFrame,
+  &_swigt__p_FXGIFCursor,
+  &_swigt__p_FXGroupBox,
+  &_swigt__p_FXHorizontalFrame,
+  &_swigt__p_FXIcon,
+  &_swigt__p_FXIconDict,
+  &_swigt__p_FXId,
+  &_swigt__p_FXList,
+  &_swigt__p_FXListItem,
+  &_swigt__p_FXMainWindow,
+  &_swigt__p_FXMatrix,
+  &_swigt__p_FXMemoryStream,
+  &_swigt__p_FXObject,
+  &_swigt__p_FXPacker,
+  &_swigt__p_FXPopup,
+  &_swigt__p_FXRecentFiles,
+  &_swigt__p_FXRegion,
+  &_swigt__p_FXRegistry,
+  &_swigt__p_FXRootWindow,
+  &_swigt__p_FXScrollArea,
+  &_swigt__p_FXScrollWindow,
+  &_swigt__p_FXSettings,
+  &_swigt__p_FXShell,
+  &_swigt__p_FXShutter,
+  &_swigt__p_FXShutterItem,
+  &_swigt__p_FXSplashWindow,
+  &_swigt__p_FXSplitter,
+  &_swigt__p_FXSpring,
+  &_swigt__p_FXStatusBar,
+  &_swigt__p_FXStream,
+  &_swigt__p_FXStringDict,
+  &_swigt__p_FXSwitcher,
+  &_swigt__p_FXTopWindow,
+  &_swigt__p_FXTranslator,
+  &_swigt__p_FXVerticalFrame,
+  &_swigt__p_FXVisual,
+  &_swigt__p_FXWindow,
+  &_swigt__p_char,
+  &_swigt__p_double,
+  &_swigt__p_float,
+  &_swigt__p_int,
+  &_swigt__p_long,
+  &_swigt__p_short,
+  &_swigt__p_unsigned_char,
+  &_swigt__p_unsigned_int,
+  &_swigt__p_unsigned_long,
+  &_swigt__p_unsigned_short,
+};
+
+static swig_cast_info _swigc__p_FXBitmap[] = {  {&_swigt__p_FXBitmap, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorItem[] = {  {&_swigt__p_FXColorItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorList[] = {  {&_swigt__p_FXColorList, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockSite[] = {{&_swigt__p_FXDockSite, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPopup[] = {{&_swigt__p_FXPopup, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutterItem[] = {{&_swigt__p_FXShutterItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusBar[] = {{&_swigt__p_FXStatusBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplashWindow[] = {{&_swigt__p_FXSplashWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMainWindow[] = {{&_swigt__p_FXMainWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTopWindow[] = {{&_swigt__p_FXTopWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRootWindow[] = {{&_swigt__p_FXRootWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollWindow[] = {{&_swigt__p_FXScrollWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShell[] = {{&_swigt__p_FXShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGroupBox[] = {{&_swigt__p_FXGroupBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplitter[] = {{&_swigt__p_FXSplitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FX4Splitter[] = {{&_swigt__p_FX4Splitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPacker[] = {{&_swigt__p_FXPacker, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalFrame[] = {{&_swigt__p_FXVerticalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalFrame[] = {{&_swigt__p_FXHorizontalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutter[] = {{&_swigt__p_FXShutter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMatrix[] = {{&_swigt__p_FXMatrix, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpring[] = {{&_swigt__p_FXSpring, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSwitcher[] = {{&_swigt__p_FXSwitcher, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComposite[] = {  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXComposite, 0, 0},  {&_swigt__p_FXColorList, _p_FXColorListTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXComposite, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXComposite, 0, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXComposite, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXList, _p_FXListTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXComposite, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFrame[] = {{&_swigt__p_FXFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDrawable[] = {  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorList, _p_FXColorListTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDrawable, 0, 0, 0},  {&_swigt__p_FXList, _p_FXListTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXDrawable, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFont[] = {  {&_swigt__p_FXFont, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIcon[] = {  {&_swigt__p_FXIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGIFCursor[] = {{&_swigt__p_FXGIFCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCURCursor[] = {{&_swigt__p_FXCURCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCursor[] = {{&_swigt__p_FXCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVisual[] = {{&_swigt__p_FXVisual, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXId[] = {  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXId, 0, 0},  {&_swigt__p_FXColorList, _p_FXColorListTo_p_FXId, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXId, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXId, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXId, 0, 0},  {&_swigt__p_FXId, 0, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXId, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXId, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXList, _p_FXListTo_p_FXId, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXId, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXId, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXId, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXId, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXId, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXId, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXId, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXId, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXList[] = {  {&_swigt__p_FXList, 0, 0, 0},  {&_swigt__p_FXColorList, _p_FXColorListTo_p_FXList, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXListItem[] = {  {&_swigt__p_FXColorItem, _p_FXColorItemTo_p_FXListItem, 0, 0},  {&_swigt__p_FXListItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDict[] = {{&_swigt__p_FXDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSettings[] = {{&_swigt__p_FXSettings, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXAccelTable[] = {{&_swigt__p_FXAccelTable, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegistry[] = {{&_swigt__p_FXRegistry, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIconDict[] = {{&_swigt__p_FXIconDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRecentFiles[] = {{&_swigt__p_FXRecentFiles, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDocument[] = {{&_swigt__p_FXDocument, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStringDict[] = {{&_swigt__p_FXStringDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileDict[] = {{&_swigt__p_FXFileDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDebugTarget[] = {{&_swigt__p_FXDebugTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDataTarget[] = {{&_swigt__p_FXDataTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDelegator[] = {{&_swigt__p_FXDelegator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTranslator[] = {{&_swigt__p_FXTranslator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXApp[] = {{&_swigt__p_FXApp, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXObject[] = {  {&_swigt__p_FXDict, _p_FXDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXSettings, _p_FXSettingsTo_p_FXObject, 0, 0},  {&_swigt__p_FXAccelTable, _p_FXAccelTableTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorItem, _p_FXColorItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXObject, 0, 0},  {&_swigt__p_FXRegistry, _p_FXRegistryTo_p_FXObject, 0, 0},  {&_swigt__p_FXId, _p_FXIdTo_p_FXObject, 0, 0},  {&_swigt__p_FXIconDict, _p_FXIconDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXObject, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXObject, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXRecentFiles, _p_FXRecentFilesTo_p_FXObject, 0, 0},  {&_swigt__p_FXDocument, _p_FXDocumentTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FXObject, 0, 0, 0},  {&_swigt__p_FXStringDict, _p_FXStringDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileDict, _p_FXFileDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXObject, 0, 0},  {&_swigt__p_FXDebugTarget, _p_FXDebugTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDataTarget, _p_FXDataTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXObject, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXObject, 0, 0},  {&_swigt__p_FXDelegator, _p_FXDelegatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXObject, 0, 0},  {&_swigt__p_FXTranslator, _p_FXTranslatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXApp, _p_FXAppTo_p_FXObject, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXListItem, _p_FXListItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXList, _p_FXListTo_p_FXObject, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorList, _p_FXColorListTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXObject, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXObject, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegion[] = {  {&_swigt__p_FXRegion, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollArea[] = {  {&_swigt__p_FXList, _p_FXListTo_p_FXScrollArea, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXScrollArea, 0, 0},  {&_swigt__p_FXScrollArea, 0, 0, 0},  {&_swigt__p_FXColorList, _p_FXColorListTo_p_FXScrollArea, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileStream[] = {{&_swigt__p_FXFileStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMemoryStream[] = {{&_swigt__p_FXMemoryStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStream[] = {  {&_swigt__p_FXFileStream, _p_FXFileStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXMemoryStream, _p_FXMemoryStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXWindow[] = {  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorList, _p_FXColorListTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXWindow, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXWindow, 0, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXList, _p_FXListTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXWindow, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
+
+static swig_cast_info *swig_cast_initial[] = {
+  _swigc__p_FX4Splitter,
+  _swigc__p_FXAccelTable,
+  _swigc__p_FXApp,
+  _swigc__p_FXBitmap,
+  _swigc__p_FXCURCursor,
+  _swigc__p_FXColorItem,
+  _swigc__p_FXColorList,
+  _swigc__p_FXComposite,
+  _swigc__p_FXCursor,
+  _swigc__p_FXDataTarget,
+  _swigc__p_FXDebugTarget,
+  _swigc__p_FXDelegator,
+  _swigc__p_FXDict,
+  _swigc__p_FXDockSite,
+  _swigc__p_FXDocument,
+  _swigc__p_FXDrawable,
+  _swigc__p_FXFileDict,
+  _swigc__p_FXFileStream,
+  _swigc__p_FXFont,
+  _swigc__p_FXFrame,
+  _swigc__p_FXGIFCursor,
+  _swigc__p_FXGroupBox,
+  _swigc__p_FXHorizontalFrame,
+  _swigc__p_FXIcon,
+  _swigc__p_FXIconDict,
+  _swigc__p_FXId,
+  _swigc__p_FXList,
+  _swigc__p_FXListItem,
+  _swigc__p_FXMainWindow,
+  _swigc__p_FXMatrix,
+  _swigc__p_FXMemoryStream,
+  _swigc__p_FXObject,
+  _swigc__p_FXPacker,
+  _swigc__p_FXPopup,
+  _swigc__p_FXRecentFiles,
+  _swigc__p_FXRegion,
+  _swigc__p_FXRegistry,
+  _swigc__p_FXRootWindow,
+  _swigc__p_FXScrollArea,
+  _swigc__p_FXScrollWindow,
+  _swigc__p_FXSettings,
+  _swigc__p_FXShell,
+  _swigc__p_FXShutter,
+  _swigc__p_FXShutterItem,
+  _swigc__p_FXSplashWindow,
+  _swigc__p_FXSplitter,
+  _swigc__p_FXSpring,
+  _swigc__p_FXStatusBar,
+  _swigc__p_FXStream,
+  _swigc__p_FXStringDict,
+  _swigc__p_FXSwitcher,
+  _swigc__p_FXTopWindow,
+  _swigc__p_FXTranslator,
+  _swigc__p_FXVerticalFrame,
+  _swigc__p_FXVisual,
+  _swigc__p_FXWindow,
+  _swigc__p_char,
+  _swigc__p_double,
+  _swigc__p_float,
+  _swigc__p_int,
+  _swigc__p_long,
+  _swigc__p_short,
+  _swigc__p_unsigned_char,
+  _swigc__p_unsigned_int,
+  _swigc__p_unsigned_long,
+  _swigc__p_unsigned_short,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned statically to an initial
+ * array. We just loop through that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded.
+ * There are three cases to handle:
+ *  1) If the cast->type has already been loaded AND the type we are adding
+ *     casting info to has not been loaded (it is in this module), THEN we
+ *     replace the cast->type pointer with the type pointer that has already
+ *     been loaded.
+ *  2) If BOTH types (the one we are adding casting info to, and the
+ *     cast->type) are loaded, THEN the cast info has already been loaded by
+ *     the previous module so we just ignore it.
+ *  3) Finally, if cast->type has not already been loaded, then we add that
+ *     swig_cast_info to the linked list (because the cast->type) pointer will
+ *     be correct.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* c-mode */
+#endif
+#endif
+
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+  size_t i;
+  swig_module_info *module_head, *iter;
+  int init;
+
+  /* check to see if the circular list has been setup, if not, set it up */
+  if (swig_module.next==0) {
+    /* Initialize the swig_module */
+    swig_module.type_initial = swig_type_initial;
+    swig_module.cast_initial = swig_cast_initial;
+    swig_module.next = &swig_module;
+    init = 1;
+  } else {
+    init = 0;
+  }
+
+  /* Try and load any already created modules */
+  module_head = SWIG_GetModule(clientdata);
+  if (!module_head) {
+    /* This is the first module loaded for this interpreter */
+    /* so set the swig module into the interpreter */
+    SWIG_SetModule(clientdata, &swig_module);
+  } else {
+    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+    iter=module_head;
+    do {
+      if (iter==&swig_module) {
+        /* Our module is already in the list, so there's nothing more to do. */
+        return;
+      }
+      iter=iter->next;
+    } while (iter!= module_head);
+
+    /* otherwise we must add our module into the list */
+    swig_module.next = module_head->next;
+    module_head->next = &swig_module;
+  }
+
+  /* When multiple interpreters are used, a module could have already been initialized in
+     a different interpreter, but not yet have a pointer in this interpreter.
+     In this case, we do not want to continue adding types... everything should be
+     set up already */
+  if (init == 0) return;
+
+  /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+  for (i = 0; i < swig_module.size; ++i) {
+    swig_type_info *type = 0;
+    swig_type_info *ret;
+    swig_cast_info *cast;
+
+#ifdef SWIGRUNTIME_DEBUG
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+
+    /* if there is another module already loaded */
+    if (swig_module.next != &swig_module) {
+      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
+    }
+    if (type) {
+      /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+      if (swig_module.type_initial[i]->clientdata) {
+	type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+      }
+    } else {
+      type = swig_module.type_initial[i];
+    }
+
+    /* Insert casting types */
+    cast = swig_module.cast_initial[i];
+    while (cast->type) {
+
+      /* Don't need to add information already in the list */
+      ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+      if (swig_module.next != &swig_module) {
+        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+      }
+      if (ret) {
+	if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+	  cast->type = ret;
+	  ret = 0;
+	} else {
+	  /* Check for casting already in the list */
+	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+	  if (!ocast) ret = 0;
+	}
+      }
+
+      if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+        if (type->cast) {
+          type->cast->prev = cast;
+          cast->next = type->cast;
+        }
+        type->cast = cast;
+      }
+      cast++;
+    }
+    /* Set entry in modules->types array equal to the type */
+    swig_module.types[i] = type;
+  }
+  swig_module.types[i] = 0;
+
+#ifdef SWIGRUNTIME_DEBUG
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+  for (i = 0; i < swig_module.size; ++i) {
+    int j = 0;
+    swig_cast_info *cast = swig_module.cast_initial[i];
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    while (cast->type) {
+      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+      cast++;
+      ++j;
+    }
+  printf("---- Total casts: %d\n",j);
+  }
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types.  It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+  size_t i;
+  swig_cast_info *equiv;
+  static int init_run = 0;
+
+  if (init_run) return;
+  init_run = 1;
+
+  for (i = 0; i < swig_module.size; i++) {
+    if (swig_module.types[i]->clientdata) {
+      equiv = swig_module.types[i]->cast;
+      while (equiv) {
+        if (!equiv->converter) {
+          if (equiv->type && !equiv->type->clientdata)
+            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+        }
+        equiv = equiv->next;
+      }
+    }
+  }
+}
+
+#ifdef __cplusplus
+#if 0
+{ /* c-mode */
+#endif
+}
+#endif
+
+/*
+
+*/
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void Init_list(void) {
+  size_t i;
+  
+  SWIG_InitRuntime();
+  
+  
+  SWIG_InitializeModule(0);
+  for (i = 0; i < swig_module.size; i++) {
+    SWIG_define_class(swig_module.types[i]);
+  }
+  
+  SWIG_RubyInitializeTrackings();
+  
+  
+  rb_define_const(mFox, "LIST_EXTENDEDSELECT", SWIG_From_int(static_cast< int >(LIST_EXTENDEDSELECT)));
+  rb_define_const(mFox, "LIST_SINGLESELECT", SWIG_From_int(static_cast< int >(LIST_SINGLESELECT)));
+  rb_define_const(mFox, "LIST_BROWSESELECT", SWIG_From_int(static_cast< int >(LIST_BROWSESELECT)));
+  rb_define_const(mFox, "LIST_MULTIPLESELECT", SWIG_From_int(static_cast< int >(LIST_MULTIPLESELECT)));
+  rb_define_const(mFox, "LIST_AUTOSELECT", SWIG_From_int(static_cast< int >(LIST_AUTOSELECT)));
+  rb_define_const(mFox, "LIST_NORMAL", SWIG_From_int(static_cast< int >(LIST_NORMAL)));
+  
+  SwigClassFXListItem.klass = rb_define_class_under(mFox, "FXListItem", ((swig_class *) SWIGTYPE_p_FXObject->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXListItem, (void *) &SwigClassFXListItem);
+  rb_define_alloc_func(SwigClassFXListItem.klass, _wrap_FXListItem_allocate);
+  rb_define_method(SwigClassFXListItem.klass, "initialize", VALUEFUNC(_wrap_new_FXListItem), -1);
+  rb_define_const(SwigClassFXListItem.klass, "SELECTED", SWIG_From_int(static_cast< int >(FXListItem::SELECTED)));
+  rb_define_const(SwigClassFXListItem.klass, "FOCUS", SWIG_From_int(static_cast< int >(FXListItem::FOCUS)));
+  rb_define_const(SwigClassFXListItem.klass, "DISABLED", SWIG_From_int(static_cast< int >(FXListItem::DISABLED)));
+  rb_define_const(SwigClassFXListItem.klass, "DRAGGABLE", SWIG_From_int(static_cast< int >(FXListItem::DRAGGABLE)));
+  rb_define_const(SwigClassFXListItem.klass, "ICONOWNED", SWIG_From_int(static_cast< int >(FXListItem::ICONOWNED)));
+  rb_define_method(SwigClassFXListItem.klass, "getText", VALUEFUNC(_wrap_FXListItem_getText), -1);
+  rb_define_method(SwigClassFXListItem.klass, "getIcon", VALUEFUNC(_wrap_FXListItem_getIcon), -1);
+  rb_define_method(SwigClassFXListItem.klass, "setData", VALUEFUNC(_wrap_FXListItem_setData), -1);
+  rb_define_method(SwigClassFXListItem.klass, "getData", VALUEFUNC(_wrap_FXListItem_getData), -1);
+  rb_define_method(SwigClassFXListItem.klass, "hasFocus", VALUEFUNC(_wrap_FXListItem_hasFocus), -1);
+  rb_define_method(SwigClassFXListItem.klass, "isSelected", VALUEFUNC(_wrap_FXListItem_isSelected), -1);
+  rb_define_method(SwigClassFXListItem.klass, "isEnabled", VALUEFUNC(_wrap_FXListItem_isEnabled), -1);
+  rb_define_method(SwigClassFXListItem.klass, "isDraggable", VALUEFUNC(_wrap_FXListItem_isDraggable), -1);
+  rb_define_method(SwigClassFXListItem.klass, "save", VALUEFUNC(_wrap_FXListItem_save), -1);
+  rb_define_method(SwigClassFXListItem.klass, "load", VALUEFUNC(_wrap_FXListItem_load), -1);
+  rb_define_method(SwigClassFXListItem.klass, "setText", VALUEFUNC(_wrap_FXListItem_setText), -1);
+  rb_define_method(SwigClassFXListItem.klass, "setIcon", VALUEFUNC(_wrap_FXListItem_setIcon), -1);
+  rb_define_method(SwigClassFXListItem.klass, "setFocus", VALUEFUNC(_wrap_FXListItem_setFocus), -1);
+  rb_define_method(SwigClassFXListItem.klass, "setSelected", VALUEFUNC(_wrap_FXListItem_setSelected), -1);
+  rb_define_method(SwigClassFXListItem.klass, "setEnabled", VALUEFUNC(_wrap_FXListItem_setEnabled), -1);
+  rb_define_method(SwigClassFXListItem.klass, "setDraggable", VALUEFUNC(_wrap_FXListItem_setDraggable), -1);
+  rb_define_method(SwigClassFXListItem.klass, "getWidth", VALUEFUNC(_wrap_FXListItem_getWidth), -1);
+  rb_define_method(SwigClassFXListItem.klass, "getHeight", VALUEFUNC(_wrap_FXListItem_getHeight), -1);
+  rb_define_method(SwigClassFXListItem.klass, "create", VALUEFUNC(_wrap_FXListItem_create), -1);
+  rb_define_method(SwigClassFXListItem.klass, "detach", VALUEFUNC(_wrap_FXListItem_detach), -1);
+  rb_define_method(SwigClassFXListItem.klass, "destroy", VALUEFUNC(_wrap_FXListItem_destroy), -1);
+  SwigClassFXListItem.mark = (void (*)(void *)) FXRbListItem::markfunc;
+  SwigClassFXListItem.destroy = (void (*)(void *)) FXRbListItem::freefunc;
+  SwigClassFXListItem.trackObjects = 0;
+  
+  SWIGTYPE_p_FXListItem->dcast = (swig_dycast_func) FXListItem_dynamic_cast;
+  
+  
+  SwigClassFXList.klass = rb_define_class_under(mFox, "FXList", ((swig_class *) SWIGTYPE_p_FXScrollArea->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXList, (void *) &SwigClassFXList);
+  rb_define_alloc_func(SwigClassFXList.klass, _wrap_FXList_allocate);
+  rb_define_method(SwigClassFXList.klass, "initialize", VALUEFUNC(_wrap_new_FXList), -1);
+  rb_define_method(SwigClassFXList.klass, "onPaint", VALUEFUNC(_wrap_FXList_onPaint), -1);
+  rb_define_method(SwigClassFXList.klass, "onEnter", VALUEFUNC(_wrap_FXList_onEnter), -1);
+  rb_define_method(SwigClassFXList.klass, "onLeave", VALUEFUNC(_wrap_FXList_onLeave), -1);
+  rb_define_method(SwigClassFXList.klass, "onUngrabbed", VALUEFUNC(_wrap_FXList_onUngrabbed), -1);
+  rb_define_method(SwigClassFXList.klass, "onKeyPress", VALUEFUNC(_wrap_FXList_onKeyPress), -1);
+  rb_define_method(SwigClassFXList.klass, "onKeyRelease", VALUEFUNC(_wrap_FXList_onKeyRelease), -1);
+  rb_define_method(SwigClassFXList.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXList_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXList.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXList_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXList.klass, "onRightBtnPress", VALUEFUNC(_wrap_FXList_onRightBtnPress), -1);
+  rb_define_method(SwigClassFXList.klass, "onRightBtnRelease", VALUEFUNC(_wrap_FXList_onRightBtnRelease), -1);
+  rb_define_method(SwigClassFXList.klass, "onMotion", VALUEFUNC(_wrap_FXList_onMotion), -1);
+  rb_define_method(SwigClassFXList.klass, "onFocusIn", VALUEFUNC(_wrap_FXList_onFocusIn), -1);
+  rb_define_method(SwigClassFXList.klass, "onFocusOut", VALUEFUNC(_wrap_FXList_onFocusOut), -1);
+  rb_define_method(SwigClassFXList.klass, "onAutoScroll", VALUEFUNC(_wrap_FXList_onAutoScroll), -1);
+  rb_define_method(SwigClassFXList.klass, "onClicked", VALUEFUNC(_wrap_FXList_onClicked), -1);
+  rb_define_method(SwigClassFXList.klass, "onDoubleClicked", VALUEFUNC(_wrap_FXList_onDoubleClicked), -1);
+  rb_define_method(SwigClassFXList.klass, "onTripleClicked", VALUEFUNC(_wrap_FXList_onTripleClicked), -1);
+  rb_define_method(SwigClassFXList.klass, "onCommand", VALUEFUNC(_wrap_FXList_onCommand), -1);
+  rb_define_method(SwigClassFXList.klass, "onQueryTip", VALUEFUNC(_wrap_FXList_onQueryTip), -1);
+  rb_define_method(SwigClassFXList.klass, "onQueryHelp", VALUEFUNC(_wrap_FXList_onQueryHelp), -1);
+  rb_define_method(SwigClassFXList.klass, "onTipTimer", VALUEFUNC(_wrap_FXList_onTipTimer), -1);
+  rb_define_method(SwigClassFXList.klass, "onLookupTimer", VALUEFUNC(_wrap_FXList_onLookupTimer), -1);
+  rb_define_method(SwigClassFXList.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXList_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXList.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXList_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXList.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXList_onCmdSetIntValue), -1);
+  rb_define_singleton_method(SwigClassFXList.klass, "ascending", VALUEFUNC(_wrap_FXList_ascending), -1);
+  rb_define_singleton_method(SwigClassFXList.klass, "descending", VALUEFUNC(_wrap_FXList_descending), -1);
+  rb_define_singleton_method(SwigClassFXList.klass, "ascendingCase", VALUEFUNC(_wrap_FXList_ascendingCase), -1);
+  rb_define_singleton_method(SwigClassFXList.klass, "descendingCase", VALUEFUNC(_wrap_FXList_descendingCase), -1);
+  rb_define_const(SwigClassFXList.klass, "ID_LOOKUPTIMER", SWIG_From_int(static_cast< int >(FXList::ID_LOOKUPTIMER)));
+  rb_define_const(SwigClassFXList.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXList::ID_LAST)));
+  rb_define_method(SwigClassFXList.klass, "getNumItems", VALUEFUNC(_wrap_FXList_getNumItems), -1);
+  rb_define_method(SwigClassFXList.klass, "getNumVisible", VALUEFUNC(_wrap_FXList_getNumVisible), -1);
+  rb_define_method(SwigClassFXList.klass, "setNumVisible", VALUEFUNC(_wrap_FXList_setNumVisible), -1);
+  rb_define_method(SwigClassFXList.klass, "getItem", VALUEFUNC(_wrap_FXList_getItem), -1);
+  rb_define_method(SwigClassFXList.klass, "setItem", VALUEFUNC(_wrap_FXList_setItem), -1);
+  rb_define_method(SwigClassFXList.klass, "fillItems", VALUEFUNC(_wrap_FXList_fillItems), -1);
+  rb_define_method(SwigClassFXList.klass, "insertItem", VALUEFUNC(_wrap_FXList_insertItem), -1);
+  rb_define_method(SwigClassFXList.klass, "appendItem", VALUEFUNC(_wrap_FXList_appendItem), -1);
+  rb_define_alias(SwigClassFXList.klass, "<<", "appendItem");
+  rb_define_method(SwigClassFXList.klass, "prependItem", VALUEFUNC(_wrap_FXList_prependItem), -1);
+  rb_define_method(SwigClassFXList.klass, "moveItem", VALUEFUNC(_wrap_FXList_moveItem), -1);
+  rb_define_method(SwigClassFXList.klass, "extractItem", VALUEFUNC(_wrap_FXList_extractItem), -1);
+  rb_define_method(SwigClassFXList.klass, "removeItem", VALUEFUNC(_wrap_FXList_removeItem), -1);
+  rb_define_method(SwigClassFXList.klass, "clearItems", VALUEFUNC(_wrap_FXList_clearItems), -1);
+  rb_define_method(SwigClassFXList.klass, "getItemWidth", VALUEFUNC(_wrap_FXList_getItemWidth), -1);
+  rb_define_method(SwigClassFXList.klass, "getItemHeight", VALUEFUNC(_wrap_FXList_getItemHeight), -1);
+  rb_define_method(SwigClassFXList.klass, "hitItem", VALUEFUNC(_wrap_FXList_hitItem), -1);
+  rb_define_method(SwigClassFXList.klass, "findItem", VALUEFUNC(_wrap_FXList_findItem), -1);
+  rb_define_method(SwigClassFXList.klass, "findItemByData", VALUEFUNC(_wrap_FXList_findItemByData), -1);
+  rb_define_method(SwigClassFXList.klass, "setItemText", VALUEFUNC(_wrap_FXList_setItemText), -1);
+  rb_define_method(SwigClassFXList.klass, "getItemText", VALUEFUNC(_wrap_FXList_getItemText), -1);
+  rb_define_method(SwigClassFXList.klass, "setItemIcon", VALUEFUNC(_wrap_FXList_setItemIcon), -1);
+  rb_define_method(SwigClassFXList.klass, "getItemIcon", VALUEFUNC(_wrap_FXList_getItemIcon), -1);
+  rb_define_method(SwigClassFXList.klass, "setItemData", VALUEFUNC(_wrap_FXList_setItemData), -1);
+  rb_define_method(SwigClassFXList.klass, "getItemData", VALUEFUNC(_wrap_FXList_getItemData), -1);
+  rb_define_method(SwigClassFXList.klass, "isItemSelected", VALUEFUNC(_wrap_FXList_isItemSelected), -1);
+  rb_define_method(SwigClassFXList.klass, "isItemCurrent", VALUEFUNC(_wrap_FXList_isItemCurrent), -1);
+  rb_define_method(SwigClassFXList.klass, "isItemVisible", VALUEFUNC(_wrap_FXList_isItemVisible), -1);
+  rb_define_method(SwigClassFXList.klass, "isItemEnabled", VALUEFUNC(_wrap_FXList_isItemEnabled), -1);
+  rb_define_method(SwigClassFXList.klass, "updateItem", VALUEFUNC(_wrap_FXList_updateItem), -1);
+  rb_define_method(SwigClassFXList.klass, "getCurrentItem", VALUEFUNC(_wrap_FXList_getCurrentItem), -1);
+  rb_define_method(SwigClassFXList.klass, "setAnchorItem", VALUEFUNC(_wrap_FXList_setAnchorItem), -1);
+  rb_define_method(SwigClassFXList.klass, "getAnchorItem", VALUEFUNC(_wrap_FXList_getAnchorItem), -1);
+  rb_define_method(SwigClassFXList.klass, "getCursorItem", VALUEFUNC(_wrap_FXList_getCursorItem), -1);
+  rb_define_method(SwigClassFXList.klass, "sortItems", VALUEFUNC(_wrap_FXList_sortItems), -1);
+  rb_define_method(SwigClassFXList.klass, "setFont", VALUEFUNC(_wrap_FXList_setFont), -1);
+  rb_define_method(SwigClassFXList.klass, "getFont", VALUEFUNC(_wrap_FXList_getFont), -1);
+  rb_define_method(SwigClassFXList.klass, "getTextColor", VALUEFUNC(_wrap_FXList_getTextColor), -1);
+  rb_define_method(SwigClassFXList.klass, "setTextColor", VALUEFUNC(_wrap_FXList_setTextColor), -1);
+  rb_define_method(SwigClassFXList.klass, "getSelBackColor", VALUEFUNC(_wrap_FXList_getSelBackColor), -1);
+  rb_define_method(SwigClassFXList.klass, "setSelBackColor", VALUEFUNC(_wrap_FXList_setSelBackColor), -1);
+  rb_define_method(SwigClassFXList.klass, "getSelTextColor", VALUEFUNC(_wrap_FXList_getSelTextColor), -1);
+  rb_define_method(SwigClassFXList.klass, "setSelTextColor", VALUEFUNC(_wrap_FXList_setSelTextColor), -1);
+  rb_define_method(SwigClassFXList.klass, "getListStyle", VALUEFUNC(_wrap_FXList_getListStyle), -1);
+  rb_define_method(SwigClassFXList.klass, "setListStyle", VALUEFUNC(_wrap_FXList_setListStyle), -1);
+  rb_define_method(SwigClassFXList.klass, "setHelpText", VALUEFUNC(_wrap_FXList_setHelpText), -1);
+  rb_define_method(SwigClassFXList.klass, "getHelpText", VALUEFUNC(_wrap_FXList_getHelpText), -1);
+  rb_define_method(SwigClassFXList.klass, "save", VALUEFUNC(_wrap_FXList_save), -1);
+  rb_define_method(SwigClassFXList.klass, "load", VALUEFUNC(_wrap_FXList_load), -1);
+  rb_define_method(SwigClassFXList.klass, "create", VALUEFUNC(_wrap_FXList_create), -1);
+  rb_define_method(SwigClassFXList.klass, "detach", VALUEFUNC(_wrap_FXList_detach), -1);
+  rb_define_method(SwigClassFXList.klass, "destroy", VALUEFUNC(_wrap_FXList_destroy), -1);
+  rb_define_method(SwigClassFXList.klass, "resize", VALUEFUNC(_wrap_FXList_resize), -1);
+  rb_define_method(SwigClassFXList.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXList_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXList.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXList_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXList.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXList_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXList.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXList_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXList.klass, "canFocus", VALUEFUNC(_wrap_FXList_canFocus), -1);
+  rb_define_method(SwigClassFXList.klass, "setFocus", VALUEFUNC(_wrap_FXList_setFocus), -1);
+  rb_define_method(SwigClassFXList.klass, "killFocus", VALUEFUNC(_wrap_FXList_killFocus), -1);
+  rb_define_method(SwigClassFXList.klass, "changeFocus", VALUEFUNC(_wrap_FXList_changeFocus), -1);
+  rb_define_method(SwigClassFXList.klass, "setDefault", VALUEFUNC(_wrap_FXList_setDefault), -1);
+  rb_define_method(SwigClassFXList.klass, "enable", VALUEFUNC(_wrap_FXList_enable), -1);
+  rb_define_method(SwigClassFXList.klass, "disable", VALUEFUNC(_wrap_FXList_disable), -1);
+  rb_define_method(SwigClassFXList.klass, "raiseWindow", VALUEFUNC(_wrap_FXList_raiseWindow), -1);
+  rb_define_method(SwigClassFXList.klass, "lower", VALUEFUNC(_wrap_FXList_lower), -1);
+  rb_define_method(SwigClassFXList.klass, "move", VALUEFUNC(_wrap_FXList_move), -1);
+  rb_define_method(SwigClassFXList.klass, "layout", VALUEFUNC(_wrap_FXList_layout), -1);
+  rb_define_method(SwigClassFXList.klass, "recalc", VALUEFUNC(_wrap_FXList_recalc), -1);
+  rb_define_method(SwigClassFXList.klass, "reparent", VALUEFUNC(_wrap_FXList_reparent), -1);
+  rb_define_method(SwigClassFXList.klass, "show", VALUEFUNC(_wrap_FXList_show), -1);
+  rb_define_method(SwigClassFXList.klass, "hide", VALUEFUNC(_wrap_FXList_hide), -1);
+  rb_define_method(SwigClassFXList.klass, "isComposite", VALUEFUNC(_wrap_FXList_isComposite), -1);
+  rb_define_method(SwigClassFXList.klass, "contains", VALUEFUNC(_wrap_FXList_contains), -1);
+  rb_define_method(SwigClassFXList.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXList_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXList.klass, "setBackColor", VALUEFUNC(_wrap_FXList_setBackColor), -1);
+  rb_define_method(SwigClassFXList.klass, "tr", VALUEFUNC(_wrap_FXList_tr), -1);
+  rb_define_method(SwigClassFXList.klass, "dropEnable", VALUEFUNC(_wrap_FXList_dropEnable), -1);
+  rb_define_method(SwigClassFXList.klass, "dropDisable", VALUEFUNC(_wrap_FXList_dropDisable), -1);
+  rb_define_method(SwigClassFXList.klass, "setShape", VALUEFUNC(_wrap_FXList_setShape), -1);
+  rb_define_method(SwigClassFXList.klass, "clearShape", VALUEFUNC(_wrap_FXList_clearShape), -1);
+  rb_define_method(SwigClassFXList.klass, "getViewportHeight", VALUEFUNC(_wrap_FXList_getViewportHeight), -1);
+  rb_define_method(SwigClassFXList.klass, "getViewportWidth", VALUEFUNC(_wrap_FXList_getViewportWidth), -1);
+  rb_define_method(SwigClassFXList.klass, "getContentHeight", VALUEFUNC(_wrap_FXList_getContentHeight), -1);
+  rb_define_method(SwigClassFXList.klass, "getContentWidth", VALUEFUNC(_wrap_FXList_getContentWidth), -1);
+  rb_define_method(SwigClassFXList.klass, "position", VALUEFUNC(_wrap_FXList_position), -1);
+  rb_define_method(SwigClassFXList.klass, "enableItem", VALUEFUNC(_wrap_FXList_enableItem), -1);
+  rb_define_method(SwigClassFXList.klass, "disableItem", VALUEFUNC(_wrap_FXList_disableItem), -1);
+  rb_define_method(SwigClassFXList.klass, "makeItemVisible", VALUEFUNC(_wrap_FXList_makeItemVisible), -1);
+  rb_define_method(SwigClassFXList.klass, "getItemAt", VALUEFUNC(_wrap_FXList_getItemAt), -1);
+  rb_define_method(SwigClassFXList.klass, "selectItem", VALUEFUNC(_wrap_FXList_selectItem), -1);
+  rb_define_method(SwigClassFXList.klass, "deselectItem", VALUEFUNC(_wrap_FXList_deselectItem), -1);
+  rb_define_method(SwigClassFXList.klass, "toggleItem", VALUEFUNC(_wrap_FXList_toggleItem), -1);
+  rb_define_method(SwigClassFXList.klass, "extendSelection", VALUEFUNC(_wrap_FXList_extendSelection), -1);
+  rb_define_method(SwigClassFXList.klass, "killSelection", VALUEFUNC(_wrap_FXList_killSelection), -1);
+  rb_define_method(SwigClassFXList.klass, "setCurrentItem", VALUEFUNC(_wrap_FXList_setCurrentItem), -1);
+  SwigClassFXList.mark = (void (*)(void *)) FXRbList::markfunc;
+  SwigClassFXList.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXList.trackObjects = 0;
+  
+  SWIGTYPE_p_FXListItem->dcast = (swig_dycast_func) FXListItem_dynamic_cast;
+  
+  
+  SwigClassFXColorItem.klass = rb_define_class_under(mFox, "FXColorItem", ((swig_class *) SWIGTYPE_p_FXListItem->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXColorItem, (void *) &SwigClassFXColorItem);
+  rb_define_alloc_func(SwigClassFXColorItem.klass, _wrap_FXColorItem_allocate);
+  rb_define_method(SwigClassFXColorItem.klass, "initialize", VALUEFUNC(_wrap_new_FXColorItem), -1);
+  rb_define_method(SwigClassFXColorItem.klass, "color=", VALUEFUNC(_wrap_FXColorItem_colore___), -1);
+  rb_define_method(SwigClassFXColorItem.klass, "color", VALUEFUNC(_wrap_FXColorItem_color), -1);
+  rb_define_method(SwigClassFXColorItem.klass, "save", VALUEFUNC(_wrap_FXColorItem_save), -1);
+  rb_define_method(SwigClassFXColorItem.klass, "load", VALUEFUNC(_wrap_FXColorItem_load), -1);
+  rb_define_method(SwigClassFXColorItem.klass, "setText", VALUEFUNC(_wrap_FXColorItem_setText), -1);
+  rb_define_method(SwigClassFXColorItem.klass, "setIcon", VALUEFUNC(_wrap_FXColorItem_setIcon), -1);
+  rb_define_method(SwigClassFXColorItem.klass, "setFocus", VALUEFUNC(_wrap_FXColorItem_setFocus), -1);
+  rb_define_method(SwigClassFXColorItem.klass, "setSelected", VALUEFUNC(_wrap_FXColorItem_setSelected), -1);
+  rb_define_method(SwigClassFXColorItem.klass, "setEnabled", VALUEFUNC(_wrap_FXColorItem_setEnabled), -1);
+  rb_define_method(SwigClassFXColorItem.klass, "setDraggable", VALUEFUNC(_wrap_FXColorItem_setDraggable), -1);
+  rb_define_method(SwigClassFXColorItem.klass, "getWidth", VALUEFUNC(_wrap_FXColorItem_getWidth), -1);
+  rb_define_method(SwigClassFXColorItem.klass, "getHeight", VALUEFUNC(_wrap_FXColorItem_getHeight), -1);
+  rb_define_method(SwigClassFXColorItem.klass, "create", VALUEFUNC(_wrap_FXColorItem_create), -1);
+  rb_define_method(SwigClassFXColorItem.klass, "detach", VALUEFUNC(_wrap_FXColorItem_detach), -1);
+  rb_define_method(SwigClassFXColorItem.klass, "destroy", VALUEFUNC(_wrap_FXColorItem_destroy), -1);
+  SwigClassFXColorItem.mark = 0;
+  SwigClassFXColorItem.destroy = (void (*)(void *)) FXRbColorItem::freefunc;
+  SwigClassFXColorItem.trackObjects = 0;
+  
+  SwigClassFXColorList.klass = rb_define_class_under(mFox, "FXColorList", ((swig_class *) SWIGTYPE_p_FXList->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXColorList, (void *) &SwigClassFXColorList);
+  rb_define_alloc_func(SwigClassFXColorList.klass, _wrap_FXColorList_allocate);
+  rb_define_method(SwigClassFXColorList.klass, "initialize", VALUEFUNC(_wrap_new_FXColorList), -1);
+  rb_define_method(SwigClassFXColorList.klass, "fillItems", VALUEFUNC(_wrap_FXColorList_fillItems), -1);
+  rb_define_method(SwigClassFXColorList.klass, "insertItem", VALUEFUNC(_wrap_FXColorList_insertItem), -1);
+  rb_define_method(SwigClassFXColorList.klass, "appendItem", VALUEFUNC(_wrap_FXColorList_appendItem), -1);
+  rb_define_alias(SwigClassFXColorList.klass, "<<", "appendItem");
+  rb_define_method(SwigClassFXColorList.klass, "prependItem", VALUEFUNC(_wrap_FXColorList_prependItem), -1);
+  rb_define_method(SwigClassFXColorList.klass, "setItemColor", VALUEFUNC(_wrap_FXColorList_setItemColor), -1);
+  rb_define_method(SwigClassFXColorList.klass, "getItemColor", VALUEFUNC(_wrap_FXColorList_getItemColor), -1);
+  rb_define_method(SwigClassFXColorList.klass, "save", VALUEFUNC(_wrap_FXColorList_save), -1);
+  rb_define_method(SwigClassFXColorList.klass, "load", VALUEFUNC(_wrap_FXColorList_load), -1);
+  rb_define_method(SwigClassFXColorList.klass, "create", VALUEFUNC(_wrap_FXColorList_create), -1);
+  rb_define_method(SwigClassFXColorList.klass, "detach", VALUEFUNC(_wrap_FXColorList_detach), -1);
+  rb_define_method(SwigClassFXColorList.klass, "destroy", VALUEFUNC(_wrap_FXColorList_destroy), -1);
+  rb_define_method(SwigClassFXColorList.klass, "resize", VALUEFUNC(_wrap_FXColorList_resize), -1);
+  rb_define_method(SwigClassFXColorList.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXColorList_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXColorList.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXColorList_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXColorList.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXColorList_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXColorList.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXColorList_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXColorList.klass, "canFocus", VALUEFUNC(_wrap_FXColorList_canFocus), -1);
+  rb_define_method(SwigClassFXColorList.klass, "setFocus", VALUEFUNC(_wrap_FXColorList_setFocus), -1);
+  rb_define_method(SwigClassFXColorList.klass, "killFocus", VALUEFUNC(_wrap_FXColorList_killFocus), -1);
+  rb_define_method(SwigClassFXColorList.klass, "changeFocus", VALUEFUNC(_wrap_FXColorList_changeFocus), -1);
+  rb_define_method(SwigClassFXColorList.klass, "setDefault", VALUEFUNC(_wrap_FXColorList_setDefault), -1);
+  rb_define_method(SwigClassFXColorList.klass, "enable", VALUEFUNC(_wrap_FXColorList_enable), -1);
+  rb_define_method(SwigClassFXColorList.klass, "disable", VALUEFUNC(_wrap_FXColorList_disable), -1);
+  rb_define_method(SwigClassFXColorList.klass, "raiseWindow", VALUEFUNC(_wrap_FXColorList_raiseWindow), -1);
+  rb_define_method(SwigClassFXColorList.klass, "lower", VALUEFUNC(_wrap_FXColorList_lower), -1);
+  rb_define_method(SwigClassFXColorList.klass, "move", VALUEFUNC(_wrap_FXColorList_move), -1);
+  rb_define_method(SwigClassFXColorList.klass, "layout", VALUEFUNC(_wrap_FXColorList_layout), -1);
+  rb_define_method(SwigClassFXColorList.klass, "recalc", VALUEFUNC(_wrap_FXColorList_recalc), -1);
+  rb_define_method(SwigClassFXColorList.klass, "reparent", VALUEFUNC(_wrap_FXColorList_reparent), -1);
+  rb_define_method(SwigClassFXColorList.klass, "show", VALUEFUNC(_wrap_FXColorList_show), -1);
+  rb_define_method(SwigClassFXColorList.klass, "hide", VALUEFUNC(_wrap_FXColorList_hide), -1);
+  rb_define_method(SwigClassFXColorList.klass, "isComposite", VALUEFUNC(_wrap_FXColorList_isComposite), -1);
+  rb_define_method(SwigClassFXColorList.klass, "contains", VALUEFUNC(_wrap_FXColorList_contains), -1);
+  rb_define_method(SwigClassFXColorList.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXColorList_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXColorList.klass, "setBackColor", VALUEFUNC(_wrap_FXColorList_setBackColor), -1);
+  rb_define_method(SwigClassFXColorList.klass, "tr", VALUEFUNC(_wrap_FXColorList_tr), -1);
+  rb_define_method(SwigClassFXColorList.klass, "dropEnable", VALUEFUNC(_wrap_FXColorList_dropEnable), -1);
+  rb_define_method(SwigClassFXColorList.klass, "dropDisable", VALUEFUNC(_wrap_FXColorList_dropDisable), -1);
+  rb_define_method(SwigClassFXColorList.klass, "setShape", VALUEFUNC(_wrap_FXColorList_setShape), -1);
+  rb_define_method(SwigClassFXColorList.klass, "clearShape", VALUEFUNC(_wrap_FXColorList_clearShape), -1);
+  rb_define_method(SwigClassFXColorList.klass, "getViewportHeight", VALUEFUNC(_wrap_FXColorList_getViewportHeight), -1);
+  rb_define_method(SwigClassFXColorList.klass, "getViewportWidth", VALUEFUNC(_wrap_FXColorList_getViewportWidth), -1);
+  rb_define_method(SwigClassFXColorList.klass, "getContentHeight", VALUEFUNC(_wrap_FXColorList_getContentHeight), -1);
+  rb_define_method(SwigClassFXColorList.klass, "getContentWidth", VALUEFUNC(_wrap_FXColorList_getContentWidth), -1);
+  rb_define_method(SwigClassFXColorList.klass, "position", VALUEFUNC(_wrap_FXColorList_position), -1);
+  rb_define_method(SwigClassFXColorList.klass, "enableItem", VALUEFUNC(_wrap_FXColorList_enableItem), -1);
+  rb_define_method(SwigClassFXColorList.klass, "disableItem", VALUEFUNC(_wrap_FXColorList_disableItem), -1);
+  rb_define_method(SwigClassFXColorList.klass, "makeItemVisible", VALUEFUNC(_wrap_FXColorList_makeItemVisible), -1);
+  rb_define_method(SwigClassFXColorList.klass, "getItemAt", VALUEFUNC(_wrap_FXColorList_getItemAt), -1);
+  rb_define_method(SwigClassFXColorList.klass, "selectItem", VALUEFUNC(_wrap_FXColorList_selectItem), -1);
+  rb_define_method(SwigClassFXColorList.klass, "deselectItem", VALUEFUNC(_wrap_FXColorList_deselectItem), -1);
+  rb_define_method(SwigClassFXColorList.klass, "toggleItem", VALUEFUNC(_wrap_FXColorList_toggleItem), -1);
+  rb_define_method(SwigClassFXColorList.klass, "extendSelection", VALUEFUNC(_wrap_FXColorList_extendSelection), -1);
+  rb_define_method(SwigClassFXColorList.klass, "killSelection", VALUEFUNC(_wrap_FXColorList_killSelection), -1);
+  rb_define_method(SwigClassFXColorList.klass, "setCurrentItem", VALUEFUNC(_wrap_FXColorList_setCurrentItem), -1);
+  SwigClassFXColorList.mark = 0;
+  SwigClassFXColorList.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXColorList.trackObjects = 0;
+}
+
diff --git a/ext/fox16_c/make_impl.rb b/ext/fox16_c/make_impl.rb
index fabb1130..3cf4377c 100755
--- a/ext/fox16_c/make_impl.rb
+++ b/ext/fox16_c/make_impl.rb
@@ -1,6 +1,6 @@
 #!/bin/env ruby
 
-$special_stubclasses = ["FXGLSHAPE", "FXICONITEM", "FXTABLE", "FXTABLEITEM", "FXTREEITEM"]
+$special_stubclasses = ["FXGLSHAPE", "FXICONITEM", "FXTABLE", "FXTABLEITEM", "FXTEXT", "FXTREEITEM"]
 
 class Processor
   def initialize
diff --git a/ext/fox16_c/markfuncs.cpp b/ext/fox16_c/markfuncs.cpp
index e001bbb3..6a4ec2df 100644
--- a/ext/fox16_c/markfuncs.cpp
+++ b/ext/fox16_c/markfuncs.cpp
@@ -531,7 +531,6 @@ void FXRbTableItem::freefunc(FXTableItem* self){
 
 
 void FXRbTable::markfunc(FXTable* self){
-  register FXTableItem* item;
   FXRbScrollArea::markfunc(self);
   if(self){
     FXRbGcMark(self->FXTable::getFont());
@@ -539,7 +538,7 @@ void FXRbTable::markfunc(FXTable* self){
     FXRbGcMark(self->FXTable::getColumnHeaderFont());
     for(FXint row=0;row<self->FXTable::getNumRows();row++){
       for(FXint col=0;col<self->FXTable::getNumColumns();col++){
-        item=self->FXTable::getItem(row,col);
+        FXTableItem* item=self->FXTable::getItem(row,col);
         FXRbGcMark(item);
         }
       }
diff --git a/ext/fox16_c/mdi_wrap.cpp b/ext/fox16_c/mdi_wrap.cpp
new file mode 100644
index 00000000..1bb28311
--- /dev/null
+++ b/ext/fox16_c/mdi_wrap.cpp
@@ -0,0 +1,17278 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 3.0.12
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+
+#ifndef SWIGRUBY
+#define SWIGRUBY
+#endif
+
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
+};
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic C API SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "4"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/*  Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN           0x1
+
+
+/*
+   Flags/methods for returning states.
+
+   The SWIG conversion methods, as ConvertPtr, return an integer
+   that tells if the conversion was successful or not. And if not,
+   an error code can be returned (see swigerrors.swg for the codes).
+
+   Use the following macros/flags to set or process the returning
+   states.
+
+   In old versions of SWIG, code such as the following was usually written:
+
+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+       // success code
+     } else {
+       //fail code
+     }
+
+   Now you can be more explicit:
+
+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+    } else {
+      // fail code
+    }
+
+   which is the same really, but now you can also do
+
+    Type *ptr;
+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+      if (SWIG_IsNewObj(res) {
+        ...
+	delete *ptr;
+      } else {
+        ...
+      }
+    } else {
+      // fail code
+    }
+
+   I.e., now SWIG_ConvertPtr can return new objects and you can
+   identify the case and take care of the deallocation. Of course that
+   also requires SWIG_ConvertPtr to return new result values, such as
+
+      int SWIG_ConvertPtr(obj, ptr,...) {
+        if (<obj is ok>) {
+          if (<need new object>) {
+            *ptr = <ptr to new allocated object>;
+            return SWIG_NEWOBJ;
+          } else {
+            *ptr = <ptr to old object>;
+            return SWIG_OLDOBJ;
+          }
+        } else {
+          return SWIG_BADOBJ;
+        }
+      }
+
+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+   SWIG errors code.
+
+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+   allows to return the 'cast rank', for example, if you have this
+
+       int food(double)
+       int fooi(int);
+
+   and you call
+
+      food(1)   // cast rank '1'  (1 -> 1.0)
+      fooi(1)   // cast rank '0'
+
+   just use the SWIG_AddCast()/SWIG_CheckState()
+*/
+
+#define SWIG_OK                    (0)
+#define SWIG_ERROR                 (-1)
+#define SWIG_IsOK(r)               (r >= 0)
+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT         (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ                (SWIG_ERROR)
+#define SWIG_OLDOBJ                (SWIG_OK)
+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+#  ifndef SWIG_TypeRank
+#    define SWIG_TypeRank             unsigned long
+#  endif
+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
+#    define SWIG_MAXCASTRANK          (2)
+#  endif
+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+#  define SWIG_AddCast(r) (r)
+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *, int *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store information on one type */
+typedef struct swig_type_info {
+  const char             *name;			/* mangled name of this type */
+  const char             *str;			/* human readable name of this type */
+  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
+  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
+  void                   *clientdata;		/* language specific type data */
+  int                    owndata;		/* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
+  swig_converter_func     converter;		/* function to cast the void pointers */
+  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
+  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
+  size_t                 size;		        /* Number of types in this module */
+  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
+  swig_type_info         **type_initial;	/* Array of initially generated type structures */
+  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
+  void                    *clientdata;		/* Language specific module data */
+} swig_module_info;
+
+/*
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+  }
+  return (int)((l1 - f1) - (l2 - f2));
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCmp(const char *nb, const char *tb) {
+  int equiv = 1;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (equiv != 0 && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
+}
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
+}
+
+/*
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+  swig_type_info *lastty = ty;
+  if (!ty || !ty->dcast) return ty;
+  while (ty && (ty->dcast)) {
+    ty = (*ty->dcast)(ptr);
+    if (ty) lastty = ty;
+  }
+  return lastty;
+}
+
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+  return ty->name;
+}
+
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (!type) return NULL;
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
+  }
+  else
+    return type->name;
+}
+
+/*
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+  swig_cast_info *cast = ti->cast;
+  /* if (ti->clientdata == clientdata) return; */
+  ti->clientdata = clientdata;
+
+  while (cast) {
+    if (!cast->converter) {
+      swig_type_info *tc = cast->type;
+      if (!tc->clientdata) {
+	SWIG_TypeClientData(tc, clientdata);
+      }
+    }
+    cast = cast->next;
+  }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientData(ti, clientdata);
+  ti->owndata = 1;
+}
+
+/*
+  Search for a swig_type_info structure only by mangled name
+  Search is a O(log #types)
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+                            swig_module_info *end,
+		            const char *name) {
+  swig_module_info *iter = start;
+  do {
+    if (iter->size) {
+      size_t l = 0;
+      size_t r = iter->size - 1;
+      do {
+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
+	size_t i = (l + r) >> 1;
+	const char *iname = iter->types[i]->name;
+	if (iname) {
+	  int compare = strcmp(name, iname);
+	  if (compare == 0) {
+	    return iter->types[i];
+	  } else if (compare < 0) {
+	    if (i) {
+	      r = i - 1;
+	    } else {
+	      break;
+	    }
+	  } else if (compare > 0) {
+	    l = i + 1;
+	  }
+	} else {
+	  break; /* should never happen */
+	}
+      } while (l <= r);
+    }
+    iter = iter->next;
+  } while (iter != end);
+  return 0;
+}
+
+/*
+  Search for a swig_type_info structure for either a mangled name or a human readable name.
+  It first searches the mangled names of the types, which is a O(log #types)
+  If a type is not found it then searches the human readable names, which is O(#types).
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+                     swig_module_info *end,
+		     const char *name) {
+  /* STEP 1: Search the name field using binary search */
+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+  if (ret) {
+    return ret;
+  } else {
+    /* STEP 2: If the type hasn't been found, do a complete search
+       of the str field (the human readable name) */
+    swig_module_info *iter = start;
+    do {
+      size_t i = 0;
+      for (; i < iter->size; ++i) {
+	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+	  return iter->types[i];
+      }
+      iter = iter->next;
+    } while (iter != end);
+  }
+
+  /* neither found a match */
+  return 0;
+}
+
+/*
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+
+/*
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = (unsigned char)((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = (unsigned char)((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (unsigned char)(d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (unsigned char)(d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/*
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/*  Errors in SWIG */
+#define  SWIG_UnknownError    	   -1
+#define  SWIG_IOError        	   -2
+#define  SWIG_RuntimeError   	   -3
+#define  SWIG_IndexError     	   -4
+#define  SWIG_TypeError      	   -5
+#define  SWIG_DivisionByZero 	   -6
+#define  SWIG_OverflowError  	   -7
+#define  SWIG_SyntaxError    	   -8
+#define  SWIG_ValueError     	   -9
+#define  SWIG_SystemError    	   -10
+#define  SWIG_AttributeError 	   -11
+#define  SWIG_MemoryError    	   -12
+#define  SWIG_NullReferenceError   -13
+
+
+
+      #include <ruby.h>
+
+      #if defined(RB_METHOD_DEFINITION_DECL)
+      # define RUBY_VALUE_METHOD_FUNC(func) (func)
+      # define RUBY_INT_METHOD_FUNC(func) (func)
+      # define RUBY_VOID_METHOD_FUNC(func) (func)
+      # define RUBY_VOIDP_METHOD_FUNC(func) (func)
+      #else
+      # define RUBY_VALUE_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
+      # define RUBY_INT_METHOD_FUNC(func) ((int (*)(ANYARGS))(func))
+      # define RUBY_VOID_METHOD_FUNC(func) ((void (*)(ANYARGS))(func))
+      # define RUBY_VOIDP_METHOD_FUNC(func) ((void *(*)(ANYARGS))(func))
+      #endif
+
+
+/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
+ * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
+ * issue for now by disabling this.
+ * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
+ */
+#ifdef rb_intern
+# undef rb_intern
+#endif
+
+/* Remove global macros defined in Ruby's win32.h */
+#ifdef write
+# undef write
+#endif
+#ifdef read
+# undef read
+#endif
+#ifdef bind
+# undef bind
+#endif
+#ifdef close
+# undef close
+#endif
+#ifdef connect
+# undef connect
+#endif
+
+
+/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
+#ifndef NUM2LL
+#define NUM2LL(x) NUM2LONG((x))
+#endif
+#ifndef LL2NUM
+#define LL2NUM(x) INT2NUM((long) (x))
+#endif
+#ifndef ULL2NUM
+#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
+#endif
+
+/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
+#ifndef NUM2ULL
+#ifdef HAVE_LONG_LONG
+#define NUM2ULL(x) rb_num2ull((x))
+#else
+#define NUM2ULL(x) NUM2ULONG(x)
+#endif
+#endif
+
+/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
+/* Define these for older versions so we can just write code the new way */
+#ifndef RSTRING_LEN
+# define RSTRING_LEN(x) RSTRING(x)->len
+#endif
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(x) RSTRING(x)->ptr
+#endif
+#ifndef RSTRING_END
+# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
+#endif
+#ifndef RARRAY_LEN
+# define RARRAY_LEN(x) RARRAY(x)->len
+#endif
+#ifndef RARRAY_PTR
+# define RARRAY_PTR(x) RARRAY(x)->ptr
+#endif
+#ifndef RFLOAT_VALUE
+# define RFLOAT_VALUE(x) RFLOAT(x)->value
+#endif
+#ifndef DOUBLE2NUM
+# define DOUBLE2NUM(x) rb_float_new(x)
+#endif
+#ifndef RHASH_TBL
+# define RHASH_TBL(x) (RHASH(x)->tbl)
+#endif
+#ifndef RHASH_ITER_LEV
+# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
+#endif
+#ifndef RHASH_IFNONE
+# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
+#endif
+#ifndef RHASH_SIZE
+# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
+#endif
+#ifndef RHASH_EMPTY_P
+# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
+#endif
+#ifndef RSTRUCT_LEN
+# define RSTRUCT_LEN(x) RSTRUCT(x)->len
+#endif
+#ifndef RSTRUCT_PTR
+# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
+#endif
+
+
+
+/*
+ * Need to be very careful about how these macros are defined, especially
+ * when compiling C++ code or C code with an ANSI C compiler.
+ *
+ * VALUEFUNC(f) is a macro used to typecast a C function that implements
+ * a Ruby method so that it can be passed as an argument to API functions
+ * like rb_define_method() and rb_define_singleton_method().
+ *
+ * VOIDFUNC(f) is a macro used to typecast a C function that implements
+ * either the "mark" or "free" stuff for a Ruby Data object, so that it
+ * can be passed as an argument to API functions like Data_Wrap_Struct()
+ * and Data_Make_Struct().
+ */
+ 
+#ifdef __cplusplus
+#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
+#    define PROTECTFUNC(f) ((VALUE (*)()) f)
+#    define VALUEFUNC(f) ((VALUE (*)()) f)
+#    define VOIDFUNC(f)  ((void (*)()) f)
+#  else
+#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
+#      define PROTECTFUNC(f) ((VALUE (*)()) f)
+#      define VALUEFUNC(f) ((VALUE (*)()) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    else /* These definitions should work for Ruby 1.7+ */
+#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
+#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    endif
+#  endif
+#else
+#  define VALUEFUNC(f) (f)
+#  define VOIDFUNC(f) (f)
+#endif
+
+/* Don't use for expressions have side effect */
+#ifndef RB_STRING_VALUE
+#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
+#endif
+#ifndef StringValue
+#define StringValue(s) RB_STRING_VALUE(s)
+#endif
+#ifndef StringValuePtr
+#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
+#endif
+#ifndef StringValueLen
+#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
+#endif
+#ifndef SafeStringValue
+#define SafeStringValue(v) do {\
+    StringValue(v);\
+    rb_check_safe_str(v);\
+} while (0)
+#endif
+
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
+#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
+#endif
+
+static VALUE _mSWIG = Qnil;
+
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+
+/* Define some additional error types */
+#define SWIG_ObjectPreviouslyDeletedError  -100
+
+
+/* Define custom exceptions for errors that do not map to existing Ruby
+   exceptions.  Note this only works for C++ since a global cannot be
+   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/
+
+SWIGINTERN VALUE 
+getNullReferenceError(void) {
+  static int init = 0;
+  static VALUE rb_eNullReferenceError ;
+  if (!init) {
+    init = 1;
+    rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
+  }
+  return rb_eNullReferenceError;
+} 
+
+SWIGINTERN VALUE 
+getObjectPreviouslyDeletedError(void) {
+  static int init = 0;
+  static VALUE rb_eObjectPreviouslyDeleted ;
+  if (!init) {
+    init = 1;
+    rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
+  }
+  return rb_eObjectPreviouslyDeleted;
+} 
+
+
+SWIGINTERN VALUE
+SWIG_Ruby_ErrorType(int SWIG_code) {
+  VALUE type;
+  switch (SWIG_code) {
+  case SWIG_MemoryError:
+    type = rb_eNoMemError;
+    break;
+  case SWIG_IOError:
+    type = rb_eIOError;
+    break;
+  case SWIG_RuntimeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_IndexError:
+    type = rb_eIndexError;
+    break;
+  case SWIG_TypeError:
+    type = rb_eTypeError;
+    break;
+  case SWIG_DivisionByZero:
+    type = rb_eZeroDivError;
+    break;
+  case SWIG_OverflowError:
+    type = rb_eRangeError;
+    break;
+  case SWIG_SyntaxError:
+    type = rb_eSyntaxError;
+    break;
+  case SWIG_ValueError:
+    type = rb_eArgError;
+    break;
+  case SWIG_SystemError:
+    type = rb_eFatal;
+    break;
+  case SWIG_AttributeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_NullReferenceError:
+    type = getNullReferenceError();
+    break;
+  case SWIG_ObjectPreviouslyDeletedError:
+    type = getObjectPreviouslyDeletedError();
+    break;
+  case SWIG_UnknownError:
+    type = rb_eRuntimeError;
+    break;
+  default:
+    type = rb_eRuntimeError;
+  }
+  return type;
+}
+
+
+/* This function is called when a user inputs a wrong argument to
+   a method.
+ */
+SWIGINTERN 
+const char* Ruby_Format_TypeError( const char* msg,
+				   const char* type, 
+				   const char* name, 
+				   const int argn,
+				   VALUE input )
+{
+  char buf[128];
+  VALUE str;
+  VALUE asStr;
+  if ( msg && *msg )
+    {
+      str = rb_str_new2(msg);
+    }
+  else
+    {
+      str = rb_str_new(NULL, 0);
+    }
+
+  str = rb_str_cat2( str, "Expected argument " );
+  sprintf( buf, "%d of type ", argn-1 );
+  str = rb_str_cat2( str, buf );
+  str = rb_str_cat2( str, type );
+  str = rb_str_cat2( str, ", but got " );
+  str = rb_str_cat2( str, rb_obj_classname(input) );
+  str = rb_str_cat2( str, " " );
+  asStr = rb_inspect(input);
+  if ( RSTRING_LEN(asStr) > 30 )
+    {
+      str = rb_str_cat( str, StringValuePtr(asStr), 30 );
+      str = rb_str_cat2( str, "..." );
+    }
+  else
+    {
+      str = rb_str_append( str, asStr );
+    }
+
+  if ( name )
+    {
+      str = rb_str_cat2( str, "\n\tin SWIG method '" );
+      str = rb_str_cat2( str, name );
+      str = rb_str_cat2( str, "'" );
+    }
+
+  return StringValuePtr( str );
+}
+
+/* This function is called when an overloaded method fails */
+SWIGINTERN 
+void Ruby_Format_OverloadedError(
+				 const int argc,
+				 const int maxargs,
+				 const char* method, 
+				 const char* prototypes 
+				 )
+{
+  const char* msg = "Wrong # of arguments";
+  if ( argc <= maxargs ) msg = "Wrong arguments";
+  rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
+	   "Possible C/C++ prototypes are:\n%s",
+	   msg, method, prototypes);
+}
+
+/* -----------------------------------------------------------------------------
+ * rubytracking.swg
+ *
+ * This file contains support for tracking mappings from 
+ * Ruby objects to C++ objects.  This functionality is needed
+ * to implement mark functions for Ruby's mark and sweep
+ * garbage collector.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(ST_DATA_T_DEFINED)
+/* Needs to be explicitly included for Ruby 1.8 and earlier */
+#include <st.h>
+#endif
+
+/* Ruby 1.8 actually assumes the first case. */
+#if SIZEOF_VOIDP == SIZEOF_LONG
+#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
+#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
+#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
+#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
+#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
+#else
+#  error sizeof(void*) is not the same as long or long long
+#endif
+
+/* Global hash table to store Trackings from C/C++
+   structs to Ruby Objects. 
+*/
+static st_table* swig_ruby_trackings = NULL;
+
+static VALUE swig_ruby_trackings_count(ID id, VALUE *var) {
+  return SWIG2NUM(swig_ruby_trackings->num_entries);
+}
+
+
+/* Setup a hash table to store Trackings */
+SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
+  /* Create a hash table to store Trackings from C++
+     objects to Ruby objects. */
+
+  /* Try to see if some other .so has already created a 
+     tracking hash table, which we keep hidden in an instance var
+     in the SWIG module.
+     This is done to allow multiple DSOs to share the same
+     tracking table.
+  */
+  VALUE trackings_value = Qnil;
+  /* change the variable name so that we can mix modules
+     compiled with older SWIG's - this used to be called "@__trackings__" */
+  ID trackings_id = rb_intern( "@__safetrackings__" );
+  VALUE verbose = rb_gv_get("VERBOSE");
+  rb_gv_set("VERBOSE", Qfalse);
+  trackings_value = rb_ivar_get( _mSWIG, trackings_id );
+  rb_gv_set("VERBOSE", verbose);
+
+  /* The trick here is that we have to store the hash table
+  pointer in a Ruby variable. We do not want Ruby's GC to
+  treat this pointer as a Ruby object, so we convert it to
+  a Ruby numeric value. */
+  if (trackings_value == Qnil) {
+    /* No, it hasn't.  Create one ourselves */
+    swig_ruby_trackings = st_init_numtable();
+    rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
+  } else {
+    swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
+  }
+
+        rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", RUBY_VALUE_METHOD_FUNC(swig_ruby_trackings_count), RUBY_VOID_METHOD_FUNC((rb_gvar_setter_t*)NULL))
+;
+}
+
+/* Add a Tracking from a C/C++ struct to a Ruby object */
+SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
+  /* Store the mapping to the global hash table. */
+  st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
+}
+
+/* Get the Ruby object that owns the specified C/C++ struct */
+SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
+  /* Now lookup the value stored in the global hash table */
+  VALUE value;
+
+  if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
+    return value;
+  } else {
+    return Qnil;
+  }
+}
+
+/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
+   is very important to remove objects once they are destroyed
+   since the same memory address may be reused later to create
+   a new object. */
+SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
+  /* Delete the object from the hash table */
+  st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
+}
+
+/* This is a helper method that unlinks a Ruby object from its
+   underlying C++ object.  This is needed if the lifetime of the
+   Ruby object is longer than the C++ object */
+SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
+  VALUE object = SWIG_RubyInstanceFor(ptr);
+
+  if (object != Qnil) {
+    if (TYPE(object) != T_DATA)
+      abort();
+    DATA_PTR(object) = 0;
+  }
+}
+
+/* This is a helper method that iterates over all the trackings
+   passing the C++ object pointer and its related Ruby object
+   to the passed callback function. */
+
+/* Proxy method to abstract the internal trackings datatype */
+      static int swig_ruby_internal_iterate_callback(st_data_t ptr, st_data_t obj, st_data_t meth) {
+        ((void(*)(void*, VALUE))meth)((void*)ptr, (VALUE)obj);
+
+  return ST_CONTINUE;
+}
+
+SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
+  st_foreach(swig_ruby_trackings, RUBY_INT_METHOD_FUNC(swig_ruby_internal_iterate_callback), (st_data_t)meth);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Ruby API portion that goes into the runtime
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGINTERN VALUE
+SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
+  if (NIL_P(target)) {
+    target = o;
+  } else {
+    if (TYPE(target) != T_ARRAY) {
+      VALUE o2 = target;
+      target = rb_ary_new();
+      rb_ary_push(target, o2);
+    }
+    rb_ary_push(target, o);
+  }
+  return target;
+}
+
+/* For ruby1.8.4 and earlier. */
+#ifndef RUBY_INIT_STACK
+   RUBY_EXTERN void Init_stack(VALUE* addr);
+#  define RUBY_INIT_STACK \
+   VALUE variable_in_this_stack_frame; \
+   Init_stack(&variable_in_this_stack_frame);
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* -----------------------------------------------------------------------------
+ * rubyrun.swg
+ *
+ * This file contains the runtime support for Ruby modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
+#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
+#define swig_owntype                                    swig_ruby_owntype
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) 		SWIG_Ruby_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
+#define SWIG_Error(code, msg)            		rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
+#define SWIG_fail                        		goto fail				 
+
+
+/* Ruby-specific SWIG API */
+
+#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
+#define SWIG_define_class(ty)                        	SWIG_Ruby_define_class(ty)
+#define SWIG_NewClassInstance(value, ty)             	SWIG_Ruby_NewClassInstance(value, ty)
+#define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
+#define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  
+
+#include "assert.h"
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  VALUE klass;
+  VALUE mImpl;
+  void  (*mark)(void *);
+  void  (*destroy)(void *);
+  int trackObjects;
+} swig_class;
+
+
+/* Global pointer used to keep some internal SWIG stuff */
+static VALUE _cSWIG_Pointer = Qnil;
+static VALUE swig_runtime_data_type_pointer = Qnil;
+
+/* Global IDs used to keep some internal SWIG stuff */
+static ID swig_arity_id = 0;
+static ID swig_call_id  = 0;
+
+/*
+  If your swig extension is to be run within an embedded ruby and has
+  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
+  This will reset ruby's stack frame on each entry point from the main 
+  program the first time a virtual director function is invoked (in a 
+  non-recursive way).
+  If this is not done, you run the risk of Ruby trashing the stack.
+*/
+
+#ifdef RUBY_EMBEDDED
+
+#  define SWIG_INIT_STACK                            \
+      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
+      ++swig_virtual_calls;
+#  define SWIG_RELEASE_STACK --swig_virtual_calls;
+#  define Ruby_DirectorTypeMismatchException(x) \
+          rb_raise( rb_eTypeError, "%s", x ); return c_result;
+
+      static unsigned int swig_virtual_calls = 0;
+
+#else  /* normal non-embedded extension */
+
+#  define SWIG_INIT_STACK
+#  define SWIG_RELEASE_STACK
+#  define Ruby_DirectorTypeMismatchException(x) \
+          throw Swig::DirectorTypeMismatchException( x );
+
+#endif  /* RUBY_EMBEDDED */
+
+
+SWIGRUNTIME VALUE 
+getExceptionClass(void) {
+  static int init = 0;
+  static VALUE rubyExceptionClass ;
+  if (!init) {
+    init = 1;
+    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
+  }
+  return rubyExceptionClass;
+} 
+
+/* This code checks to see if the Ruby object being raised as part
+   of an exception inherits from the Ruby class Exception.  If so,
+   the object is simply returned.  If not, then a new Ruby exception
+   object is created and that will be returned to Ruby.*/
+SWIGRUNTIME VALUE
+SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
+  VALUE exceptionClass = getExceptionClass();
+  if (rb_obj_is_kind_of(obj, exceptionClass)) {
+    return obj;
+  }  else {
+    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
+  }
+}
+
+/* Initialize Ruby runtime support */
+SWIGRUNTIME void
+SWIG_Ruby_InitRuntime(void)
+{
+  if (_mSWIG == Qnil) {
+    _mSWIG = rb_define_module("SWIG");
+    swig_call_id  = rb_intern("call");
+    swig_arity_id = rb_intern("arity");
+  }
+}
+
+/* Define Ruby class for C type */
+SWIGRUNTIME void
+SWIG_Ruby_define_class(swig_type_info *type)
+{
+  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+  sprintf(klass_name, "TYPE%s", type->name);
+  if (NIL_P(_cSWIG_Pointer)) {
+    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
+    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
+  }
+  rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
+  free((void *) klass_name);
+}
+
+/* Create a new pointer object */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
+{
+  int own =  flags & SWIG_POINTER_OWN; 
+  int track;
+  char *klass_name;
+  swig_class *sklass;
+  VALUE klass;
+  VALUE obj;
+  
+  if (!ptr)
+    return Qnil;
+  
+  if (type->clientdata) {
+    sklass = (swig_class *) type->clientdata;
+		
+    /* Are we tracking this class and have we already returned this Ruby object? */
+    track = sklass->trackObjects;
+    if (track) {
+      obj = SWIG_RubyInstanceFor(ptr);
+      
+      /* Check the object's type and make sure it has the correct type.
+        It might not in cases where methods do things like 
+        downcast methods. */
+      if (obj != Qnil) {
+        VALUE value = rb_iv_get(obj, "@__swigtype__");
+        const char* type_name = RSTRING_PTR(value);
+				
+        if (strcmp(type->name, type_name) == 0) {
+          return obj;
+        }
+      }
+    }
+
+    /* Create a new Ruby object */
+    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
+			   ( own ? VOIDFUNC(sklass->destroy) : 
+			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
+			     ), ptr);
+
+    /* If tracking is on for this class then track this object. */
+    if (track) {
+      SWIG_RubyAddTracking(ptr, obj);
+    }
+  } else {
+    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+    sprintf(klass_name, "TYPE%s", type->name);
+    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
+    free((void *) klass_name);
+    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
+  }
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  
+  return obj;
+}
+
+/* Create a new class instance (always owned) */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
+{
+  VALUE obj;
+  swig_class *sklass = (swig_class *) type->clientdata;
+  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  return obj;
+}
+
+/* Get type mangle from class name */
+SWIGRUNTIMEINLINE char *
+SWIG_Ruby_MangleStr(VALUE obj)
+{
+  VALUE stype = rb_iv_get(obj, "@__swigtype__");
+  return StringValuePtr(stype);
+}
+
+/* Acquire a pointer value */
+typedef struct {
+  void (*datafree)(void *);
+  int own;
+} swig_ruby_owntype;
+
+SWIGRUNTIME swig_ruby_owntype
+SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
+  swig_ruby_owntype oldown = {0, 0};
+  if (obj) {
+    oldown.datafree = RDATA(obj)->dfree;
+    RDATA(obj)->dfree = own.datafree;
+  }
+  return oldown;
+}
+
+/* Convert a pointer value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
+{
+  char *c;
+  swig_cast_info *tc;
+  void *vptr = 0;
+
+  /* Grab the pointer */
+  if (NIL_P(obj)) {
+    if (ptr)
+      *ptr = 0;
+    return SWIG_OK;
+  } else {
+    if (TYPE(obj) != T_DATA) {
+      return SWIG_ERROR;
+    }
+    Data_Get_Struct(obj, void, vptr);
+  }
+  
+  if (own) {
+    own->datafree = RDATA(obj)->dfree;
+    own->own = 0;
+  }
+    
+  /* Check to see if the input object is giving up ownership
+     of the underlying C struct or C++ object.  If so then we
+     need to reset the destructor since the Ruby object no 
+     longer owns the underlying C++ object.*/ 
+  if (flags & SWIG_POINTER_DISOWN) {
+    /* Is tracking on for this class? */
+    int track = 0;
+    if (ty && ty->clientdata) {
+      swig_class *sklass = (swig_class *) ty->clientdata;
+      track = sklass->trackObjects;
+    }
+		
+    if (track) {
+      /* We are tracking objects for this class.  Thus we change the destructor
+       * to SWIG_RubyRemoveTracking.  This allows us to
+       * remove the mapping from the C++ to Ruby object
+       * when the Ruby object is garbage collected.  If we don't
+       * do this, then it is possible we will return a reference 
+       * to a Ruby object that no longer exists thereby crashing Ruby. */
+      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
+    } else {    
+      RDATA(obj)->dfree = 0;
+    }
+  }
+
+  /* Do type-checking if type info was provided */
+  if (ty) {
+    if (ty->clientdata) {
+      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
+        if (vptr == 0) {
+          /* The object has already been deleted */
+          return SWIG_ObjectPreviouslyDeletedError;
+        }
+      }
+    }
+    if ((c = SWIG_MangleStr(obj)) == NULL) {
+      return SWIG_ERROR;
+    }
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) {
+      return SWIG_ERROR;
+    } else {
+      if (ptr) {
+        if (tc->type == ty) {
+          *ptr = vptr;
+        } else {
+          int newmemory = 0;
+          *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
+          if (newmemory == SWIG_CAST_NEW_MEMORY) {
+            assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+            if (own)
+              own->own = own->own | SWIG_CAST_NEW_MEMORY;
+          }
+        }
+      }
+    }
+  } else {
+    if (ptr)
+      *ptr = vptr;
+  }
+  
+  return SWIG_OK;
+}
+
+/* Check convert */
+SWIGRUNTIMEINLINE int
+SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
+{
+  char *c = SWIG_MangleStr(obj);
+  if (!c) return 0;
+  return SWIG_TypeCheck(c,ty) != 0;
+}
+
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r, ptr, sz);
+  strcpy(r, type->name);
+  return rb_str_new2(result);
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c;
+
+  if (TYPE(obj) != T_STRING) goto type_error;
+  c = StringValuePtr(obj);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') goto type_error;
+  c++;
+  c = SWIG_UnpackData(c, ptr, sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) goto type_error;
+  }
+  return SWIG_OK;
+
+ type_error:
+  return SWIG_ERROR;
+}
+
+SWIGRUNTIME swig_module_info *
+SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
+{
+  VALUE pointer;
+  swig_module_info *ret = 0;
+  VALUE verbose = rb_gv_get("VERBOSE");
+
+ /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
+  rb_gv_set("VERBOSE", Qfalse);
+  
+  /* first check if pointer already created */
+  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  if (pointer != Qnil) {
+    Data_Get_Struct(pointer, swig_module_info, ret);
+  }
+
+  /* reinstate warnings */
+  rb_gv_set("VERBOSE", verbose);
+  return ret;
+}
+
+SWIGRUNTIME void 
+SWIG_Ruby_SetModule(swig_module_info *pointer)
+{
+  /* register a new class */
+  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
+  /* create and store the structure pointer to a global variable */
+  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
+  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
+}
+
+/* This function can be used to check whether a proc or method or similarly
+   callable function has been passed.  Usually used in a %typecheck, like:
+
+   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
+        $result = SWIG_Ruby_isCallable( $input );
+   }
+ */
+SWIGINTERN
+int SWIG_Ruby_isCallable( VALUE proc )
+{
+  if ( rb_respond_to( proc, swig_call_id ) )
+    return 1;
+  return 0;
+}
+
+/* This function can be used to check the arity (number of arguments)
+   a proc or method can take.  Usually used in a %typecheck.
+   Valid arities will be that equal to minimal or those < 0
+   which indicate a variable number of parameters at the end.
+ */
+SWIGINTERN
+int SWIG_Ruby_arity( VALUE proc, int minimal )
+{
+  if ( rb_respond_to( proc, swig_arity_id ) )
+    {
+      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
+      int arity = NUM2INT(num);
+      if ( arity < 0 && (arity+1) < -minimal ) return 1;
+      if ( arity == minimal ) return 1;
+      return 1;
+    }
+  return 0;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
+
+
+
+  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) 
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_p_FX4Splitter swig_types[0]
+#define SWIGTYPE_p_FX7Segment swig_types[1]
+#define SWIGTYPE_p_FXAccelTable swig_types[2]
+#define SWIGTYPE_p_FXApp swig_types[3]
+#define SWIGTYPE_p_FXArrowButton swig_types[4]
+#define SWIGTYPE_p_FXBitmap swig_types[5]
+#define SWIGTYPE_p_FXBitmapFrame swig_types[6]
+#define SWIGTYPE_p_FXButton swig_types[7]
+#define SWIGTYPE_p_FXCURCursor swig_types[8]
+#define SWIGTYPE_p_FXCanvas swig_types[9]
+#define SWIGTYPE_p_FXCheckButton swig_types[10]
+#define SWIGTYPE_p_FXColorBar swig_types[11]
+#define SWIGTYPE_p_FXColorRing swig_types[12]
+#define SWIGTYPE_p_FXColorSelector swig_types[13]
+#define SWIGTYPE_p_FXColorWell swig_types[14]
+#define SWIGTYPE_p_FXColorWheel swig_types[15]
+#define SWIGTYPE_p_FXComboBox swig_types[16]
+#define SWIGTYPE_p_FXComposite swig_types[17]
+#define SWIGTYPE_p_FXCursor swig_types[18]
+#define SWIGTYPE_p_FXDataTarget swig_types[19]
+#define SWIGTYPE_p_FXDebugTarget swig_types[20]
+#define SWIGTYPE_p_FXDelegator swig_types[21]
+#define SWIGTYPE_p_FXDial swig_types[22]
+#define SWIGTYPE_p_FXDict swig_types[23]
+#define SWIGTYPE_p_FXDirBox swig_types[24]
+#define SWIGTYPE_p_FXDirSelector swig_types[25]
+#define SWIGTYPE_p_FXDockBar swig_types[26]
+#define SWIGTYPE_p_FXDockHandler swig_types[27]
+#define SWIGTYPE_p_FXDockSite swig_types[28]
+#define SWIGTYPE_p_FXDockTitle swig_types[29]
+#define SWIGTYPE_p_FXDocument swig_types[30]
+#define SWIGTYPE_p_FXDragCorner swig_types[31]
+#define SWIGTYPE_p_FXDrawable swig_types[32]
+#define SWIGTYPE_p_FXDriveBox swig_types[33]
+#define SWIGTYPE_p_FXFileDict swig_types[34]
+#define SWIGTYPE_p_FXFileSelector swig_types[35]
+#define SWIGTYPE_p_FXFileStream swig_types[36]
+#define SWIGTYPE_p_FXFont swig_types[37]
+#define SWIGTYPE_p_FXFontSelector swig_types[38]
+#define SWIGTYPE_p_FXFrame swig_types[39]
+#define SWIGTYPE_p_FXGIFCursor swig_types[40]
+#define SWIGTYPE_p_FXGradientBar swig_types[41]
+#define SWIGTYPE_p_FXGroupBox swig_types[42]
+#define SWIGTYPE_p_FXHeader swig_types[43]
+#define SWIGTYPE_p_FXHeaderItem swig_types[44]
+#define SWIGTYPE_p_FXHorizontalFrame swig_types[45]
+#define SWIGTYPE_p_FXHorizontalSeparator swig_types[46]
+#define SWIGTYPE_p_FXIcon swig_types[47]
+#define SWIGTYPE_p_FXIconDict swig_types[48]
+#define SWIGTYPE_p_FXId swig_types[49]
+#define SWIGTYPE_p_FXImageFrame swig_types[50]
+#define SWIGTYPE_p_FXImageView swig_types[51]
+#define SWIGTYPE_p_FXKnob swig_types[52]
+#define SWIGTYPE_p_FXLabel swig_types[53]
+#define SWIGTYPE_p_FXListBox swig_types[54]
+#define SWIGTYPE_p_FXMDIChild swig_types[55]
+#define SWIGTYPE_p_FXMDIClient swig_types[56]
+#define SWIGTYPE_p_FXMDIDeleteButton swig_types[57]
+#define SWIGTYPE_p_FXMDIMaximizeButton swig_types[58]
+#define SWIGTYPE_p_FXMDIMenu swig_types[59]
+#define SWIGTYPE_p_FXMDIMinimizeButton swig_types[60]
+#define SWIGTYPE_p_FXMDIRestoreButton swig_types[61]
+#define SWIGTYPE_p_FXMDIWindowButton swig_types[62]
+#define SWIGTYPE_p_FXMainWindow swig_types[63]
+#define SWIGTYPE_p_FXMatrix swig_types[64]
+#define SWIGTYPE_p_FXMemoryStream swig_types[65]
+#define SWIGTYPE_p_FXMenuBar swig_types[66]
+#define SWIGTYPE_p_FXMenuButton swig_types[67]
+#define SWIGTYPE_p_FXMenuCaption swig_types[68]
+#define SWIGTYPE_p_FXMenuCascade swig_types[69]
+#define SWIGTYPE_p_FXMenuCheck swig_types[70]
+#define SWIGTYPE_p_FXMenuCommand swig_types[71]
+#define SWIGTYPE_p_FXMenuPane swig_types[72]
+#define SWIGTYPE_p_FXMenuRadio swig_types[73]
+#define SWIGTYPE_p_FXMenuSeparator swig_types[74]
+#define SWIGTYPE_p_FXMenuTitle swig_types[75]
+#define SWIGTYPE_p_FXObject swig_types[76]
+#define SWIGTYPE_p_FXOption swig_types[77]
+#define SWIGTYPE_p_FXOptionMenu swig_types[78]
+#define SWIGTYPE_p_FXPacker swig_types[79]
+#define SWIGTYPE_p_FXPicker swig_types[80]
+#define SWIGTYPE_p_FXPopup swig_types[81]
+#define SWIGTYPE_p_FXProgressBar swig_types[82]
+#define SWIGTYPE_p_FXRadioButton swig_types[83]
+#define SWIGTYPE_p_FXRealSlider swig_types[84]
+#define SWIGTYPE_p_FXRealSpinner swig_types[85]
+#define SWIGTYPE_p_FXRecentFiles swig_types[86]
+#define SWIGTYPE_p_FXRegion swig_types[87]
+#define SWIGTYPE_p_FXRegistry swig_types[88]
+#define SWIGTYPE_p_FXRootWindow swig_types[89]
+#define SWIGTYPE_p_FXRuler swig_types[90]
+#define SWIGTYPE_p_FXRulerView swig_types[91]
+#define SWIGTYPE_p_FXScrollArea swig_types[92]
+#define SWIGTYPE_p_FXScrollBar swig_types[93]
+#define SWIGTYPE_p_FXScrollCorner swig_types[94]
+#define SWIGTYPE_p_FXScrollPane swig_types[95]
+#define SWIGTYPE_p_FXScrollWindow swig_types[96]
+#define SWIGTYPE_p_FXSeparator swig_types[97]
+#define SWIGTYPE_p_FXSettings swig_types[98]
+#define SWIGTYPE_p_FXShell swig_types[99]
+#define SWIGTYPE_p_FXShutter swig_types[100]
+#define SWIGTYPE_p_FXShutterItem swig_types[101]
+#define SWIGTYPE_p_FXSlider swig_types[102]
+#define SWIGTYPE_p_FXSpinner swig_types[103]
+#define SWIGTYPE_p_FXSplashWindow swig_types[104]
+#define SWIGTYPE_p_FXSplitter swig_types[105]
+#define SWIGTYPE_p_FXSpring swig_types[106]
+#define SWIGTYPE_p_FXStatusBar swig_types[107]
+#define SWIGTYPE_p_FXStatusLine swig_types[108]
+#define SWIGTYPE_p_FXStream swig_types[109]
+#define SWIGTYPE_p_FXStringDict swig_types[110]
+#define SWIGTYPE_p_FXSwitcher swig_types[111]
+#define SWIGTYPE_p_FXTabBar swig_types[112]
+#define SWIGTYPE_p_FXTabBook swig_types[113]
+#define SWIGTYPE_p_FXTabItem swig_types[114]
+#define SWIGTYPE_p_FXTextField swig_types[115]
+#define SWIGTYPE_p_FXToggleButton swig_types[116]
+#define SWIGTYPE_p_FXToolBar swig_types[117]
+#define SWIGTYPE_p_FXToolBarGrip swig_types[118]
+#define SWIGTYPE_p_FXToolBarShell swig_types[119]
+#define SWIGTYPE_p_FXToolBarTab swig_types[120]
+#define SWIGTYPE_p_FXToolTip swig_types[121]
+#define SWIGTYPE_p_FXTopWindow swig_types[122]
+#define SWIGTYPE_p_FXTranslator swig_types[123]
+#define SWIGTYPE_p_FXTreeListBox swig_types[124]
+#define SWIGTYPE_p_FXTriStateButton swig_types[125]
+#define SWIGTYPE_p_FXVerticalFrame swig_types[126]
+#define SWIGTYPE_p_FXVerticalSeparator swig_types[127]
+#define SWIGTYPE_p_FXVisual swig_types[128]
+#define SWIGTYPE_p_FXWindow swig_types[129]
+#define SWIGTYPE_p_char swig_types[130]
+#define SWIGTYPE_p_double swig_types[131]
+#define SWIGTYPE_p_float swig_types[132]
+#define SWIGTYPE_p_int swig_types[133]
+#define SWIGTYPE_p_long swig_types[134]
+#define SWIGTYPE_p_short swig_types[135]
+#define SWIGTYPE_p_unsigned_char swig_types[136]
+#define SWIGTYPE_p_unsigned_int swig_types[137]
+#define SWIGTYPE_p_unsigned_long swig_types[138]
+#define SWIGTYPE_p_unsigned_short swig_types[139]
+static swig_type_info *swig_types[141];
+static swig_module_info swig_module = {swig_types, 140, 0, 0, 0, 0};
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
+
+/* -------- TYPES TABLE (END) -------- */
+
+#define SWIG_init    Init_mdi
+#define SWIG_name    "Mdi"
+
+
+
+#define SWIG_RUBY_THREAD_BEGIN_BLOCK
+#define SWIG_RUBY_THREAD_END_BLOCK
+
+
+#define SWIGVERSION 0x030012 
+#define SWIG_VERSION SWIGVERSION
+
+
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
+
+
+#include <stdexcept>
+
+
+#include "FXRbCommon.h"
+
+
+inline FXColor to_FXColor(VALUE obj){
+  if(TYPE(obj)==T_STRING){
+    return fxcolorfromname(StringValuePtr(obj));
+    }
+  else if(TYPE(obj)==T_SYMBOL){
+    return fxcolorfromname(rb_id2name(SYM2ID(obj)));
+    }
+  else{
+    return NUM2ULONG(obj);
+    }
+  }
+
+
+inline FXString to_FXString(VALUE obj){
+  if(!NIL_P(obj)){
+    Check_Type(obj,T_STRING);
+    return FXString(StringValuePtr(obj));
+    }
+  else{
+    return FXString::null;
+    }
+  }
+
+
+inline FXbool to_FXbool(VALUE obj){
+  if (obj == Qtrue || obj == Qfalse){
+    return (obj == Qtrue) ? TRUE : FALSE;
+    }
+  else{
+    return static_cast<FXbool>(NUM2UINT(obj));
+    }
+  }
+
+
+static swig_type_info* FXEventTypeInfo=0;
+
+inline void* to_FXEvent(VALUE obj){
+  void* ptr;
+  if(!FXEventTypeInfo){
+    FXEventTypeInfo=SWIG_TypeQuery("FXEvent *");
+    FXASSERT(FXEventTypeInfo!=0);
+    }
+  SWIG_ConvertPtr(obj,&ptr,FXEventTypeInfo,1);
+  return ptr;
+  }
+
+
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
+
+
+  #define SWIG_From_long   LONG2NUM 
+
+SWIGINTERN FXMDIDeleteButton *new_FXMDIDeleteButton(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=FRAME_RAISED,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbMDIDeleteButton(p,tgt,sel,opts,x,y,w,h);
+      }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_int  (int value)
+{    
+  return SWIG_From_long  (value);
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_bool  (bool value)
+{
+  return value ? Qtrue : Qfalse;
+}
+
+
+SWIGINTERN swig_type_info*
+SWIG_pchar_descriptor(void)
+{
+  static int init = 0;
+  static swig_type_info* info = 0;
+  if (!init) {
+    info = SWIG_TypeQuery("_p_char");
+    init = 1;
+  }
+  return info;
+}
+
+
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
+{
+  if (TYPE(obj) == T_STRING) {
+    char *cstr = StringValuePtr(obj); 
+    size_t size = RSTRING_LEN(obj) + 1;
+    if (cptr)  {
+      if (alloc) {
+	if (*alloc == SWIG_NEWOBJ) {
+	  *cptr = reinterpret_cast< char* >(memcpy(new char[size], cstr, sizeof(char)*(size)));
+	} else {
+	  *cptr = cstr;
+	  *alloc = SWIG_OLDOBJ;
+	}
+      }
+    }
+    if (psize) *psize = size;
+    return SWIG_OK;
+  } else {
+    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+    if (pchar_descriptor) {
+      void* vptr = 0;
+      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
+	if (cptr) *cptr = (char *)vptr;
+	if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
+	if (alloc) *alloc = SWIG_OLDOBJ;
+	return SWIG_OK;
+      }
+    }
+  }  
+  return SWIG_TypeError;
+}
+
+
+
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+  if (carray) {
+    if (size > LONG_MAX) {
+      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+      return pchar_descriptor ? 
+	SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : Qnil;
+    } else {
+      return rb_str_new(carray, static_cast< long >(size));
+    }
+  } else {
+    return Qnil;
+  }
+}
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtr(const char *cptr)
+{ 
+  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
+}
+
+SWIGINTERN FXMDIRestoreButton *new_FXMDIRestoreButton(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=FRAME_RAISED,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbMDIRestoreButton(p,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN FXMDIMaximizeButton *new_FXMDIMaximizeButton(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=FRAME_RAISED,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbMDIMaximizeButton(p,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN FXMDIMinimizeButton *new_FXMDIMinimizeButton(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=FRAME_RAISED,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbMDIMinimizeButton(p,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN FXMDIWindowButton *new_FXMDIWindowButton(FXComposite *p,FXPopup *pup,FXObject *tgt=0,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbMDIWindowButton(p,pup,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN FXMDIMenu *new_FXMDIMenu(FXWindow *owner,FXObject *tgt=0){
+      return new FXRbMDIMenu(owner,tgt);
+      }
+SWIGINTERN FXMDIClient *new_FXMDIClient(FXComposite *p,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbMDIClient(p,opts,x,y,w,h);
+      }
+SWIGINTERN FXMDIChild *new_FXMDIChild(FXMDIClient *p,FXString const &name,FXIcon *ic=0,FXPopup *pup=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbMDIChild(p,name,ic,pup,opts,x,y,w,h);
+      }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_long  (unsigned long value)
+{
+  return ULONG2NUM(value); 
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_int  (unsigned int value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+static swig_class SwigClassFXMDIDeleteButton;
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMDIDeleteButton_allocate(VALUE self)
+#else
+_wrap_FXMDIDeleteButton_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMDIDeleteButton);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMDIDeleteButton(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) FRAME_RAISED ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXMDIDeleteButton *result = 0 ;
+  
+  if ((argc < 1) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXMDIDeleteButton", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXMDIDeleteButton", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXMDIDeleteButton *)new_FXMDIDeleteButton(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_save(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMDIDeleteButton_save((FXMDIDeleteButton const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_load(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMDIDeleteButton_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_create(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  FXMDIDeleteButton_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_detach(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  FXMDIDeleteButton_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_destroy(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  FXMDIDeleteButton_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_resize(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMDIDeleteButton_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  result = (FXint)FXMDIDeleteButton_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  result = (FXint)FXMDIDeleteButton_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMDIDeleteButton_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMDIDeleteButton_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  result = (bool)FXMDIDeleteButton_canFocus((FXMDIDeleteButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  FXMDIDeleteButton_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  FXMDIDeleteButton_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXMDIDeleteButton_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMDIDeleteButton_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_enable(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  FXMDIDeleteButton_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_disable(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  FXMDIDeleteButton_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  FXMDIDeleteButton_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_lower(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  FXMDIDeleteButton_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_move(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMDIDeleteButton_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_position(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXMDIDeleteButton_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_layout(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  FXMDIDeleteButton_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_recalc(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  FXMDIDeleteButton_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_reparent(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXMDIDeleteButton_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_show(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  FXMDIDeleteButton_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_hide(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  FXMDIDeleteButton_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  result = (bool)FXMDIDeleteButton_isComposite((FXMDIDeleteButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_contains(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXMDIDeleteButton_contains((FXMDIDeleteButton const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  result = (bool)FXMDIDeleteButton_doesSaveUnder((FXMDIDeleteButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXMDIDeleteButton_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_tr(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXMDIDeleteButton_tr((FXMDIDeleteButton const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  FXMDIDeleteButton_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  FXMDIDeleteButton_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXMDIDeleteButton_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXMDIDeleteButton_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXMDIDeleteButton_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMDIDeleteButton_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIDeleteButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIDeleteButton_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIDeleteButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIDeleteButton_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIDeleteButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIDeleteButton_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIDeleteButton_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXMDIDeleteButton *arg1 = (FXMDIDeleteButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIDeleteButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIDeleteButton *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIDeleteButton * >(argp1);
+  FXMDIDeleteButton_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMDIRestoreButton;
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMDIRestoreButton_allocate(VALUE self)
+#else
+_wrap_FXMDIRestoreButton_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMDIRestoreButton);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMDIRestoreButton(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) FRAME_RAISED ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXMDIRestoreButton *result = 0 ;
+  
+  if ((argc < 1) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXMDIRestoreButton", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXMDIRestoreButton", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXMDIRestoreButton *)new_FXMDIRestoreButton(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_save(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMDIRestoreButton_save((FXMDIRestoreButton const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_load(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMDIRestoreButton_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_create(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  FXMDIRestoreButton_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_detach(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  FXMDIRestoreButton_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_destroy(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  FXMDIRestoreButton_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_resize(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMDIRestoreButton_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  result = (FXint)FXMDIRestoreButton_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  result = (FXint)FXMDIRestoreButton_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMDIRestoreButton_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMDIRestoreButton_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  result = (bool)FXMDIRestoreButton_canFocus((FXMDIRestoreButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  FXMDIRestoreButton_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  FXMDIRestoreButton_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXMDIRestoreButton_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMDIRestoreButton_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_enable(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  FXMDIRestoreButton_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_disable(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  FXMDIRestoreButton_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  FXMDIRestoreButton_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_lower(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  FXMDIRestoreButton_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_move(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMDIRestoreButton_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_position(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXMDIRestoreButton_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_layout(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  FXMDIRestoreButton_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_recalc(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  FXMDIRestoreButton_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_reparent(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXMDIRestoreButton_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_show(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  FXMDIRestoreButton_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_hide(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  FXMDIRestoreButton_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  result = (bool)FXMDIRestoreButton_isComposite((FXMDIRestoreButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_contains(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXMDIRestoreButton_contains((FXMDIRestoreButton const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  result = (bool)FXMDIRestoreButton_doesSaveUnder((FXMDIRestoreButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXMDIRestoreButton_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_tr(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXMDIRestoreButton_tr((FXMDIRestoreButton const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  FXMDIRestoreButton_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  FXMDIRestoreButton_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXMDIRestoreButton_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXMDIRestoreButton_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXMDIRestoreButton_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMDIRestoreButton_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIRestoreButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIRestoreButton_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIRestoreButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIRestoreButton_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIRestoreButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIRestoreButton_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIRestoreButton_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXMDIRestoreButton *arg1 = (FXMDIRestoreButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIRestoreButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIRestoreButton *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIRestoreButton * >(argp1);
+  FXMDIRestoreButton_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMDIMaximizeButton;
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMDIMaximizeButton_allocate(VALUE self)
+#else
+_wrap_FXMDIMaximizeButton_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMDIMaximizeButton);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMDIMaximizeButton(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) FRAME_RAISED ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXMDIMaximizeButton *result = 0 ;
+  
+  if ((argc < 1) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXMDIMaximizeButton", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXMDIMaximizeButton", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXMDIMaximizeButton *)new_FXMDIMaximizeButton(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_save(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMDIMaximizeButton_save((FXMDIMaximizeButton const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_load(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMDIMaximizeButton_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_create(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  FXMDIMaximizeButton_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_detach(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  FXMDIMaximizeButton_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_destroy(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  FXMDIMaximizeButton_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_resize(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMDIMaximizeButton_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  result = (FXint)FXMDIMaximizeButton_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  result = (FXint)FXMDIMaximizeButton_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMDIMaximizeButton_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMDIMaximizeButton_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  result = (bool)FXMDIMaximizeButton_canFocus((FXMDIMaximizeButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  FXMDIMaximizeButton_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  FXMDIMaximizeButton_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXMDIMaximizeButton_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMDIMaximizeButton_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_enable(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  FXMDIMaximizeButton_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_disable(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  FXMDIMaximizeButton_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  FXMDIMaximizeButton_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_lower(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  FXMDIMaximizeButton_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_move(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMDIMaximizeButton_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_position(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXMDIMaximizeButton_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_layout(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  FXMDIMaximizeButton_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_recalc(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  FXMDIMaximizeButton_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_reparent(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXMDIMaximizeButton_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_show(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  FXMDIMaximizeButton_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_hide(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  FXMDIMaximizeButton_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  result = (bool)FXMDIMaximizeButton_isComposite((FXMDIMaximizeButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_contains(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXMDIMaximizeButton_contains((FXMDIMaximizeButton const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  result = (bool)FXMDIMaximizeButton_doesSaveUnder((FXMDIMaximizeButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXMDIMaximizeButton_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_tr(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXMDIMaximizeButton_tr((FXMDIMaximizeButton const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  FXMDIMaximizeButton_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  FXMDIMaximizeButton_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXMDIMaximizeButton_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXMDIMaximizeButton_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXMDIMaximizeButton_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMDIMaximizeButton_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIMaximizeButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIMaximizeButton_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIMaximizeButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIMaximizeButton_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIMaximizeButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIMaximizeButton_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMaximizeButton_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXMDIMaximizeButton *arg1 = (FXMDIMaximizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMaximizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMaximizeButton *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMaximizeButton * >(argp1);
+  FXMDIMaximizeButton_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMDIMinimizeButton;
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMDIMinimizeButton_allocate(VALUE self)
+#else
+_wrap_FXMDIMinimizeButton_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMDIMinimizeButton);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMDIMinimizeButton(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) FRAME_RAISED ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXMDIMinimizeButton *result = 0 ;
+  
+  if ((argc < 1) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXMDIMinimizeButton", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXMDIMinimizeButton", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXMDIMinimizeButton *)new_FXMDIMinimizeButton(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_save(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMDIMinimizeButton_save((FXMDIMinimizeButton const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_load(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMDIMinimizeButton_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_create(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  FXMDIMinimizeButton_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_detach(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  FXMDIMinimizeButton_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_destroy(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  FXMDIMinimizeButton_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_resize(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMDIMinimizeButton_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  result = (FXint)FXMDIMinimizeButton_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  result = (FXint)FXMDIMinimizeButton_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMDIMinimizeButton_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMDIMinimizeButton_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  result = (bool)FXMDIMinimizeButton_canFocus((FXMDIMinimizeButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  FXMDIMinimizeButton_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  FXMDIMinimizeButton_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXMDIMinimizeButton_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMDIMinimizeButton_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_enable(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  FXMDIMinimizeButton_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_disable(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  FXMDIMinimizeButton_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  FXMDIMinimizeButton_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_lower(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  FXMDIMinimizeButton_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_move(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMDIMinimizeButton_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_position(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXMDIMinimizeButton_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_layout(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  FXMDIMinimizeButton_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_recalc(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  FXMDIMinimizeButton_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_reparent(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXMDIMinimizeButton_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_show(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  FXMDIMinimizeButton_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_hide(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  FXMDIMinimizeButton_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  result = (bool)FXMDIMinimizeButton_isComposite((FXMDIMinimizeButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_contains(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXMDIMinimizeButton_contains((FXMDIMinimizeButton const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  result = (bool)FXMDIMinimizeButton_doesSaveUnder((FXMDIMinimizeButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXMDIMinimizeButton_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_tr(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXMDIMinimizeButton_tr((FXMDIMinimizeButton const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  FXMDIMinimizeButton_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  FXMDIMinimizeButton_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXMDIMinimizeButton_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXMDIMinimizeButton_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXMDIMinimizeButton_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMDIMinimizeButton_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIMinimizeButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIMinimizeButton_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIMinimizeButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIMinimizeButton_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIMinimizeButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIMinimizeButton_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMinimizeButton_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXMDIMinimizeButton *arg1 = (FXMDIMinimizeButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMinimizeButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMinimizeButton *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMinimizeButton * >(argp1);
+  FXMDIMinimizeButton_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMDIWindowButton;
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMDIWindowButton_allocate(VALUE self)
+#else
+_wrap_FXMDIWindowButton_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMDIWindowButton);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMDIWindowButton(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXPopup *arg2 = (FXPopup *) 0 ;
+  FXObject *arg3 = (FXObject *) 0 ;
+  FXSelector arg4 = (FXSelector) 0 ;
+  FXuint arg5 = (FXuint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXMDIWindowButton *result = 0 ;
+  
+  if ((argc < 2) || (argc > 9)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXMDIWindowButton", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXPopup *","FXMDIWindowButton", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXPopup * >(argp2);
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXObject *","FXMDIWindowButton", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXObject * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXMDIWindowButton *)new_FXMDIWindowButton(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_save(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMDIWindowButton_save((FXMDIWindowButton const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_load(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMDIWindowButton_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_create(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  FXMDIWindowButton_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_detach(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  FXMDIWindowButton_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_destroy(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  FXMDIWindowButton_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_resize(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMDIWindowButton_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  result = (FXint)FXMDIWindowButton_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  result = (FXint)FXMDIWindowButton_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMDIWindowButton_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMDIWindowButton_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  result = (bool)FXMDIWindowButton_canFocus((FXMDIWindowButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  FXMDIWindowButton_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  FXMDIWindowButton_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXMDIWindowButton_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMDIWindowButton_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_enable(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  FXMDIWindowButton_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_disable(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  FXMDIWindowButton_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  FXMDIWindowButton_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_lower(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  FXMDIWindowButton_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_move(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMDIWindowButton_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_position(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXMDIWindowButton_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_layout(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  FXMDIWindowButton_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_recalc(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  FXMDIWindowButton_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_reparent(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXMDIWindowButton_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_show(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  FXMDIWindowButton_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_hide(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  FXMDIWindowButton_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  result = (bool)FXMDIWindowButton_isComposite((FXMDIWindowButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_contains(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXMDIWindowButton_contains((FXMDIWindowButton const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  result = (bool)FXMDIWindowButton_doesSaveUnder((FXMDIWindowButton const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXMDIWindowButton_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_tr(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXMDIWindowButton_tr((FXMDIWindowButton const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  FXMDIWindowButton_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  FXMDIWindowButton_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXMDIWindowButton_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXMDIWindowButton_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXMDIWindowButton_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMDIWindowButton_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIWindowButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIWindowButton_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIWindowButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIWindowButton_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIWindowButton, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIWindowButton_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIWindowButton_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXMDIWindowButton *arg1 = (FXMDIWindowButton *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIWindowButton, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIWindowButton *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIWindowButton * >(argp1);
+  FXMDIWindowButton_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMDIMenu;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMDIMenu_allocate(VALUE self)
+#else
+_wrap_FXMDIMenu_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMDIMenu);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMDIMenu(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXMDIMenu *result = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXMDIMenu", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXMDIMenu", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXMDIMenu *)new_FXMDIMenu(arg1,arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_save(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMDIMenu_save((FXMDIMenu const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_load(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMDIMenu_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_create(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  FXMDIMenu_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_detach(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  FXMDIMenu_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_destroy(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  FXMDIMenu_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_resize(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMDIMenu_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  result = (FXint)FXMDIMenu_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  result = (FXint)FXMDIMenu_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMDIMenu_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMDIMenu_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  result = (bool)FXMDIMenu_canFocus((FXMDIMenu const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  FXMDIMenu_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  FXMDIMenu_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXMDIMenu_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMDIMenu_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_enable(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  FXMDIMenu_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_disable(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  FXMDIMenu_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  FXMDIMenu_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_lower(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  FXMDIMenu_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_move(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMDIMenu_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_position(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXMDIMenu_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_layout(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  FXMDIMenu_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_recalc(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  FXMDIMenu_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_reparent(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXMDIMenu_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_show(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  FXMDIMenu_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_hide(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  FXMDIMenu_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  result = (bool)FXMDIMenu_isComposite((FXMDIMenu const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_contains(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXMDIMenu_contains((FXMDIMenu const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  result = (bool)FXMDIMenu_doesSaveUnder((FXMDIMenu const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXMDIMenu_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_tr(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXMDIMenu_tr((FXMDIMenu const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  FXMDIMenu_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  FXMDIMenu_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXMDIMenu_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXMDIMenu_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXMDIMenu_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMDIMenu_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIMenu, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIMenu_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIMenu, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIMenu_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIMenu, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIMenu_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  FXMDIMenu_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_popup(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 3) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","popup", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","popup", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  if (argc > 3) {
+    arg5 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg6 = NUM2INT(argv[4]);
+  }
+  FXMDIMenu_popup(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIMenu_popdown(int argc, VALUE *argv, VALUE self) {
+  FXMDIMenu *arg1 = (FXMDIMenu *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIMenu, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIMenu *","popdown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIMenu * >(argp1);
+  FXMDIMenu_popdown(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMDIClient;
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_onCmdActivateNext(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","onCmdActivateNext", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdActivateNext", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdActivateNext(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_onCmdActivatePrev(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","onCmdActivatePrev", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdActivatePrev", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdActivatePrev(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_onCmdTileHorizontal(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","onCmdTileHorizontal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdTileHorizontal", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdTileHorizontal(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_onCmdTileVertical(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","onCmdTileVertical", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdTileVertical", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdTileVertical(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_onCmdCascade(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","onCmdCascade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCascade", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCascade(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_onUpdActivateNext(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","onUpdActivateNext", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdActivateNext", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdActivateNext(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_onUpdActivatePrev(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","onUpdActivatePrev", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdActivatePrev", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdActivatePrev(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_onUpdTileVertical(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","onUpdTileVertical", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdTileVertical", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdTileVertical(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_onUpdTileHorizontal(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","onUpdTileHorizontal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdTileHorizontal", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdTileHorizontal(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_onUpdCascade(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","onUpdCascade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdCascade", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdCascade(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_onUpdClose(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","onUpdClose", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdClose", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdClose(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_onUpdMenuClose(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","onUpdMenuClose", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdMenuClose", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdMenuClose(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_onUpdRestore(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","onUpdRestore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdRestore", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdRestore(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_onUpdMenuRestore(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","onUpdMenuRestore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdMenuRestore", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdMenuRestore(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_onUpdMinimize(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","onUpdMinimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdMinimize", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdMinimize(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_onUpdMenuMinimize(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","onUpdMenuMinimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdMenuMinimize", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdMenuMinimize(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_onUpdMaximize(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","onUpdMaximize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdMaximize", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdMaximize(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_onUpdMenuWindow(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","onUpdMenuWindow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdMenuWindow", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdMenuWindow(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_onCmdWindowSelect(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","onCmdWindowSelect", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdWindowSelect", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdWindowSelect(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_onUpdWindowSelect(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","onUpdWindowSelect", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdWindowSelect", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdWindowSelect(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_onCmdOthersWindows(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","onCmdOthersWindows", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdOthersWindows", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdOthersWindows(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_onUpdOthersWindows(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","onUpdOthersWindows", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdOthersWindows", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdOthersWindows(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_onUpdAnyWindows(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","onUpdAnyWindows", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdAnyWindows", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdAnyWindows(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMDIClient_allocate(VALUE self)
+#else
+_wrap_FXMDIClient_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMDIClient);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMDIClient(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXuint arg2 = (FXuint) 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMDIClient *result = 0 ;
+  
+  if ((argc < 1) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXMDIClient", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXMDIClient *)new_FXMDIClient(arg1,arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_forallWindows(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","forallWindows", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","forallWindows", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = (argv[2] == Qnil) ? NULL : (void *) argv[2];
+  result = (long)(arg1)->forallWindows(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_forallDocuments(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","forallDocuments", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","forallDocuments", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = (argv[2] == Qnil) ? NULL : (void *) argv[2];
+  result = (long)(arg1)->forallDocuments(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_forallDocWindows(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXObject *arg3 = (FXObject *) 0 ;
+  FXSelector arg4 ;
+  void *arg5 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","forallDocWindows", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","forallDocWindows", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXObject *","forallDocWindows", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXObject * >(argp3);
+  arg4 = NUM2UINT(argv[2]);
+  arg5 = (argv[3] == Qnil) ? NULL : (void *) argv[3];
+  result = (long)(arg1)->forallDocWindows(arg2,arg3,arg4,arg5);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_getActiveChild(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMDIChild *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient const *","getActiveChild", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  result = (FXMDIChild *)((FXMDIClient const *)arg1)->getActiveChild();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXMDIChild, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_setCascadeX(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","setCascadeX", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setCascadeX(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_setCascadeY(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","setCascadeY", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setCascadeY(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_getCascadeX(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient const *","getCascadeX", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  result = (FXint)((FXMDIClient const *)arg1)->getCascadeX();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_getCascadeY(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient const *","getCascadeY", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  result = (FXint)((FXMDIClient const *)arg1)->getCascadeY();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_save(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMDIClient_save((FXMDIClient const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_load(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMDIClient_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_create(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  FXMDIClient_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_detach(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  FXMDIClient_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_destroy(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  FXMDIClient_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_resize(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMDIClient_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  result = (FXint)FXMDIClient_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  result = (FXint)FXMDIClient_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMDIClient_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMDIClient_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  result = (bool)FXMDIClient_canFocus((FXMDIClient const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  FXMDIClient_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  FXMDIClient_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXMDIClient_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMDIClient_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_enable(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  FXMDIClient_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_disable(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  FXMDIClient_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  FXMDIClient_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_lower(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  FXMDIClient_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_move(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMDIClient_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_position(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXMDIClient_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_layout(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  FXMDIClient_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_recalc(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  FXMDIClient_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_reparent(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXMDIClient_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_show(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  FXMDIClient_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_hide(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  FXMDIClient_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  result = (bool)FXMDIClient_isComposite((FXMDIClient const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_contains(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXMDIClient_contains((FXMDIClient const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  result = (bool)FXMDIClient_doesSaveUnder((FXMDIClient const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXMDIClient_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_tr(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXMDIClient_tr((FXMDIClient const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  FXMDIClient_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  FXMDIClient_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXMDIClient_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXMDIClient_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXMDIClient_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMDIClient_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIClient, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIClient_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIClient, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIClient_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIClient, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIClient_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  FXMDIClient_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_setActiveChild(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXMDIChild *arg2 = (FXMDIChild *) 0 ;
+  FXbool arg3 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","setActiveChild", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  if (argc > 0) {
+    res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXMDIChild *","setActiveChild", 2, argv[0] )); 
+    }
+    arg2 = reinterpret_cast< FXMDIChild * >(argp2);
+  }
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXMDIClient_setActiveChild(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_cascade(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","cascade", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMDIClient_cascade(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_horizontal(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","horizontal", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMDIClient_horizontal(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIClient_vertical(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","vertical", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMDIClient_vertical(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMDIChild;
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onFocusSelf(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onFocusSelf", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusSelf", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusSelf(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onFocusIn(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onFocusIn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusIn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusIn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onFocusOut(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onFocusOut", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusOut", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusOut(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onRightBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onRightBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onRightBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onRightBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onRightBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onRightBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onMiddleBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onMiddleBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMiddleBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMiddleBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onMiddleBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onMiddleBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMiddleBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMiddleBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onSelected(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSelected", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onSelected", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onSelected(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onDeselected(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onDeselected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDeselected", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onDeselected", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onDeselected(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onCmdClose(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onCmdClose", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdClose", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdClose(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onUpdClose(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onUpdClose", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdClose", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdClose(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onCmdRestore(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onCmdRestore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdRestore", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdRestore(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onUpdRestore(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onUpdRestore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdRestore", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdRestore(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onUpdMaximize(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onUpdMaximize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdMaximize", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdMaximize(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onUpdMinimize(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onUpdMinimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdMinimize", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdMinimize(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onCmdMaximize(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onCmdMaximize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMaximize", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdMaximize(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onCmdMinimize(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onCmdMinimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMinimize", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdMinimize(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onUpdWindow(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onUpdWindow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdWindow", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdWindow(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onUpdMenuRestore(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onUpdMenuRestore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdMenuRestore", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdMenuRestore(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onUpdMenuMinimize(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onUpdMenuMinimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdMenuMinimize", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdMenuMinimize(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onUpdMenuClose(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onUpdMenuClose", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdMenuClose", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdMenuClose(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onUpdMenuWindow(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onUpdMenuWindow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdMenuWindow", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdMenuWindow(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onCmdSetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onCmdSetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onCmdGetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onCmdGetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdGetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onCmdSetIconValue(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onCmdSetIconValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIconValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetIconValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_onCmdGetIconValue(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","onCmdGetIconValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIconValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdGetIconValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMDIChild_allocate(VALUE self)
+#else
+_wrap_FXMDIChild_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMDIChild);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMDIChild(int argc, VALUE *argv, VALUE self) {
+  FXMDIClient *arg1 = (FXMDIClient *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXPopup *arg4 = (FXPopup *) 0 ;
+  FXuint arg5 = (FXuint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXMDIChild *result = 0 ;
+  
+  if ((argc < 2) || (argc > 9)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXMDIClient, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIClient *","FXMDIChild", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXMDIClient * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","FXMDIChild", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 3) {
+    res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_FXPopup, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXPopup *","FXMDIChild", 4, argv[3] )); 
+    }
+    arg4 = reinterpret_cast< FXPopup * >(argp4);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  {
+    result = (FXMDIChild *)new_FXMDIChild(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setNormalX(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setNormalX", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setNormalX(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setNormalY(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setNormalY", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setNormalY(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setNormalWidth(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setNormalWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setNormalWidth(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setNormalHeight(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setNormalHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setNormalHeight(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_getNormalX(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","getNormalX", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (FXint)((FXMDIChild const *)arg1)->getNormalX();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_getNormalY(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","getNormalY", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (FXint)((FXMDIChild const *)arg1)->getNormalY();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_getNormalWidth(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","getNormalWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (FXint)((FXMDIChild const *)arg1)->getNormalWidth();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_getNormalHeight(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","getNormalHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (FXint)((FXMDIChild const *)arg1)->getNormalHeight();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setIconX(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setIconX", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setIconX(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setIconY(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setIconY", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setIconY(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setIconWidth(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setIconWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setIconWidth(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setIconHeight(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setIconHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setIconHeight(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_getIconX(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","getIconX", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (FXint)((FXMDIChild const *)arg1)->getIconX();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_getIconY(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","getIconY", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (FXint)((FXMDIChild const *)arg1)->getIconY();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_getIconWidth(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","getIconWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (FXint)((FXMDIChild const *)arg1)->getIconWidth();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_getIconHeight(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","getIconHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (FXint)((FXMDIChild const *)arg1)->getIconHeight();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_contentWindow(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","contentWindow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (FXWindow *)((FXMDIChild const *)arg1)->contentWindow();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setTitle(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setTitle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTitle((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_getTitle(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","getTitle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = ((FXMDIChild const *)arg1)->getTitle();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_getHiliteColor(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","getHiliteColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (FXColor)((FXMDIChild const *)arg1)->getHiliteColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_getShadowColor(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","getShadowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (FXColor)((FXMDIChild const *)arg1)->getShadowColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_getBaseColor(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","getBaseColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (FXColor)((FXMDIChild const *)arg1)->getBaseColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_getBorderColor(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","getBorderColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (FXColor)((FXMDIChild const *)arg1)->getBorderColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_getTitleColor(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","getTitleColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (FXColor)((FXMDIChild const *)arg1)->getTitleColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_getTitleBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","getTitleBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (FXColor)((FXMDIChild const *)arg1)->getTitleBackColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setHiliteColor(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setHiliteColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setHiliteColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setShadowColor(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setShadowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setShadowColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setBaseColor(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setBaseColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setBaseColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setBorderColor(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setBorderColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setBorderColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setTitleColor(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setTitleColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTitleColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setTitleBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setTitleBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTitleBackColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_isMaximized(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","isMaximized", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (FXbool)((FXMDIChild const *)arg1)->isMaximized();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_isMinimized(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","isMinimized", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (FXbool)((FXMDIChild const *)arg1)->isMinimized();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_getIcon(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","getIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (FXIcon *)((FXMDIChild const *)arg1)->getIcon();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setIcon(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  (arg1)->setIcon(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_getMenu(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPopup *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","getMenu", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (FXPopup *)((FXMDIChild const *)arg1)->getMenu();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXPopup, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setMenu(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXPopup *arg2 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setMenu", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXPopup *","setMenu", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXPopup * >(argp2);
+  (arg1)->setMenu(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setTracking(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setTracking", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->setTracking(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_getTracking(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","getTracking", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (FXbool)((FXMDIChild const *)arg1)->getTracking();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setFont(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  (arg1)->setFont(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_getFont(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (FXFont *)((FXMDIChild const *)arg1)->getFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_save(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMDIChild_save((FXMDIChild const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_load(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMDIChild_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_create(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  FXMDIChild_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_detach(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  FXMDIChild_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_destroy(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  FXMDIChild_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_resize(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMDIChild_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (FXint)FXMDIChild_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (FXint)FXMDIChild_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMDIChild_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMDIChild_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (bool)FXMDIChild_canFocus((FXMDIChild const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  FXMDIChild_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  FXMDIChild_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXMDIChild_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMDIChild_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_enable(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  FXMDIChild_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_disable(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  FXMDIChild_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  FXMDIChild_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_lower(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  FXMDIChild_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_move(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMDIChild_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_position(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXMDIChild_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_layout(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  FXMDIChild_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_recalc(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  FXMDIChild_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_reparent(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXMDIChild_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_show(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  FXMDIChild_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_hide(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  FXMDIChild_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (bool)FXMDIChild_isComposite((FXMDIChild const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_contains(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXMDIChild_contains((FXMDIChild const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  result = (bool)FXMDIChild_doesSaveUnder((FXMDIChild const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXMDIChild_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_tr(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXMDIChild_tr((FXMDIChild const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  FXMDIChild_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  FXMDIChild_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXMDIChild_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXMDIChild_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXMDIChild_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMDIChild_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIChild, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIChild_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIChild, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIChild_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMDIChild, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMDIChild_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  FXMDIChild_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_minimize(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","minimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXMDIChild_minimize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_maximize(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","maximize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXMDIChild_maximize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_restore(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXMDIChild_restore(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMDIChild_close(int argc, VALUE *argv, VALUE self) {
+  FXMDIChild *arg1 = (FXMDIChild *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMDIChild, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMDIChild *","close", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMDIChild * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXMDIChild_close(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_FXMDIMenuTo_p_FXMenuPane(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXMenuPane *)  ((FXMDIMenu *) x));
+}
+static void *_p_FXScrollPaneTo_p_FXMenuPane(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXMenuPane *)  ((FXScrollPane *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXMDIClientTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXMDIClient *) x));
+}
+static void *_p_FXMenuPaneTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXPopup *) ((FXMenuPane *) x));
+}
+static void *_p_FXToolBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXMenuBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXDockBar *)(FXToolBar *) ((FXMenuBar *) x));
+}
+static void *_p_FXToolTipTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXTabBookTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXShell *) x));
+}
+static void *_p_FXStatusBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXScrollArea *) x));
+}
+static void *_p_FXPopupTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXComboBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXMDIChildTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXMDIChild *) x));
+}
+static void *_p_FX4SplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXSplitter *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXPackerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXPacker *) x));
+}
+static void *_p_FXDirBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXSwitcherTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXShutterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXDockSiteTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXRulerViewTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXMatrixTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXShutterItemTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXDockBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXImageViewTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXSpringTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXScrollPaneTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXPopup *)(FXMenuPane *) ((FXScrollPane *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXMDIMenuTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXPopup *)(FXMenuPane *) ((FXMDIMenu *) x));
+}
+static void *_p_FXMDIWindowButtonTo_p_FXMenuButton(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXMenuButton *)  ((FXMDIWindowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *)  ((FXPopup *) x));
+}
+static void *_p_FXTopWindowTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *)  ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXToolTipTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *)  ((FXToolTip *) x));
+}
+static void *_p_FXMenuPaneTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXPopup *) ((FXMenuPane *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXMDIMenuTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXPopup *)(FXMenuPane *) ((FXMDIMenu *) x));
+}
+static void *_p_FXScrollPaneTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXPopup *)(FXMenuPane *) ((FXScrollPane *) x));
+}
+static void *_p_FXMenuPaneTo_p_FXPopup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPopup *)  ((FXMenuPane *) x));
+}
+static void *_p_FXMDIMenuTo_p_FXPopup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPopup *) (FXMenuPane *) ((FXMDIMenu *) x));
+}
+static void *_p_FXScrollPaneTo_p_FXPopup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPopup *) (FXMenuPane *) ((FXScrollPane *) x));
+}
+static void *_p_FXGradientBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShutterItemTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXMenuCheckTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXMenuCaption *)(FXMenuCommand *) ((FXMenuCheck *) x));
+}
+static void *_p_FXMDIChildTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXMDIChild *) x));
+}
+static void *_p_FXTabBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXMDIMenuTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXPopup *)(FXMenuPane *) ((FXMDIMenu *) x));
+}
+static void *_p_FXMatrixTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXCheckButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *) ((FXCheckButton *) x));
+}
+static void *_p_FXMenuButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *) ((FXMenuButton *) x));
+}
+static void *_p_FXRadioButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *) ((FXRadioButton *) x));
+}
+static void *_p_FXToggleButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *) ((FXToggleButton *) x));
+}
+static void *_p_FXTriStateButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *)(FXToggleButton *) ((FXTriStateButton *) x));
+}
+static void *_p_FXMDIDeleteButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *)(FXButton *) ((FXMDIDeleteButton *) x));
+}
+static void *_p_FXMDIRestoreButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *)(FXButton *) ((FXMDIRestoreButton *) x));
+}
+static void *_p_FXMDIMaximizeButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *)(FXButton *) ((FXMDIMaximizeButton *) x));
+}
+static void *_p_FXMDIMinimizeButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *)(FXButton *) ((FXMDIMinimizeButton *) x));
+}
+static void *_p_FXMDIWindowButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *)(FXMenuButton *) ((FXMDIWindowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXPickerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *)(FXButton *) ((FXPicker *) x));
+}
+static void *_p_FXMenuPaneTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXPopup *) ((FXMenuPane *) x));
+}
+static void *_p_FXHeaderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXSplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSpringTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXMenuSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXMenuSeparator *) x));
+}
+static void *_p_FXProgressBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXMDIClientTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXMDIClient *) x));
+}
+static void *_p_FXToolTipTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXDockSiteTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXMenuCascadeTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXMenuCaption *) ((FXMenuCascade *) x));
+}
+static void *_p_FXColorRingTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXCanvasTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXCanvas *) x));
+}
+static void *_p_FXColorWheelTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *) ((FXButton *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXScrollBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXScrollBar *) x));
+}
+static void *_p_FXComboBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXTabItemTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *) ((FXTabItem *) x));
+}
+static void *_p_FXFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStatusBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXKnobTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXMenuCommandTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXMenuCaption *) ((FXMenuCommand *) x));
+}
+static void *_p_FXRulerViewTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXMenuCaptionTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXMenuCaption *) x));
+}
+static void *_p_FXStatusLineTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXMenuTitleTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXMenuCaption *) ((FXMenuTitle *) x));
+}
+static void *_p_FXMenuBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXDockBar *)(FXToolBar *) ((FXMenuBar *) x));
+}
+static void *_p_FXDockBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXMenuRadioTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXMenuCaption *)(FXMenuCommand *) ((FXMenuRadio *) x));
+}
+static void *_p_FXLabelTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXLabel *) x));
+}
+static void *_p_FXShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXOptionTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *) ((FXOption *) x));
+}
+static void *_p_FXOptionMenuTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXLabel *) ((FXOptionMenu *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXToolBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXScrollPaneTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXPopup *)(FXMenuPane *) ((FXScrollPane *) x));
+}
+static void *_p_FXDirBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXDocumentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDocument *) x));
+}
+static void *_p_FXGradientBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXRegistryTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *)(FXSettings *) ((FXRegistry *) x));
+}
+static void *_p_FXHeaderItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXHeaderItem *) x));
+}
+static void *_p_FXShutterItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXMenuCheckTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXMenuCaption *)(FXMenuCommand *) ((FXMenuCheck *) x));
+}
+static void *_p_FXMDIChildTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXMDIChild *) x));
+}
+static void *_p_FXTabBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXIconDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXIconDict *) x));
+}
+static void *_p_FXMDIMenuTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXPopup *)(FXMenuPane *) ((FXMDIMenu *) x));
+}
+static void *_p_FXMatrixTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXFileDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXFileDict *) x));
+}
+static void *_p_FXRecentFilesTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXRecentFiles *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXCheckButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXCheckButton *) x));
+}
+static void *_p_FXMenuButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXMenuButton *) x));
+}
+static void *_p_FXRadioButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXRadioButton *) x));
+}
+static void *_p_FXToggleButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXToggleButton *) x));
+}
+static void *_p_FXTriStateButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *)(FXToggleButton *) ((FXTriStateButton *) x));
+}
+static void *_p_FXMDIDeleteButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *)(FXButton *) ((FXMDIDeleteButton *) x));
+}
+static void *_p_FXMDIRestoreButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *)(FXButton *) ((FXMDIRestoreButton *) x));
+}
+static void *_p_FXMDIMaximizeButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *)(FXButton *) ((FXMDIMaximizeButton *) x));
+}
+static void *_p_FXMDIMinimizeButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *)(FXButton *) ((FXMDIMinimizeButton *) x));
+}
+static void *_p_FXMDIWindowButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *)(FXMenuButton *) ((FXMDIWindowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXPickerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *)(FXButton *) ((FXPicker *) x));
+}
+static void *_p_FXDrawableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXDrawable *) x));
+}
+static void *_p_FXMenuPaneTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXPopup *) ((FXMenuPane *) x));
+}
+static void *_p_FXAppTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXApp *) x));
+}
+static void *_p_FXHeaderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXTranslatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXTranslator *) x));
+}
+static void *_p_FX4SplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FXSpringTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXMenuSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXMenuSeparator *) x));
+}
+static void *_p_FXIdTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXId *) x));
+}
+static void *_p_FXProgressBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXMDIClientTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXMDIClient *) x));
+}
+static void *_p_FXToolTipTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXSettingsTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXSettings *) x));
+}
+static void *_p_FXDockSiteTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXMenuCascadeTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXMenuCaption *) ((FXMenuCascade *) x));
+}
+static void *_p_FXColorRingTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDebugTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDebugTarget *) x));
+}
+static void *_p_FXDataTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDataTarget *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXCanvasTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXListBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXColorWheelTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXButton *) x));
+}
+static void *_p_FXVisualTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXVisual *) x));
+}
+static void *_p_FXScrollBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXFontTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXFont *) x));
+}
+static void *_p_FXComboBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXTabItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXTabItem *) x));
+}
+static void *_p_FXFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStringDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXStringDict *) x));
+}
+static void *_p_FXStatusBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXDelegatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDelegator *) x));
+}
+static void *_p_FXAccelTableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXAccelTable *) x));
+}
+static void *_p_FXCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXKnobTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXMenuCommandTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXMenuCaption *) ((FXMenuCommand *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRulerViewTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXStatusLineTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMenuCaptionTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXMenuCaption *) x));
+}
+static void *_p_FXMenuTitleTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXMenuCaption *) ((FXMenuTitle *) x));
+}
+static void *_p_FXMenuBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *)(FXToolBar *) ((FXMenuBar *) x));
+}
+static void *_p_FXDockBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXMenuRadioTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXMenuCaption *)(FXMenuCommand *) ((FXMenuRadio *) x));
+}
+static void *_p_FXLabelTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXLabel *) x));
+}
+static void *_p_FXDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDict *) x));
+}
+static void *_p_FXShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXOptionTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXOption *) x));
+}
+static void *_p_FXOptionMenuTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXOptionMenu *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXToolBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDirBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXScrollPaneTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXPopup *)(FXMenuPane *) ((FXScrollPane *) x));
+}
+static void *_p_FXPickerTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *) (FXButton *) ((FXPicker *) x));
+}
+static void *_p_FXMDIMinimizeButtonTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *) (FXButton *) ((FXMDIMinimizeButton *) x));
+}
+static void *_p_FXMDIMaximizeButtonTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *) (FXButton *) ((FXMDIMaximizeButton *) x));
+}
+static void *_p_FXMDIRestoreButtonTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *) (FXButton *) ((FXMDIRestoreButton *) x));
+}
+static void *_p_FXMDIDeleteButtonTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *) (FXButton *) ((FXMDIDeleteButton *) x));
+}
+static void *_p_FXTriStateButtonTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *) (FXToggleButton *) ((FXTriStateButton *) x));
+}
+static void *_p_FXToggleButtonTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *)  ((FXToggleButton *) x));
+}
+static void *_p_FXRadioButtonTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *)  ((FXRadioButton *) x));
+}
+static void *_p_FXMenuButtonTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *)  ((FXMenuButton *) x));
+}
+static void *_p_FXCheckButtonTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *)  ((FXCheckButton *) x));
+}
+static void *_p_FXMDIWindowButtonTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *) (FXMenuButton *) ((FXMDIWindowButton *) x));
+}
+static void *_p_FXButtonTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *)  ((FXButton *) x));
+}
+static void *_p_FXTabItemTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *)  ((FXTabItem *) x));
+}
+static void *_p_FXOptionTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *)  ((FXOption *) x));
+}
+static void *_p_FXOptionMenuTo_p_FXLabel(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXLabel *)  ((FXOptionMenu *) x));
+}
+static void *_p_FXGradientBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShutterItemTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXMenuCheckTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXMenuCaption *)(FXMenuCommand *) ((FXMenuCheck *) x));
+}
+static void *_p_FXMDIChildTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXMDIChild *) x));
+}
+static void *_p_FXTabBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXMDIMenuTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXPopup *)(FXMenuPane *) ((FXMDIMenu *) x));
+}
+static void *_p_FXMatrixTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXCheckButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *) ((FXCheckButton *) x));
+}
+static void *_p_FXMenuButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *) ((FXMenuButton *) x));
+}
+static void *_p_FXRadioButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *) ((FXRadioButton *) x));
+}
+static void *_p_FXToggleButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *) ((FXToggleButton *) x));
+}
+static void *_p_FXTriStateButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *)(FXToggleButton *) ((FXTriStateButton *) x));
+}
+static void *_p_FXMDIDeleteButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *)(FXButton *) ((FXMDIDeleteButton *) x));
+}
+static void *_p_FXMDIRestoreButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *)(FXButton *) ((FXMDIRestoreButton *) x));
+}
+static void *_p_FXMDIMaximizeButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *)(FXButton *) ((FXMDIMaximizeButton *) x));
+}
+static void *_p_FXMDIMinimizeButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *)(FXButton *) ((FXMDIMinimizeButton *) x));
+}
+static void *_p_FXMDIWindowButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *)(FXMenuButton *) ((FXMDIWindowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXPickerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *)(FXButton *) ((FXPicker *) x));
+}
+static void *_p_FXMenuPaneTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXPopup *) ((FXMenuPane *) x));
+}
+static void *_p_FXHeaderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXSplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSpringTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXMenuSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXMenuSeparator *) x));
+}
+static void *_p_FXProgressBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXMDIClientTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXMDIClient *) x));
+}
+static void *_p_FXToolTipTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXDockSiteTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXMenuCascadeTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXMenuCaption *) ((FXMenuCascade *) x));
+}
+static void *_p_FXColorRingTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXCanvasTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXColorWheelTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *) ((FXButton *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXScrollBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXComboBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXTabItemTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *) ((FXTabItem *) x));
+}
+static void *_p_FXFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStatusBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXKnobTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXMenuCommandTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXMenuCaption *) ((FXMenuCommand *) x));
+}
+static void *_p_FXRulerViewTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXStatusLineTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *)  ((FXWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXMenuCaptionTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXMenuCaption *) x));
+}
+static void *_p_FXMenuTitleTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXMenuCaption *) ((FXMenuTitle *) x));
+}
+static void *_p_FXMenuBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *)(FXToolBar *) ((FXMenuBar *) x));
+}
+static void *_p_FXDockBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXMenuRadioTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXMenuCaption *)(FXMenuCommand *) ((FXMenuRadio *) x));
+}
+static void *_p_FXLabelTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXLabel *) x));
+}
+static void *_p_FXShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXOptionTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *) ((FXOption *) x));
+}
+static void *_p_FXOptionMenuTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXLabel *) ((FXOptionMenu *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXToolBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXScrollPaneTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXPopup *)(FXMenuPane *) ((FXScrollPane *) x));
+}
+static void *_p_FXDirBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXFileStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXFileStream *) x));
+}
+static void *_p_FXMemoryStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXMemoryStream *) x));
+}
+static void *_p_FXGradientBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShutterItemTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXMenuCheckTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXMenuCaption *)(FXMenuCommand *) ((FXMenuCheck *) x));
+}
+static void *_p_FXMDIChildTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXMDIChild *) x));
+}
+static void *_p_FXTabBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXMDIMenuTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXPopup *)(FXMenuPane *) ((FXMDIMenu *) x));
+}
+static void *_p_FXMatrixTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXCheckButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXCheckButton *) x));
+}
+static void *_p_FXMenuButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXMenuButton *) x));
+}
+static void *_p_FXRadioButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXRadioButton *) x));
+}
+static void *_p_FXToggleButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXToggleButton *) x));
+}
+static void *_p_FXTriStateButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *)(FXToggleButton *) ((FXTriStateButton *) x));
+}
+static void *_p_FXMDIDeleteButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *)(FXButton *) ((FXMDIDeleteButton *) x));
+}
+static void *_p_FXMDIRestoreButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *)(FXButton *) ((FXMDIRestoreButton *) x));
+}
+static void *_p_FXMDIMaximizeButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *)(FXButton *) ((FXMDIMaximizeButton *) x));
+}
+static void *_p_FXMDIMinimizeButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *)(FXButton *) ((FXMDIMinimizeButton *) x));
+}
+static void *_p_FXMDIWindowButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *)(FXMenuButton *) ((FXMDIWindowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXPickerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *)(FXButton *) ((FXPicker *) x));
+}
+static void *_p_FXDrawableTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXDrawable *) x));
+}
+static void *_p_FXMenuPaneTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXPopup *) ((FXMenuPane *) x));
+}
+static void *_p_FXHeaderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXSplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSpringTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXMenuSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXMenuSeparator *) x));
+}
+static void *_p_FXProgressBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXMDIClientTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXMDIClient *) x));
+}
+static void *_p_FXToolTipTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXDockSiteTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXMenuCascadeTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXMenuCaption *) ((FXMenuCascade *) x));
+}
+static void *_p_FXColorRingTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXCanvasTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXColorWheelTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXButton *) x));
+}
+static void *_p_FXVisualTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXVisual *) x));
+}
+static void *_p_FXScrollBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXFontTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXFont *) x));
+}
+static void *_p_FXComboBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXTabItemTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXTabItem *) x));
+}
+static void *_p_FXFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStatusBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXCursor *) x));
+}
+static void *_p_FXKnobTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXMenuCommandTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXMenuCaption *) ((FXMenuCommand *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRulerViewTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXStatusLineTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXMainWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXMenuCaptionTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXMenuCaption *) x));
+}
+static void *_p_FXMenuTitleTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXMenuCaption *) ((FXMenuTitle *) x));
+}
+static void *_p_FXMenuBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *)(FXToolBar *) ((FXMenuBar *) x));
+}
+static void *_p_FXDockBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXMenuRadioTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXMenuCaption *)(FXMenuCommand *) ((FXMenuRadio *) x));
+}
+static void *_p_FXLabelTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXLabel *) x));
+}
+static void *_p_FXShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXOptionTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXOption *) x));
+}
+static void *_p_FXOptionMenuTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXLabel *) ((FXOptionMenu *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXToolBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDirBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXScrollPaneTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXPopup *)(FXMenuPane *) ((FXScrollPane *) x));
+}
+static void *_p_FXOptionTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *) ((FXOption *) x));
+}
+static void *_p_FXTextFieldTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXTextField *) x));
+}
+static void *_p_FXToggleButtonTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *) ((FXToggleButton *) x));
+}
+static void *_p_FXRadioButtonTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *) ((FXRadioButton *) x));
+}
+static void *_p_FXMenuButtonTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *) ((FXMenuButton *) x));
+}
+static void *_p_FXCheckButtonTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *) ((FXCheckButton *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXArrowButton *) x));
+}
+static void *_p_FXTriStateButtonTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *)(FXToggleButton *) ((FXTriStateButton *) x));
+}
+static void *_p_FXMDIDeleteButtonTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *)(FXButton *) ((FXMDIDeleteButton *) x));
+}
+static void *_p_FXMDIRestoreButtonTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *)(FXButton *) ((FXMDIRestoreButton *) x));
+}
+static void *_p_FXMDIMaximizeButtonTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *)(FXButton *) ((FXMDIMaximizeButton *) x));
+}
+static void *_p_FXMDIMinimizeButtonTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *)(FXButton *) ((FXMDIMinimizeButton *) x));
+}
+static void *_p_FXMDIWindowButtonTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *)(FXMenuButton *) ((FXMDIWindowButton *) x));
+}
+static void *_p_FXRulerTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXRuler *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXStatusLineTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXStatusLine *) x));
+}
+static void *_p_FXTabItemTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *) ((FXTabItem *) x));
+}
+static void *_p_FXKnobTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXKnob *) x));
+}
+static void *_p_FXGradientBarTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXGradientBar *) x));
+}
+static void *_p_FXColorWheelTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXColorWheel *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXBitmapFrame *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXDockHandler *) x));
+}
+static void *_p_FXImageFrameTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXImageFrame *) x));
+}
+static void *_p_FXLabelTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXLabel *) x));
+}
+static void *_p_FXPickerTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *)(FXButton *) ((FXPicker *) x));
+}
+static void *_p_FXOptionMenuTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *) ((FXOptionMenu *) x));
+}
+static void *_p_FXProgressBarTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXProgressBar *) x));
+}
+static void *_p_FXDockTitleTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXHeaderTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXHeader *) x));
+}
+static void *_p_FXColorWellTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXColorWell *) x));
+}
+static void *_p_FXDialTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXDial *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXToolBarTab *) x));
+}
+static void *_p_FX7SegmentTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FX7Segment *) x));
+}
+static void *_p_FXRealSliderTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXSlider *) x));
+}
+static void *_p_FXButtonTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXLabel *) ((FXButton *) x));
+}
+static void *_p_FXColorBarTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXColorBar *) x));
+}
+static void *_p_FXColorRingTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXColorRing *) x));
+}
+static void *_p_FXPickerTo_p_FXButton(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXButton *)  ((FXPicker *) x));
+}
+static void *_p_FXMDIDeleteButtonTo_p_FXButton(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXButton *)  ((FXMDIDeleteButton *) x));
+}
+static void *_p_FXMDIRestoreButtonTo_p_FXButton(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXButton *)  ((FXMDIRestoreButton *) x));
+}
+static void *_p_FXMDIMaximizeButtonTo_p_FXButton(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXButton *)  ((FXMDIMaximizeButton *) x));
+}
+static void *_p_FXMDIMinimizeButtonTo_p_FXButton(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXButton *)  ((FXMDIMinimizeButton *) x));
+}
+static swig_type_info _swigt__p_FXBitmap = {"_p_FXBitmap", "FXBitmap *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXButton = {"_p_FXButton", "FXButton *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXPicker = {"_p_FXPicker", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXComposite = {"_p_FXComposite", "FXComposite *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDriveBox = {"_p_FXDriveBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMenuBar = {"_p_FXMenuBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBar = {"_p_FXToolBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolTip = {"_p_FXToolTip", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTabBook = {"_p_FXTabBook", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGroupBox = {"_p_FXGroupBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusBar = {"_p_FXStatusBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollArea = {"_p_FXScrollArea", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollWindow = {"_p_FXScrollWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRootWindow = {"_p_FXRootWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplashWindow = {"_p_FXSplashWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMainWindow = {"_p_FXMainWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTopWindow = {"_p_FXTopWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXComboBox = {"_p_FXComboBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalFrame = {"_p_FXHorizontalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalFrame = {"_p_FXVerticalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FX4Splitter = {"_p_FX4Splitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplitter = {"_p_FXSplitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRealSpinner = {"_p_FXRealSpinner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSpinner = {"_p_FXSpinner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPacker = {"_p_FXPacker", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDirBox = {"_p_FXDirBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSwitcher = {"_p_FXSwitcher", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorSelector = {"_p_FXColorSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFontSelector = {"_p_FXFontSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileSelector = {"_p_FXFileSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDirSelector = {"_p_FXDirSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutter = {"_p_FXShutter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockSite = {"_p_FXDockSite", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRulerView = {"_p_FXRulerView", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTreeListBox = {"_p_FXTreeListBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXListBox = {"_p_FXListBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMatrix = {"_p_FXMatrix", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutterItem = {"_p_FXShutterItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockBar = {"_p_FXDockBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTabBar = {"_p_FXTabBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImageView = {"_p_FXImageView", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSpring = {"_p_FXSpring", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollPane = {"_p_FXScrollPane", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarShell = {"_p_FXToolBarShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDrawable = {"_p_FXDrawable", "FXDrawable *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGradientBar = {"_p_FXGradientBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorBar = {"_p_FXColorBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMenuCheck = {"_p_FXMenuCheck", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTextField = {"_p_FXTextField", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarTab = {"_p_FXToolBarTab", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollCorner = {"_p_FXScrollCorner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXArrowButton = {"_p_FXArrowButton", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCheckButton = {"_p_FXCheckButton", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRadioButton = {"_p_FXRadioButton", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToggleButton = {"_p_FXToggleButton", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTriStateButton = {"_p_FXTriStateButton", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHeader = {"_p_FXHeader", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImageFrame = {"_p_FXImageFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalSeparator = {"_p_FXVerticalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalSeparator = {"_p_FXHorizontalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSeparator = {"_p_FXSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMenuSeparator = {"_p_FXMenuSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXKnob = {"_p_FXKnob", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXProgressBar = {"_p_FXProgressBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXBitmapFrame = {"_p_FXBitmapFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSlider = {"_p_FXSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRealSlider = {"_p_FXRealSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMenuCascade = {"_p_FXMenuCascade", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorRing = {"_p_FXColorRing", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockHandler = {"_p_FXDockHandler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCanvas = {"_p_FXCanvas", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWheel = {"_p_FXColorWheel", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDial = {"_p_FXDial", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarGrip = {"_p_FXToolBarGrip", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollBar = {"_p_FXScrollBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTabItem = {"_p_FXTabItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockTitle = {"_p_FXDockTitle", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FX7Segment = {"_p_FX7Segment", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMenuCommand = {"_p_FXMenuCommand", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusLine = {"_p_FXStatusLine", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMenuCaption = {"_p_FXMenuCaption", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMenuTitle = {"_p_FXMenuTitle", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMenuRadio = {"_p_FXMenuRadio", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXOption = {"_p_FXOption", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXOptionMenu = {"_p_FXOptionMenu", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWell = {"_p_FXColorWell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDragCorner = {"_p_FXDragCorner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRuler = {"_p_FXRuler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFont = {"_p_FXFont", "FXFont *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFrame = {"_p_FXFrame", "FXFrame *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXIcon = {"_p_FXIcon", "FXIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXId = {"_p_FXId", "FXId *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXVisual = {"_p_FXVisual", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCursor = {"_p_FXCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCURCursor = {"_p_FXCURCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGIFCursor = {"_p_FXGIFCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXLabel = {"_p_FXLabel", "FXLabel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMDIChild = {"_p_FXMDIChild", "FXMDIChild *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMDIClient = {"_p_FXMDIClient", "FXMDIClient *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMDIDeleteButton = {"_p_FXMDIDeleteButton", "FXMDIDeleteButton *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMDIMaximizeButton = {"_p_FXMDIMaximizeButton", "FXMDIMaximizeButton *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMDIMenu = {"_p_FXMDIMenu", "FXMDIMenu *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMDIMinimizeButton = {"_p_FXMDIMinimizeButton", "FXMDIMinimizeButton *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMDIRestoreButton = {"_p_FXMDIRestoreButton", "FXMDIRestoreButton *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMDIWindowButton = {"_p_FXMDIWindowButton", "FXMDIWindowButton *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMenuButton = {"_p_FXMenuButton", "FXMenuButton *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMenuPane = {"_p_FXMenuPane", "FXMenuPane *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXObject = {"_p_FXObject", "FXObject *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDocument = {"_p_FXDocument", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRegistry = {"_p_FXRegistry", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHeaderItem = {"_p_FXHeaderItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXIconDict = {"_p_FXIconDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileDict = {"_p_FXFileDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRecentFiles = {"_p_FXRecentFiles", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTranslator = {"_p_FXTranslator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXApp = {"_p_FXApp", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDict = {"_p_FXDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSettings = {"_p_FXSettings", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDataTarget = {"_p_FXDataTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDebugTarget = {"_p_FXDebugTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStringDict = {"_p_FXStringDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDelegator = {"_p_FXDelegator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXAccelTable = {"_p_FXAccelTable", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPopup = {"_p_FXPopup", "FXPopup *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRegion = {"_p_FXRegion", "FXRegion *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXShell = {"_p_FXShell", "FXShell *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXStream = {"_p_FXStream", "FXStream *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFileStream = {"_p_FXFileStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMemoryStream = {"_p_FXMemoryStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXWindow = {"_p_FXWindow", "FXWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_char = {"_p_char", "char *|FXchar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "double *|FXdouble *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_float = {"_p_float", "float *|FXfloat *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "FXint *|int *|FXInputHandle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_long = {"_p_long", "long *|FXTime *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_short = {"_p_short", "short *|FXshort *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "FXuchar *|unsigned char *|FXbool *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "FXwchar *|FXDragType *|unsigned int *|FXuint *|FXColor *|FXSelector *|FXHotKey *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|FXuval *|FXPixel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|FXushort *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_FX4Splitter,
+  &_swigt__p_FX7Segment,
+  &_swigt__p_FXAccelTable,
+  &_swigt__p_FXApp,
+  &_swigt__p_FXArrowButton,
+  &_swigt__p_FXBitmap,
+  &_swigt__p_FXBitmapFrame,
+  &_swigt__p_FXButton,
+  &_swigt__p_FXCURCursor,
+  &_swigt__p_FXCanvas,
+  &_swigt__p_FXCheckButton,
+  &_swigt__p_FXColorBar,
+  &_swigt__p_FXColorRing,
+  &_swigt__p_FXColorSelector,
+  &_swigt__p_FXColorWell,
+  &_swigt__p_FXColorWheel,
+  &_swigt__p_FXComboBox,
+  &_swigt__p_FXComposite,
+  &_swigt__p_FXCursor,
+  &_swigt__p_FXDataTarget,
+  &_swigt__p_FXDebugTarget,
+  &_swigt__p_FXDelegator,
+  &_swigt__p_FXDial,
+  &_swigt__p_FXDict,
+  &_swigt__p_FXDirBox,
+  &_swigt__p_FXDirSelector,
+  &_swigt__p_FXDockBar,
+  &_swigt__p_FXDockHandler,
+  &_swigt__p_FXDockSite,
+  &_swigt__p_FXDockTitle,
+  &_swigt__p_FXDocument,
+  &_swigt__p_FXDragCorner,
+  &_swigt__p_FXDrawable,
+  &_swigt__p_FXDriveBox,
+  &_swigt__p_FXFileDict,
+  &_swigt__p_FXFileSelector,
+  &_swigt__p_FXFileStream,
+  &_swigt__p_FXFont,
+  &_swigt__p_FXFontSelector,
+  &_swigt__p_FXFrame,
+  &_swigt__p_FXGIFCursor,
+  &_swigt__p_FXGradientBar,
+  &_swigt__p_FXGroupBox,
+  &_swigt__p_FXHeader,
+  &_swigt__p_FXHeaderItem,
+  &_swigt__p_FXHorizontalFrame,
+  &_swigt__p_FXHorizontalSeparator,
+  &_swigt__p_FXIcon,
+  &_swigt__p_FXIconDict,
+  &_swigt__p_FXId,
+  &_swigt__p_FXImageFrame,
+  &_swigt__p_FXImageView,
+  &_swigt__p_FXKnob,
+  &_swigt__p_FXLabel,
+  &_swigt__p_FXListBox,
+  &_swigt__p_FXMDIChild,
+  &_swigt__p_FXMDIClient,
+  &_swigt__p_FXMDIDeleteButton,
+  &_swigt__p_FXMDIMaximizeButton,
+  &_swigt__p_FXMDIMenu,
+  &_swigt__p_FXMDIMinimizeButton,
+  &_swigt__p_FXMDIRestoreButton,
+  &_swigt__p_FXMDIWindowButton,
+  &_swigt__p_FXMainWindow,
+  &_swigt__p_FXMatrix,
+  &_swigt__p_FXMemoryStream,
+  &_swigt__p_FXMenuBar,
+  &_swigt__p_FXMenuButton,
+  &_swigt__p_FXMenuCaption,
+  &_swigt__p_FXMenuCascade,
+  &_swigt__p_FXMenuCheck,
+  &_swigt__p_FXMenuCommand,
+  &_swigt__p_FXMenuPane,
+  &_swigt__p_FXMenuRadio,
+  &_swigt__p_FXMenuSeparator,
+  &_swigt__p_FXMenuTitle,
+  &_swigt__p_FXObject,
+  &_swigt__p_FXOption,
+  &_swigt__p_FXOptionMenu,
+  &_swigt__p_FXPacker,
+  &_swigt__p_FXPicker,
+  &_swigt__p_FXPopup,
+  &_swigt__p_FXProgressBar,
+  &_swigt__p_FXRadioButton,
+  &_swigt__p_FXRealSlider,
+  &_swigt__p_FXRealSpinner,
+  &_swigt__p_FXRecentFiles,
+  &_swigt__p_FXRegion,
+  &_swigt__p_FXRegistry,
+  &_swigt__p_FXRootWindow,
+  &_swigt__p_FXRuler,
+  &_swigt__p_FXRulerView,
+  &_swigt__p_FXScrollArea,
+  &_swigt__p_FXScrollBar,
+  &_swigt__p_FXScrollCorner,
+  &_swigt__p_FXScrollPane,
+  &_swigt__p_FXScrollWindow,
+  &_swigt__p_FXSeparator,
+  &_swigt__p_FXSettings,
+  &_swigt__p_FXShell,
+  &_swigt__p_FXShutter,
+  &_swigt__p_FXShutterItem,
+  &_swigt__p_FXSlider,
+  &_swigt__p_FXSpinner,
+  &_swigt__p_FXSplashWindow,
+  &_swigt__p_FXSplitter,
+  &_swigt__p_FXSpring,
+  &_swigt__p_FXStatusBar,
+  &_swigt__p_FXStatusLine,
+  &_swigt__p_FXStream,
+  &_swigt__p_FXStringDict,
+  &_swigt__p_FXSwitcher,
+  &_swigt__p_FXTabBar,
+  &_swigt__p_FXTabBook,
+  &_swigt__p_FXTabItem,
+  &_swigt__p_FXTextField,
+  &_swigt__p_FXToggleButton,
+  &_swigt__p_FXToolBar,
+  &_swigt__p_FXToolBarGrip,
+  &_swigt__p_FXToolBarShell,
+  &_swigt__p_FXToolBarTab,
+  &_swigt__p_FXToolTip,
+  &_swigt__p_FXTopWindow,
+  &_swigt__p_FXTranslator,
+  &_swigt__p_FXTreeListBox,
+  &_swigt__p_FXTriStateButton,
+  &_swigt__p_FXVerticalFrame,
+  &_swigt__p_FXVerticalSeparator,
+  &_swigt__p_FXVisual,
+  &_swigt__p_FXWindow,
+  &_swigt__p_char,
+  &_swigt__p_double,
+  &_swigt__p_float,
+  &_swigt__p_int,
+  &_swigt__p_long,
+  &_swigt__p_short,
+  &_swigt__p_unsigned_char,
+  &_swigt__p_unsigned_int,
+  &_swigt__p_unsigned_long,
+  &_swigt__p_unsigned_short,
+};
+
+static swig_cast_info _swigc__p_FXBitmap[] = {  {&_swigt__p_FXBitmap, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPicker[] = {{&_swigt__p_FXPicker, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXButton[] = {  {&_swigt__p_FXButton, 0, 0, 0},  {&_swigt__p_FXPicker, _p_FXPickerTo_p_FXButton, 0, 0},  {&_swigt__p_FXMDIDeleteButton, _p_FXMDIDeleteButtonTo_p_FXButton, 0, 0},  {&_swigt__p_FXMDIRestoreButton, _p_FXMDIRestoreButtonTo_p_FXButton, 0, 0},  {&_swigt__p_FXMDIMaximizeButton, _p_FXMDIMaximizeButtonTo_p_FXButton, 0, 0},  {&_swigt__p_FXMDIMinimizeButton, _p_FXMDIMinimizeButtonTo_p_FXButton, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDriveBox[] = {{&_swigt__p_FXDriveBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMenuBar[] = {{&_swigt__p_FXMenuBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBar[] = {{&_swigt__p_FXToolBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolTip[] = {{&_swigt__p_FXToolTip, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabBook[] = {{&_swigt__p_FXTabBook, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGroupBox[] = {{&_swigt__p_FXGroupBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusBar[] = {{&_swigt__p_FXStatusBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollArea[] = {{&_swigt__p_FXScrollArea, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollWindow[] = {{&_swigt__p_FXScrollWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRootWindow[] = {{&_swigt__p_FXRootWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplashWindow[] = {{&_swigt__p_FXSplashWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMainWindow[] = {{&_swigt__p_FXMainWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTopWindow[] = {{&_swigt__p_FXTopWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComboBox[] = {{&_swigt__p_FXComboBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalFrame[] = {{&_swigt__p_FXHorizontalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalFrame[] = {{&_swigt__p_FXVerticalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FX4Splitter[] = {{&_swigt__p_FX4Splitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplitter[] = {{&_swigt__p_FXSplitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSpinner[] = {{&_swigt__p_FXRealSpinner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpinner[] = {{&_swigt__p_FXSpinner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPacker[] = {{&_swigt__p_FXPacker, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirBox[] = {{&_swigt__p_FXDirBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSwitcher[] = {{&_swigt__p_FXSwitcher, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorSelector[] = {{&_swigt__p_FXColorSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFontSelector[] = {{&_swigt__p_FXFontSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileSelector[] = {{&_swigt__p_FXFileSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirSelector[] = {{&_swigt__p_FXDirSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutter[] = {{&_swigt__p_FXShutter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockSite[] = {{&_swigt__p_FXDockSite, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRulerView[] = {{&_swigt__p_FXRulerView, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTreeListBox[] = {{&_swigt__p_FXTreeListBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXListBox[] = {{&_swigt__p_FXListBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMatrix[] = {{&_swigt__p_FXMatrix, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutterItem[] = {{&_swigt__p_FXShutterItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockBar[] = {{&_swigt__p_FXDockBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabBar[] = {{&_swigt__p_FXTabBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageView[] = {{&_swigt__p_FXImageView, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpring[] = {{&_swigt__p_FXSpring, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollPane[] = {{&_swigt__p_FXScrollPane, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarShell[] = {{&_swigt__p_FXToolBarShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComposite[] = {  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMDIClient, _p_FXMDIClientTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMenuPane, _p_FXMenuPaneTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMenuBar, _p_FXMenuBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXComposite, 0, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXComposite, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXComposite, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMDIChild, _p_FXMDIChildTo_p_FXComposite, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXComposite, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollPane, _p_FXScrollPaneTo_p_FXComposite, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMDIMenu, _p_FXMDIMenuTo_p_FXComposite, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGradientBar[] = {{&_swigt__p_FXGradientBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorBar[] = {{&_swigt__p_FXColorBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMenuCheck[] = {{&_swigt__p_FXMenuCheck, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTextField[] = {{&_swigt__p_FXTextField, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarTab[] = {{&_swigt__p_FXToolBarTab, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollCorner[] = {{&_swigt__p_FXScrollCorner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXArrowButton[] = {{&_swigt__p_FXArrowButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCheckButton[] = {{&_swigt__p_FXCheckButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRadioButton[] = {{&_swigt__p_FXRadioButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToggleButton[] = {{&_swigt__p_FXToggleButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTriStateButton[] = {{&_swigt__p_FXTriStateButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeader[] = {{&_swigt__p_FXHeader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageFrame[] = {{&_swigt__p_FXImageFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalSeparator[] = {{&_swigt__p_FXVerticalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalSeparator[] = {{&_swigt__p_FXHorizontalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSeparator[] = {{&_swigt__p_FXSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMenuSeparator[] = {{&_swigt__p_FXMenuSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXKnob[] = {{&_swigt__p_FXKnob, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXProgressBar[] = {{&_swigt__p_FXProgressBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBitmapFrame[] = {{&_swigt__p_FXBitmapFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSlider[] = {{&_swigt__p_FXSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSlider[] = {{&_swigt__p_FXRealSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMenuCascade[] = {{&_swigt__p_FXMenuCascade, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorRing[] = {{&_swigt__p_FXColorRing, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockHandler[] = {{&_swigt__p_FXDockHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCanvas[] = {{&_swigt__p_FXCanvas, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWheel[] = {{&_swigt__p_FXColorWheel, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDial[] = {{&_swigt__p_FXDial, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarGrip[] = {{&_swigt__p_FXToolBarGrip, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollBar[] = {{&_swigt__p_FXScrollBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabItem[] = {{&_swigt__p_FXTabItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockTitle[] = {{&_swigt__p_FXDockTitle, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FX7Segment[] = {{&_swigt__p_FX7Segment, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMenuCommand[] = {{&_swigt__p_FXMenuCommand, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusLine[] = {{&_swigt__p_FXStatusLine, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMenuCaption[] = {{&_swigt__p_FXMenuCaption, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMenuTitle[] = {{&_swigt__p_FXMenuTitle, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMenuRadio[] = {{&_swigt__p_FXMenuRadio, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXOption[] = {{&_swigt__p_FXOption, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXOptionMenu[] = {{&_swigt__p_FXOptionMenu, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWell[] = {{&_swigt__p_FXColorWell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDragCorner[] = {{&_swigt__p_FXDragCorner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRuler[] = {{&_swigt__p_FXRuler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDrawable[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMenuCheck, _p_FXMenuCheckTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMDIChild, _p_FXMDIChildTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMDIMenu, _p_FXMDIMenuTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXCheckButton, _p_FXCheckButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMenuButton, _p_FXMenuButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMDIWindowButton, _p_FXMDIWindowButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRadioButton, _p_FXRadioButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToggleButton, _p_FXToggleButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTriStateButton, _p_FXTriStateButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMDIDeleteButton, _p_FXMDIDeleteButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMDIRestoreButton, _p_FXMDIRestoreButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMDIMaximizeButton, _p_FXMDIMaximizeButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMDIMinimizeButton, _p_FXMDIMinimizeButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPicker, _p_FXPickerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDrawable, 0, 0, 0},  {&_swigt__p_FXMenuPane, _p_FXMenuPaneTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMenuSeparator, _p_FXMenuSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMDIClient, _p_FXMDIClientTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMenuCascade, _p_FXMenuCascadeTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXButton, _p_FXButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabItem, _p_FXTabItemTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMenuCommand, _p_FXMenuCommandTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMenuBar, _p_FXMenuBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMenuCaption, _p_FXMenuCaptionTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMenuTitle, _p_FXMenuTitleTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMenuRadio, _p_FXMenuRadioTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXLabel, _p_FXLabelTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXOption, _p_FXOptionTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXOptionMenu, _p_FXOptionMenuTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollPane, _p_FXScrollPaneTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXDrawable, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFont[] = {  {&_swigt__p_FXFont, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFrame[] = {  {&_swigt__p_FXOption, _p_FXOptionTo_p_FXFrame, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXFrame, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXFrame, 0, 0},  {&_swigt__p_FXMDIMinimizeButton, _p_FXMDIMinimizeButtonTo_p_FXFrame, 0, 0},  {&_swigt__p_FXToggleButton, _p_FXToggleButtonTo_p_FXFrame, 0, 0},  {&_swigt__p_FXRadioButton, _p_FXRadioButtonTo_p_FXFrame, 0, 0},  {&_swigt__p_FXMenuButton, _p_FXMenuButtonTo_p_FXFrame, 0, 0},  {&_swigt__p_FXMDIWindowButton, _p_FXMDIWindowButtonTo_p_FXFrame, 0, 0},  {&_swigt__p_FXCheckButton, _p_FXCheckButtonTo_p_FXFrame, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXFrame, 0, 0},  {&_swigt__p_FXTriStateButton, _p_FXTriStateButtonTo_p_FXFrame, 0, 0},  {&_swigt__p_FXMDIDeleteButton, _p_FXMDIDeleteButtonTo_p_FXFrame, 0, 0},  {&_swigt__p_FXMDIRestoreButton, _p_FXMDIRestoreButtonTo_p_FXFrame, 0, 0},  {&_swigt__p_FXMDIMaximizeButton, _p_FXMDIMaximizeButtonTo_p_FXFrame, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXFrame, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXFrame, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXFrame, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXFrame, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXFrame, 0, 0},  {&_swigt__p_FXTabItem, _p_FXTabItemTo_p_FXFrame, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXFrame, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXFrame, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXFrame, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXFrame, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXFrame, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXFrame, 0, 0},  {&_swigt__p_FXLabel, _p_FXLabelTo_p_FXFrame, 0, 0},  {&_swigt__p_FXPicker, _p_FXPickerTo_p_FXFrame, 0, 0},  {&_swigt__p_FXOptionMenu, _p_FXOptionMenuTo_p_FXFrame, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXFrame, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXFrame, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXFrame, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXFrame, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXFrame, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXFrame, 0, 0},  {&_swigt__p_FXFrame, 0, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXFrame, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXFrame, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXFrame, 0, 0},  {&_swigt__p_FXButton, _p_FXButtonTo_p_FXFrame, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXFrame, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXFrame, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIcon[] = {  {&_swigt__p_FXIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVisual[] = {{&_swigt__p_FXVisual, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCursor[] = {{&_swigt__p_FXCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCURCursor[] = {{&_swigt__p_FXCURCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGIFCursor[] = {{&_swigt__p_FXGIFCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXId[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXId, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXId, 0, 0},  {&_swigt__p_FXMenuCheck, _p_FXMenuCheckTo_p_FXId, 0, 0},  {&_swigt__p_FXMDIChild, _p_FXMDIChildTo_p_FXId, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXId, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXId, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXId, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXMDIMenu, _p_FXMDIMenuTo_p_FXId, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXId, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXCheckButton, _p_FXCheckButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXMenuButton, _p_FXMenuButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXMDIWindowButton, _p_FXMDIWindowButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXRadioButton, _p_FXRadioButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXToggleButton, _p_FXToggleButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXTriStateButton, _p_FXTriStateButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXMDIDeleteButton, _p_FXMDIDeleteButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXMDIRestoreButton, _p_FXMDIRestoreButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXMDIMaximizeButton, _p_FXMDIMaximizeButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXMDIMinimizeButton, _p_FXMDIMinimizeButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXPicker, _p_FXPickerTo_p_FXId, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXId, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXId, 0, 0},  {&_swigt__p_FXMenuPane, _p_FXMenuPaneTo_p_FXId, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXId, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXId, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXId, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXId, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXId, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXId, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXId, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXMenuSeparator, _p_FXMenuSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXId, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXId, 0, 0},  {&_swigt__p_FXMDIClient, _p_FXMDIClientTo_p_FXId, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXId, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXId, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXId, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXMenuCascade, _p_FXMenuCascadeTo_p_FXId, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXId, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXId, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXId, 0, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXId, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXId, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXId, 0, 0},  {&_swigt__p_FXButton, _p_FXButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXId, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXId, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXTabItem, _p_FXTabItemTo_p_FXId, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXId, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXId, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXMenuCommand, _p_FXMenuCommandTo_p_FXId, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXId, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXMenuBar, _p_FXMenuBarTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXId, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXMenuCaption, _p_FXMenuCaptionTo_p_FXId, 0, 0},  {&_swigt__p_FXMenuTitle, _p_FXMenuTitleTo_p_FXId, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXId, 0, 0},  {&_swigt__p_FXMenuRadio, _p_FXMenuRadioTo_p_FXId, 0, 0},  {&_swigt__p_FXLabel, _p_FXLabelTo_p_FXId, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXId, 0, 0},  {&_swigt__p_FXOption, _p_FXOptionTo_p_FXId, 0, 0},  {&_swigt__p_FXOptionMenu, _p_FXOptionMenuTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXId, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXId, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXId, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollPane, _p_FXScrollPaneTo_p_FXId, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXId, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXLabel[] = {  {&_swigt__p_FXPicker, _p_FXPickerTo_p_FXLabel, 0, 0},  {&_swigt__p_FXMDIMinimizeButton, _p_FXMDIMinimizeButtonTo_p_FXLabel, 0, 0},  {&_swigt__p_FXMDIMaximizeButton, _p_FXMDIMaximizeButtonTo_p_FXLabel, 0, 0},  {&_swigt__p_FXMDIRestoreButton, _p_FXMDIRestoreButtonTo_p_FXLabel, 0, 0},  {&_swigt__p_FXMDIDeleteButton, _p_FXMDIDeleteButtonTo_p_FXLabel, 0, 0},  {&_swigt__p_FXTriStateButton, _p_FXTriStateButtonTo_p_FXLabel, 0, 0},  {&_swigt__p_FXToggleButton, _p_FXToggleButtonTo_p_FXLabel, 0, 0},  {&_swigt__p_FXRadioButton, _p_FXRadioButtonTo_p_FXLabel, 0, 0},  {&_swigt__p_FXMenuButton, _p_FXMenuButtonTo_p_FXLabel, 0, 0},  {&_swigt__p_FXCheckButton, _p_FXCheckButtonTo_p_FXLabel, 0, 0},  {&_swigt__p_FXMDIWindowButton, _p_FXMDIWindowButtonTo_p_FXLabel, 0, 0},  {&_swigt__p_FXLabel, 0, 0, 0},  {&_swigt__p_FXButton, _p_FXButtonTo_p_FXLabel, 0, 0},  {&_swigt__p_FXTabItem, _p_FXTabItemTo_p_FXLabel, 0, 0},  {&_swigt__p_FXOption, _p_FXOptionTo_p_FXLabel, 0, 0},  {&_swigt__p_FXOptionMenu, _p_FXOptionMenuTo_p_FXLabel, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMDIChild[] = {  {&_swigt__p_FXMDIChild, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMDIClient[] = {  {&_swigt__p_FXMDIClient, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMDIDeleteButton[] = {  {&_swigt__p_FXMDIDeleteButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMDIMaximizeButton[] = {  {&_swigt__p_FXMDIMaximizeButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMDIMenu[] = {  {&_swigt__p_FXMDIMenu, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMDIMinimizeButton[] = {  {&_swigt__p_FXMDIMinimizeButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMDIRestoreButton[] = {  {&_swigt__p_FXMDIRestoreButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMDIWindowButton[] = {  {&_swigt__p_FXMDIWindowButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMenuButton[] = {  {&_swigt__p_FXMenuButton, 0, 0, 0},  {&_swigt__p_FXMDIWindowButton, _p_FXMDIWindowButtonTo_p_FXMenuButton, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMenuPane[] = {  {&_swigt__p_FXMenuPane, 0, 0, 0},  {&_swigt__p_FXMDIMenu, _p_FXMDIMenuTo_p_FXMenuPane, 0, 0},  {&_swigt__p_FXScrollPane, _p_FXScrollPaneTo_p_FXMenuPane, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDocument[] = {{&_swigt__p_FXDocument, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegistry[] = {{&_swigt__p_FXRegistry, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeaderItem[] = {{&_swigt__p_FXHeaderItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIconDict[] = {{&_swigt__p_FXIconDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileDict[] = {{&_swigt__p_FXFileDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRecentFiles[] = {{&_swigt__p_FXRecentFiles, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTranslator[] = {{&_swigt__p_FXTranslator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXApp[] = {{&_swigt__p_FXApp, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDict[] = {{&_swigt__p_FXDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSettings[] = {{&_swigt__p_FXSettings, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDataTarget[] = {{&_swigt__p_FXDataTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDebugTarget[] = {{&_swigt__p_FXDebugTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStringDict[] = {{&_swigt__p_FXStringDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDelegator[] = {{&_swigt__p_FXDelegator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXAccelTable[] = {{&_swigt__p_FXAccelTable, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXObject[] = {  {&_swigt__p_FXDocument, _p_FXDocumentTo_p_FXObject, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXRegistry, _p_FXRegistryTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeaderItem, _p_FXHeaderItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXMenuCheck, _p_FXMenuCheckTo_p_FXObject, 0, 0},  {&_swigt__p_FXMDIChild, _p_FXMDIChildTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXObject, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXObject, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXIconDict, _p_FXIconDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXMDIMenu, _p_FXMDIMenuTo_p_FXObject, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileDict, _p_FXFileDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXRecentFiles, _p_FXRecentFilesTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXObject, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXCheckButton, _p_FXCheckButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXMenuButton, _p_FXMenuButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXMDIWindowButton, _p_FXMDIWindowButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXRadioButton, _p_FXRadioButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXToggleButton, _p_FXToggleButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXTriStateButton, _p_FXTriStateButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXMDIDeleteButton, _p_FXMDIDeleteButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXMDIRestoreButton, _p_FXMDIRestoreButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXMDIMaximizeButton, _p_FXMDIMaximizeButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXMDIMinimizeButton, _p_FXMDIMinimizeButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXPicker, _p_FXPickerTo_p_FXObject, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXObject, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXObject, 0, 0},  {&_swigt__p_FXMenuPane, _p_FXMenuPaneTo_p_FXObject, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXObject, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FXTranslator, _p_FXTranslatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXObject, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXObject, 0, 0},  {&_swigt__p_FXApp, _p_FXAppTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXMenuSeparator, _p_FXMenuSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXObject, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXObject, 0, 0},  {&_swigt__p_FXMDIClient, _p_FXMDIClientTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXObject, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXObject, 0, 0},  {&_swigt__p_FXDict, _p_FXDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXSettings, _p_FXSettingsTo_p_FXObject, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXObject, 0, 0},  {&_swigt__p_FXMenuCascade, _p_FXMenuCascadeTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXObject, 0, 0},  {&_swigt__p_FXDataTarget, _p_FXDataTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDebugTarget, _p_FXDebugTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXObject, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXObject, 0, 0},  {&_swigt__p_FXId, _p_FXIdTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXObject, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXObject, 0, 0},  {&_swigt__p_FXButton, _p_FXButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXObject, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabItem, _p_FXTabItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXObject, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXStringDict, _p_FXStringDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXDelegator, _p_FXDelegatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXAccelTable, _p_FXAccelTableTo_p_FXObject, 0, 0},  {&_swigt__p_FXObject, 0, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXMenuCommand, _p_FXMenuCommandTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXObject, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXMenuBar, _p_FXMenuBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXObject, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXMenuCaption, _p_FXMenuCaptionTo_p_FXObject, 0, 0},  {&_swigt__p_FXMenuTitle, _p_FXMenuTitleTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXMenuRadio, _p_FXMenuRadioTo_p_FXObject, 0, 0},  {&_swigt__p_FXLabel, _p_FXLabelTo_p_FXObject, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXOption, _p_FXOptionTo_p_FXObject, 0, 0},  {&_swigt__p_FXOptionMenu, _p_FXOptionMenuTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXObject, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXObject, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollPane, _p_FXScrollPaneTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXObject, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPopup[] = {  {&_swigt__p_FXPopup, 0, 0, 0},  {&_swigt__p_FXMenuPane, _p_FXMenuPaneTo_p_FXPopup, 0, 0},  {&_swigt__p_FXMDIMenu, _p_FXMDIMenuTo_p_FXPopup, 0, 0},  {&_swigt__p_FXScrollPane, _p_FXScrollPaneTo_p_FXPopup, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegion[] = {  {&_swigt__p_FXRegion, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShell[] = {  {&_swigt__p_FXShell, 0, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXShell, 0, 0},  {&_swigt__p_FXMenuPane, _p_FXMenuPaneTo_p_FXShell, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXShell, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXShell, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXShell, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXShell, 0, 0},  {&_swigt__p_FXMDIMenu, _p_FXMDIMenuTo_p_FXShell, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXShell, 0, 0},  {&_swigt__p_FXScrollPane, _p_FXScrollPaneTo_p_FXShell, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileStream[] = {{&_swigt__p_FXFileStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMemoryStream[] = {{&_swigt__p_FXMemoryStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStream[] = {  {&_swigt__p_FXFileStream, _p_FXFileStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXMemoryStream, _p_FXMemoryStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXWindow[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMenuCheck, _p_FXMenuCheckTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMDIChild, _p_FXMDIChildTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMDIMenu, _p_FXMDIMenuTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXCheckButton, _p_FXCheckButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMenuButton, _p_FXMenuButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMDIWindowButton, _p_FXMDIWindowButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRadioButton, _p_FXRadioButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToggleButton, _p_FXToggleButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTriStateButton, _p_FXTriStateButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMDIDeleteButton, _p_FXMDIDeleteButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMDIRestoreButton, _p_FXMDIRestoreButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMDIMaximizeButton, _p_FXMDIMaximizeButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMDIMinimizeButton, _p_FXMDIMinimizeButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPicker, _p_FXPickerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMenuPane, _p_FXMenuPaneTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXWindow, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMenuSeparator, _p_FXMenuSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXWindow, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMDIClient, _p_FXMDIClientTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXWindow, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXWindow, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXWindow, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMenuCascade, _p_FXMenuCascadeTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXWindow, 0, 0},  {&_swigt__p_FXButton, _p_FXButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTabItem, _p_FXTabItemTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXWindow, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXWindow, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMenuCommand, _p_FXMenuCommandTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXWindow, 0, 0, 0},  {&_swigt__p_FXMenuBar, _p_FXMenuBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMenuCaption, _p_FXMenuCaptionTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMenuTitle, _p_FXMenuTitleTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMenuRadio, _p_FXMenuRadioTo_p_FXWindow, 0, 0},  {&_swigt__p_FXLabel, _p_FXLabelTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXOption, _p_FXOptionTo_p_FXWindow, 0, 0},  {&_swigt__p_FXOptionMenu, _p_FXOptionMenuTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollPane, _p_FXScrollPaneTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXWindow, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
+
+static swig_cast_info *swig_cast_initial[] = {
+  _swigc__p_FX4Splitter,
+  _swigc__p_FX7Segment,
+  _swigc__p_FXAccelTable,
+  _swigc__p_FXApp,
+  _swigc__p_FXArrowButton,
+  _swigc__p_FXBitmap,
+  _swigc__p_FXBitmapFrame,
+  _swigc__p_FXButton,
+  _swigc__p_FXCURCursor,
+  _swigc__p_FXCanvas,
+  _swigc__p_FXCheckButton,
+  _swigc__p_FXColorBar,
+  _swigc__p_FXColorRing,
+  _swigc__p_FXColorSelector,
+  _swigc__p_FXColorWell,
+  _swigc__p_FXColorWheel,
+  _swigc__p_FXComboBox,
+  _swigc__p_FXComposite,
+  _swigc__p_FXCursor,
+  _swigc__p_FXDataTarget,
+  _swigc__p_FXDebugTarget,
+  _swigc__p_FXDelegator,
+  _swigc__p_FXDial,
+  _swigc__p_FXDict,
+  _swigc__p_FXDirBox,
+  _swigc__p_FXDirSelector,
+  _swigc__p_FXDockBar,
+  _swigc__p_FXDockHandler,
+  _swigc__p_FXDockSite,
+  _swigc__p_FXDockTitle,
+  _swigc__p_FXDocument,
+  _swigc__p_FXDragCorner,
+  _swigc__p_FXDrawable,
+  _swigc__p_FXDriveBox,
+  _swigc__p_FXFileDict,
+  _swigc__p_FXFileSelector,
+  _swigc__p_FXFileStream,
+  _swigc__p_FXFont,
+  _swigc__p_FXFontSelector,
+  _swigc__p_FXFrame,
+  _swigc__p_FXGIFCursor,
+  _swigc__p_FXGradientBar,
+  _swigc__p_FXGroupBox,
+  _swigc__p_FXHeader,
+  _swigc__p_FXHeaderItem,
+  _swigc__p_FXHorizontalFrame,
+  _swigc__p_FXHorizontalSeparator,
+  _swigc__p_FXIcon,
+  _swigc__p_FXIconDict,
+  _swigc__p_FXId,
+  _swigc__p_FXImageFrame,
+  _swigc__p_FXImageView,
+  _swigc__p_FXKnob,
+  _swigc__p_FXLabel,
+  _swigc__p_FXListBox,
+  _swigc__p_FXMDIChild,
+  _swigc__p_FXMDIClient,
+  _swigc__p_FXMDIDeleteButton,
+  _swigc__p_FXMDIMaximizeButton,
+  _swigc__p_FXMDIMenu,
+  _swigc__p_FXMDIMinimizeButton,
+  _swigc__p_FXMDIRestoreButton,
+  _swigc__p_FXMDIWindowButton,
+  _swigc__p_FXMainWindow,
+  _swigc__p_FXMatrix,
+  _swigc__p_FXMemoryStream,
+  _swigc__p_FXMenuBar,
+  _swigc__p_FXMenuButton,
+  _swigc__p_FXMenuCaption,
+  _swigc__p_FXMenuCascade,
+  _swigc__p_FXMenuCheck,
+  _swigc__p_FXMenuCommand,
+  _swigc__p_FXMenuPane,
+  _swigc__p_FXMenuRadio,
+  _swigc__p_FXMenuSeparator,
+  _swigc__p_FXMenuTitle,
+  _swigc__p_FXObject,
+  _swigc__p_FXOption,
+  _swigc__p_FXOptionMenu,
+  _swigc__p_FXPacker,
+  _swigc__p_FXPicker,
+  _swigc__p_FXPopup,
+  _swigc__p_FXProgressBar,
+  _swigc__p_FXRadioButton,
+  _swigc__p_FXRealSlider,
+  _swigc__p_FXRealSpinner,
+  _swigc__p_FXRecentFiles,
+  _swigc__p_FXRegion,
+  _swigc__p_FXRegistry,
+  _swigc__p_FXRootWindow,
+  _swigc__p_FXRuler,
+  _swigc__p_FXRulerView,
+  _swigc__p_FXScrollArea,
+  _swigc__p_FXScrollBar,
+  _swigc__p_FXScrollCorner,
+  _swigc__p_FXScrollPane,
+  _swigc__p_FXScrollWindow,
+  _swigc__p_FXSeparator,
+  _swigc__p_FXSettings,
+  _swigc__p_FXShell,
+  _swigc__p_FXShutter,
+  _swigc__p_FXShutterItem,
+  _swigc__p_FXSlider,
+  _swigc__p_FXSpinner,
+  _swigc__p_FXSplashWindow,
+  _swigc__p_FXSplitter,
+  _swigc__p_FXSpring,
+  _swigc__p_FXStatusBar,
+  _swigc__p_FXStatusLine,
+  _swigc__p_FXStream,
+  _swigc__p_FXStringDict,
+  _swigc__p_FXSwitcher,
+  _swigc__p_FXTabBar,
+  _swigc__p_FXTabBook,
+  _swigc__p_FXTabItem,
+  _swigc__p_FXTextField,
+  _swigc__p_FXToggleButton,
+  _swigc__p_FXToolBar,
+  _swigc__p_FXToolBarGrip,
+  _swigc__p_FXToolBarShell,
+  _swigc__p_FXToolBarTab,
+  _swigc__p_FXToolTip,
+  _swigc__p_FXTopWindow,
+  _swigc__p_FXTranslator,
+  _swigc__p_FXTreeListBox,
+  _swigc__p_FXTriStateButton,
+  _swigc__p_FXVerticalFrame,
+  _swigc__p_FXVerticalSeparator,
+  _swigc__p_FXVisual,
+  _swigc__p_FXWindow,
+  _swigc__p_char,
+  _swigc__p_double,
+  _swigc__p_float,
+  _swigc__p_int,
+  _swigc__p_long,
+  _swigc__p_short,
+  _swigc__p_unsigned_char,
+  _swigc__p_unsigned_int,
+  _swigc__p_unsigned_long,
+  _swigc__p_unsigned_short,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned statically to an initial
+ * array. We just loop through that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded.
+ * There are three cases to handle:
+ *  1) If the cast->type has already been loaded AND the type we are adding
+ *     casting info to has not been loaded (it is in this module), THEN we
+ *     replace the cast->type pointer with the type pointer that has already
+ *     been loaded.
+ *  2) If BOTH types (the one we are adding casting info to, and the
+ *     cast->type) are loaded, THEN the cast info has already been loaded by
+ *     the previous module so we just ignore it.
+ *  3) Finally, if cast->type has not already been loaded, then we add that
+ *     swig_cast_info to the linked list (because the cast->type) pointer will
+ *     be correct.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* c-mode */
+#endif
+#endif
+
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+  size_t i;
+  swig_module_info *module_head, *iter;
+  int init;
+
+  /* check to see if the circular list has been setup, if not, set it up */
+  if (swig_module.next==0) {
+    /* Initialize the swig_module */
+    swig_module.type_initial = swig_type_initial;
+    swig_module.cast_initial = swig_cast_initial;
+    swig_module.next = &swig_module;
+    init = 1;
+  } else {
+    init = 0;
+  }
+
+  /* Try and load any already created modules */
+  module_head = SWIG_GetModule(clientdata);
+  if (!module_head) {
+    /* This is the first module loaded for this interpreter */
+    /* so set the swig module into the interpreter */
+    SWIG_SetModule(clientdata, &swig_module);
+  } else {
+    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+    iter=module_head;
+    do {
+      if (iter==&swig_module) {
+        /* Our module is already in the list, so there's nothing more to do. */
+        return;
+      }
+      iter=iter->next;
+    } while (iter!= module_head);
+
+    /* otherwise we must add our module into the list */
+    swig_module.next = module_head->next;
+    module_head->next = &swig_module;
+  }
+
+  /* When multiple interpreters are used, a module could have already been initialized in
+     a different interpreter, but not yet have a pointer in this interpreter.
+     In this case, we do not want to continue adding types... everything should be
+     set up already */
+  if (init == 0) return;
+
+  /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+  for (i = 0; i < swig_module.size; ++i) {
+    swig_type_info *type = 0;
+    swig_type_info *ret;
+    swig_cast_info *cast;
+
+#ifdef SWIGRUNTIME_DEBUG
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+
+    /* if there is another module already loaded */
+    if (swig_module.next != &swig_module) {
+      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
+    }
+    if (type) {
+      /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+      if (swig_module.type_initial[i]->clientdata) {
+	type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+      }
+    } else {
+      type = swig_module.type_initial[i];
+    }
+
+    /* Insert casting types */
+    cast = swig_module.cast_initial[i];
+    while (cast->type) {
+
+      /* Don't need to add information already in the list */
+      ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+      if (swig_module.next != &swig_module) {
+        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+      }
+      if (ret) {
+	if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+	  cast->type = ret;
+	  ret = 0;
+	} else {
+	  /* Check for casting already in the list */
+	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+	  if (!ocast) ret = 0;
+	}
+      }
+
+      if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+        if (type->cast) {
+          type->cast->prev = cast;
+          cast->next = type->cast;
+        }
+        type->cast = cast;
+      }
+      cast++;
+    }
+    /* Set entry in modules->types array equal to the type */
+    swig_module.types[i] = type;
+  }
+  swig_module.types[i] = 0;
+
+#ifdef SWIGRUNTIME_DEBUG
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+  for (i = 0; i < swig_module.size; ++i) {
+    int j = 0;
+    swig_cast_info *cast = swig_module.cast_initial[i];
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    while (cast->type) {
+      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+      cast++;
+      ++j;
+    }
+  printf("---- Total casts: %d\n",j);
+  }
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types.  It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+  size_t i;
+  swig_cast_info *equiv;
+  static int init_run = 0;
+
+  if (init_run) return;
+  init_run = 1;
+
+  for (i = 0; i < swig_module.size; i++) {
+    if (swig_module.types[i]->clientdata) {
+      equiv = swig_module.types[i]->cast;
+      while (equiv) {
+        if (!equiv->converter) {
+          if (equiv->type && !equiv->type->clientdata)
+            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+        }
+        equiv = equiv->next;
+      }
+    }
+  }
+}
+
+#ifdef __cplusplus
+#if 0
+{ /* c-mode */
+#endif
+}
+#endif
+
+/*
+
+*/
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void Init_mdi(void) {
+  size_t i;
+  
+  SWIG_InitRuntime();
+  
+  
+  SWIG_InitializeModule(0);
+  for (i = 0; i < swig_module.size; i++) {
+    SWIG_define_class(swig_module.types[i]);
+  }
+  
+  SWIG_RubyInitializeTrackings();
+  
+  
+  
+  
+  
+  
+  
+  SwigClassFXMDIDeleteButton.klass = rb_define_class_under(mFox, "FXMDIDeleteButton", ((swig_class *) SWIGTYPE_p_FXButton->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMDIDeleteButton, (void *) &SwigClassFXMDIDeleteButton);
+  rb_define_alloc_func(SwigClassFXMDIDeleteButton.klass, _wrap_FXMDIDeleteButton_allocate);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "initialize", VALUEFUNC(_wrap_new_FXMDIDeleteButton), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "onPaint", VALUEFUNC(_wrap_FXMDIDeleteButton_onPaint), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "save", VALUEFUNC(_wrap_FXMDIDeleteButton_save), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "load", VALUEFUNC(_wrap_FXMDIDeleteButton_load), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "create", VALUEFUNC(_wrap_FXMDIDeleteButton_create), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "detach", VALUEFUNC(_wrap_FXMDIDeleteButton_detach), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "destroy", VALUEFUNC(_wrap_FXMDIDeleteButton_destroy), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "resize", VALUEFUNC(_wrap_FXMDIDeleteButton_resize), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXMDIDeleteButton_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXMDIDeleteButton_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXMDIDeleteButton_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXMDIDeleteButton_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "canFocus", VALUEFUNC(_wrap_FXMDIDeleteButton_canFocus), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "setFocus", VALUEFUNC(_wrap_FXMDIDeleteButton_setFocus), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "killFocus", VALUEFUNC(_wrap_FXMDIDeleteButton_killFocus), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "changeFocus", VALUEFUNC(_wrap_FXMDIDeleteButton_changeFocus), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "setDefault", VALUEFUNC(_wrap_FXMDIDeleteButton_setDefault), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "enable", VALUEFUNC(_wrap_FXMDIDeleteButton_enable), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "disable", VALUEFUNC(_wrap_FXMDIDeleteButton_disable), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "raiseWindow", VALUEFUNC(_wrap_FXMDIDeleteButton_raiseWindow), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "lower", VALUEFUNC(_wrap_FXMDIDeleteButton_lower), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "move", VALUEFUNC(_wrap_FXMDIDeleteButton_move), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "position", VALUEFUNC(_wrap_FXMDIDeleteButton_position), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "layout", VALUEFUNC(_wrap_FXMDIDeleteButton_layout), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "recalc", VALUEFUNC(_wrap_FXMDIDeleteButton_recalc), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "reparent", VALUEFUNC(_wrap_FXMDIDeleteButton_reparent), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "show", VALUEFUNC(_wrap_FXMDIDeleteButton_show), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "hide", VALUEFUNC(_wrap_FXMDIDeleteButton_hide), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "isComposite", VALUEFUNC(_wrap_FXMDIDeleteButton_isComposite), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "contains", VALUEFUNC(_wrap_FXMDIDeleteButton_contains), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXMDIDeleteButton_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "setBackColor", VALUEFUNC(_wrap_FXMDIDeleteButton_setBackColor), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "tr", VALUEFUNC(_wrap_FXMDIDeleteButton_tr), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "dropEnable", VALUEFUNC(_wrap_FXMDIDeleteButton_dropEnable), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "dropDisable", VALUEFUNC(_wrap_FXMDIDeleteButton_dropDisable), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "setShape", VALUEFUNC(_wrap_FXMDIDeleteButton_setShape), -1);
+  rb_define_method(SwigClassFXMDIDeleteButton.klass, "clearShape", VALUEFUNC(_wrap_FXMDIDeleteButton_clearShape), -1);
+  SwigClassFXMDIDeleteButton.mark = (void (*)(void *)) FXRbMDIDeleteButton::markfunc;
+  SwigClassFXMDIDeleteButton.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXMDIDeleteButton.trackObjects = 0;
+  
+  SwigClassFXMDIRestoreButton.klass = rb_define_class_under(mFox, "FXMDIRestoreButton", ((swig_class *) SWIGTYPE_p_FXButton->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMDIRestoreButton, (void *) &SwigClassFXMDIRestoreButton);
+  rb_define_alloc_func(SwigClassFXMDIRestoreButton.klass, _wrap_FXMDIRestoreButton_allocate);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "initialize", VALUEFUNC(_wrap_new_FXMDIRestoreButton), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "onPaint", VALUEFUNC(_wrap_FXMDIRestoreButton_onPaint), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "save", VALUEFUNC(_wrap_FXMDIRestoreButton_save), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "load", VALUEFUNC(_wrap_FXMDIRestoreButton_load), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "create", VALUEFUNC(_wrap_FXMDIRestoreButton_create), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "detach", VALUEFUNC(_wrap_FXMDIRestoreButton_detach), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "destroy", VALUEFUNC(_wrap_FXMDIRestoreButton_destroy), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "resize", VALUEFUNC(_wrap_FXMDIRestoreButton_resize), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXMDIRestoreButton_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXMDIRestoreButton_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXMDIRestoreButton_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXMDIRestoreButton_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "canFocus", VALUEFUNC(_wrap_FXMDIRestoreButton_canFocus), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "setFocus", VALUEFUNC(_wrap_FXMDIRestoreButton_setFocus), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "killFocus", VALUEFUNC(_wrap_FXMDIRestoreButton_killFocus), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "changeFocus", VALUEFUNC(_wrap_FXMDIRestoreButton_changeFocus), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "setDefault", VALUEFUNC(_wrap_FXMDIRestoreButton_setDefault), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "enable", VALUEFUNC(_wrap_FXMDIRestoreButton_enable), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "disable", VALUEFUNC(_wrap_FXMDIRestoreButton_disable), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "raiseWindow", VALUEFUNC(_wrap_FXMDIRestoreButton_raiseWindow), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "lower", VALUEFUNC(_wrap_FXMDIRestoreButton_lower), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "move", VALUEFUNC(_wrap_FXMDIRestoreButton_move), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "position", VALUEFUNC(_wrap_FXMDIRestoreButton_position), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "layout", VALUEFUNC(_wrap_FXMDIRestoreButton_layout), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "recalc", VALUEFUNC(_wrap_FXMDIRestoreButton_recalc), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "reparent", VALUEFUNC(_wrap_FXMDIRestoreButton_reparent), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "show", VALUEFUNC(_wrap_FXMDIRestoreButton_show), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "hide", VALUEFUNC(_wrap_FXMDIRestoreButton_hide), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "isComposite", VALUEFUNC(_wrap_FXMDIRestoreButton_isComposite), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "contains", VALUEFUNC(_wrap_FXMDIRestoreButton_contains), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXMDIRestoreButton_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "setBackColor", VALUEFUNC(_wrap_FXMDIRestoreButton_setBackColor), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "tr", VALUEFUNC(_wrap_FXMDIRestoreButton_tr), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "dropEnable", VALUEFUNC(_wrap_FXMDIRestoreButton_dropEnable), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "dropDisable", VALUEFUNC(_wrap_FXMDIRestoreButton_dropDisable), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "setShape", VALUEFUNC(_wrap_FXMDIRestoreButton_setShape), -1);
+  rb_define_method(SwigClassFXMDIRestoreButton.klass, "clearShape", VALUEFUNC(_wrap_FXMDIRestoreButton_clearShape), -1);
+  SwigClassFXMDIRestoreButton.mark = (void (*)(void *)) FXRbMDIRestoreButton::markfunc;
+  SwigClassFXMDIRestoreButton.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXMDIRestoreButton.trackObjects = 0;
+  
+  SwigClassFXMDIMaximizeButton.klass = rb_define_class_under(mFox, "FXMDIMaximizeButton", ((swig_class *) SWIGTYPE_p_FXButton->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMDIMaximizeButton, (void *) &SwigClassFXMDIMaximizeButton);
+  rb_define_alloc_func(SwigClassFXMDIMaximizeButton.klass, _wrap_FXMDIMaximizeButton_allocate);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "initialize", VALUEFUNC(_wrap_new_FXMDIMaximizeButton), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "onPaint", VALUEFUNC(_wrap_FXMDIMaximizeButton_onPaint), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "save", VALUEFUNC(_wrap_FXMDIMaximizeButton_save), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "load", VALUEFUNC(_wrap_FXMDIMaximizeButton_load), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "create", VALUEFUNC(_wrap_FXMDIMaximizeButton_create), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "detach", VALUEFUNC(_wrap_FXMDIMaximizeButton_detach), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "destroy", VALUEFUNC(_wrap_FXMDIMaximizeButton_destroy), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "resize", VALUEFUNC(_wrap_FXMDIMaximizeButton_resize), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXMDIMaximizeButton_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXMDIMaximizeButton_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXMDIMaximizeButton_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXMDIMaximizeButton_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "canFocus", VALUEFUNC(_wrap_FXMDIMaximizeButton_canFocus), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "setFocus", VALUEFUNC(_wrap_FXMDIMaximizeButton_setFocus), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "killFocus", VALUEFUNC(_wrap_FXMDIMaximizeButton_killFocus), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "changeFocus", VALUEFUNC(_wrap_FXMDIMaximizeButton_changeFocus), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "setDefault", VALUEFUNC(_wrap_FXMDIMaximizeButton_setDefault), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "enable", VALUEFUNC(_wrap_FXMDIMaximizeButton_enable), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "disable", VALUEFUNC(_wrap_FXMDIMaximizeButton_disable), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "raiseWindow", VALUEFUNC(_wrap_FXMDIMaximizeButton_raiseWindow), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "lower", VALUEFUNC(_wrap_FXMDIMaximizeButton_lower), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "move", VALUEFUNC(_wrap_FXMDIMaximizeButton_move), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "position", VALUEFUNC(_wrap_FXMDIMaximizeButton_position), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "layout", VALUEFUNC(_wrap_FXMDIMaximizeButton_layout), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "recalc", VALUEFUNC(_wrap_FXMDIMaximizeButton_recalc), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "reparent", VALUEFUNC(_wrap_FXMDIMaximizeButton_reparent), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "show", VALUEFUNC(_wrap_FXMDIMaximizeButton_show), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "hide", VALUEFUNC(_wrap_FXMDIMaximizeButton_hide), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "isComposite", VALUEFUNC(_wrap_FXMDIMaximizeButton_isComposite), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "contains", VALUEFUNC(_wrap_FXMDIMaximizeButton_contains), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXMDIMaximizeButton_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "setBackColor", VALUEFUNC(_wrap_FXMDIMaximizeButton_setBackColor), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "tr", VALUEFUNC(_wrap_FXMDIMaximizeButton_tr), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "dropEnable", VALUEFUNC(_wrap_FXMDIMaximizeButton_dropEnable), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "dropDisable", VALUEFUNC(_wrap_FXMDIMaximizeButton_dropDisable), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "setShape", VALUEFUNC(_wrap_FXMDIMaximizeButton_setShape), -1);
+  rb_define_method(SwigClassFXMDIMaximizeButton.klass, "clearShape", VALUEFUNC(_wrap_FXMDIMaximizeButton_clearShape), -1);
+  SwigClassFXMDIMaximizeButton.mark = (void (*)(void *)) FXRbMDIMaximizeButton::markfunc;
+  SwigClassFXMDIMaximizeButton.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXMDIMaximizeButton.trackObjects = 0;
+  
+  SwigClassFXMDIMinimizeButton.klass = rb_define_class_under(mFox, "FXMDIMinimizeButton", ((swig_class *) SWIGTYPE_p_FXButton->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMDIMinimizeButton, (void *) &SwigClassFXMDIMinimizeButton);
+  rb_define_alloc_func(SwigClassFXMDIMinimizeButton.klass, _wrap_FXMDIMinimizeButton_allocate);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "initialize", VALUEFUNC(_wrap_new_FXMDIMinimizeButton), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "onPaint", VALUEFUNC(_wrap_FXMDIMinimizeButton_onPaint), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "save", VALUEFUNC(_wrap_FXMDIMinimizeButton_save), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "load", VALUEFUNC(_wrap_FXMDIMinimizeButton_load), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "create", VALUEFUNC(_wrap_FXMDIMinimizeButton_create), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "detach", VALUEFUNC(_wrap_FXMDIMinimizeButton_detach), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "destroy", VALUEFUNC(_wrap_FXMDIMinimizeButton_destroy), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "resize", VALUEFUNC(_wrap_FXMDIMinimizeButton_resize), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXMDIMinimizeButton_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXMDIMinimizeButton_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXMDIMinimizeButton_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXMDIMinimizeButton_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "canFocus", VALUEFUNC(_wrap_FXMDIMinimizeButton_canFocus), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "setFocus", VALUEFUNC(_wrap_FXMDIMinimizeButton_setFocus), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "killFocus", VALUEFUNC(_wrap_FXMDIMinimizeButton_killFocus), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "changeFocus", VALUEFUNC(_wrap_FXMDIMinimizeButton_changeFocus), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "setDefault", VALUEFUNC(_wrap_FXMDIMinimizeButton_setDefault), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "enable", VALUEFUNC(_wrap_FXMDIMinimizeButton_enable), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "disable", VALUEFUNC(_wrap_FXMDIMinimizeButton_disable), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "raiseWindow", VALUEFUNC(_wrap_FXMDIMinimizeButton_raiseWindow), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "lower", VALUEFUNC(_wrap_FXMDIMinimizeButton_lower), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "move", VALUEFUNC(_wrap_FXMDIMinimizeButton_move), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "position", VALUEFUNC(_wrap_FXMDIMinimizeButton_position), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "layout", VALUEFUNC(_wrap_FXMDIMinimizeButton_layout), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "recalc", VALUEFUNC(_wrap_FXMDIMinimizeButton_recalc), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "reparent", VALUEFUNC(_wrap_FXMDIMinimizeButton_reparent), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "show", VALUEFUNC(_wrap_FXMDIMinimizeButton_show), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "hide", VALUEFUNC(_wrap_FXMDIMinimizeButton_hide), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "isComposite", VALUEFUNC(_wrap_FXMDIMinimizeButton_isComposite), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "contains", VALUEFUNC(_wrap_FXMDIMinimizeButton_contains), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXMDIMinimizeButton_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "setBackColor", VALUEFUNC(_wrap_FXMDIMinimizeButton_setBackColor), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "tr", VALUEFUNC(_wrap_FXMDIMinimizeButton_tr), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "dropEnable", VALUEFUNC(_wrap_FXMDIMinimizeButton_dropEnable), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "dropDisable", VALUEFUNC(_wrap_FXMDIMinimizeButton_dropDisable), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "setShape", VALUEFUNC(_wrap_FXMDIMinimizeButton_setShape), -1);
+  rb_define_method(SwigClassFXMDIMinimizeButton.klass, "clearShape", VALUEFUNC(_wrap_FXMDIMinimizeButton_clearShape), -1);
+  SwigClassFXMDIMinimizeButton.mark = (void (*)(void *)) FXRbMDIMinimizeButton::markfunc;
+  SwigClassFXMDIMinimizeButton.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXMDIMinimizeButton.trackObjects = 0;
+  
+  SwigClassFXMDIWindowButton.klass = rb_define_class_under(mFox, "FXMDIWindowButton", ((swig_class *) SWIGTYPE_p_FXMenuButton->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMDIWindowButton, (void *) &SwigClassFXMDIWindowButton);
+  rb_define_alloc_func(SwigClassFXMDIWindowButton.klass, _wrap_FXMDIWindowButton_allocate);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "initialize", VALUEFUNC(_wrap_new_FXMDIWindowButton), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "onPaint", VALUEFUNC(_wrap_FXMDIWindowButton_onPaint), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "save", VALUEFUNC(_wrap_FXMDIWindowButton_save), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "load", VALUEFUNC(_wrap_FXMDIWindowButton_load), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "create", VALUEFUNC(_wrap_FXMDIWindowButton_create), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "detach", VALUEFUNC(_wrap_FXMDIWindowButton_detach), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "destroy", VALUEFUNC(_wrap_FXMDIWindowButton_destroy), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "resize", VALUEFUNC(_wrap_FXMDIWindowButton_resize), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXMDIWindowButton_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXMDIWindowButton_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXMDIWindowButton_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXMDIWindowButton_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "canFocus", VALUEFUNC(_wrap_FXMDIWindowButton_canFocus), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "setFocus", VALUEFUNC(_wrap_FXMDIWindowButton_setFocus), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "killFocus", VALUEFUNC(_wrap_FXMDIWindowButton_killFocus), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "changeFocus", VALUEFUNC(_wrap_FXMDIWindowButton_changeFocus), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "setDefault", VALUEFUNC(_wrap_FXMDIWindowButton_setDefault), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "enable", VALUEFUNC(_wrap_FXMDIWindowButton_enable), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "disable", VALUEFUNC(_wrap_FXMDIWindowButton_disable), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "raiseWindow", VALUEFUNC(_wrap_FXMDIWindowButton_raiseWindow), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "lower", VALUEFUNC(_wrap_FXMDIWindowButton_lower), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "move", VALUEFUNC(_wrap_FXMDIWindowButton_move), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "position", VALUEFUNC(_wrap_FXMDIWindowButton_position), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "layout", VALUEFUNC(_wrap_FXMDIWindowButton_layout), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "recalc", VALUEFUNC(_wrap_FXMDIWindowButton_recalc), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "reparent", VALUEFUNC(_wrap_FXMDIWindowButton_reparent), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "show", VALUEFUNC(_wrap_FXMDIWindowButton_show), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "hide", VALUEFUNC(_wrap_FXMDIWindowButton_hide), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "isComposite", VALUEFUNC(_wrap_FXMDIWindowButton_isComposite), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "contains", VALUEFUNC(_wrap_FXMDIWindowButton_contains), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXMDIWindowButton_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "setBackColor", VALUEFUNC(_wrap_FXMDIWindowButton_setBackColor), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "tr", VALUEFUNC(_wrap_FXMDIWindowButton_tr), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "dropEnable", VALUEFUNC(_wrap_FXMDIWindowButton_dropEnable), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "dropDisable", VALUEFUNC(_wrap_FXMDIWindowButton_dropDisable), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "setShape", VALUEFUNC(_wrap_FXMDIWindowButton_setShape), -1);
+  rb_define_method(SwigClassFXMDIWindowButton.klass, "clearShape", VALUEFUNC(_wrap_FXMDIWindowButton_clearShape), -1);
+  SwigClassFXMDIWindowButton.mark = (void (*)(void *)) FXRbMDIWindowButton::markfunc;
+  SwigClassFXMDIWindowButton.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXMDIWindowButton.trackObjects = 0;
+  
+  SwigClassFXMDIMenu.klass = rb_define_class_under(mFox, "FXMDIMenu", ((swig_class *) SWIGTYPE_p_FXMenuPane->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMDIMenu, (void *) &SwigClassFXMDIMenu);
+  rb_define_alloc_func(SwigClassFXMDIMenu.klass, _wrap_FXMDIMenu_allocate);
+  rb_define_method(SwigClassFXMDIMenu.klass, "initialize", VALUEFUNC(_wrap_new_FXMDIMenu), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "save", VALUEFUNC(_wrap_FXMDIMenu_save), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "load", VALUEFUNC(_wrap_FXMDIMenu_load), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "create", VALUEFUNC(_wrap_FXMDIMenu_create), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "detach", VALUEFUNC(_wrap_FXMDIMenu_detach), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "destroy", VALUEFUNC(_wrap_FXMDIMenu_destroy), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "resize", VALUEFUNC(_wrap_FXMDIMenu_resize), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXMDIMenu_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXMDIMenu_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXMDIMenu_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXMDIMenu_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "canFocus", VALUEFUNC(_wrap_FXMDIMenu_canFocus), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "setFocus", VALUEFUNC(_wrap_FXMDIMenu_setFocus), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "killFocus", VALUEFUNC(_wrap_FXMDIMenu_killFocus), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "changeFocus", VALUEFUNC(_wrap_FXMDIMenu_changeFocus), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "setDefault", VALUEFUNC(_wrap_FXMDIMenu_setDefault), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "enable", VALUEFUNC(_wrap_FXMDIMenu_enable), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "disable", VALUEFUNC(_wrap_FXMDIMenu_disable), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "raiseWindow", VALUEFUNC(_wrap_FXMDIMenu_raiseWindow), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "lower", VALUEFUNC(_wrap_FXMDIMenu_lower), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "move", VALUEFUNC(_wrap_FXMDIMenu_move), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "position", VALUEFUNC(_wrap_FXMDIMenu_position), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "layout", VALUEFUNC(_wrap_FXMDIMenu_layout), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "recalc", VALUEFUNC(_wrap_FXMDIMenu_recalc), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "reparent", VALUEFUNC(_wrap_FXMDIMenu_reparent), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "show", VALUEFUNC(_wrap_FXMDIMenu_show), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "hide", VALUEFUNC(_wrap_FXMDIMenu_hide), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "isComposite", VALUEFUNC(_wrap_FXMDIMenu_isComposite), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "contains", VALUEFUNC(_wrap_FXMDIMenu_contains), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXMDIMenu_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "setBackColor", VALUEFUNC(_wrap_FXMDIMenu_setBackColor), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "tr", VALUEFUNC(_wrap_FXMDIMenu_tr), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "dropEnable", VALUEFUNC(_wrap_FXMDIMenu_dropEnable), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "dropDisable", VALUEFUNC(_wrap_FXMDIMenu_dropDisable), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "setShape", VALUEFUNC(_wrap_FXMDIMenu_setShape), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "clearShape", VALUEFUNC(_wrap_FXMDIMenu_clearShape), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "popup", VALUEFUNC(_wrap_FXMDIMenu_popup), -1);
+  rb_define_method(SwigClassFXMDIMenu.klass, "popdown", VALUEFUNC(_wrap_FXMDIMenu_popdown), -1);
+  SwigClassFXMDIMenu.mark = (void (*)(void *)) FXRbMDIMenu::markfunc;
+  SwigClassFXMDIMenu.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXMDIMenu.trackObjects = 0;
+  
+  SwigClassFXMDIClient.klass = rb_define_class_under(mFox, "FXMDIClient", ((swig_class *) SWIGTYPE_p_FXComposite->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMDIClient, (void *) &SwigClassFXMDIClient);
+  rb_define_alloc_func(SwigClassFXMDIClient.klass, _wrap_FXMDIClient_allocate);
+  rb_define_method(SwigClassFXMDIClient.klass, "initialize", VALUEFUNC(_wrap_new_FXMDIClient), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "onCmdActivateNext", VALUEFUNC(_wrap_FXMDIClient_onCmdActivateNext), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "onCmdActivatePrev", VALUEFUNC(_wrap_FXMDIClient_onCmdActivatePrev), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "onCmdTileHorizontal", VALUEFUNC(_wrap_FXMDIClient_onCmdTileHorizontal), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "onCmdTileVertical", VALUEFUNC(_wrap_FXMDIClient_onCmdTileVertical), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "onCmdCascade", VALUEFUNC(_wrap_FXMDIClient_onCmdCascade), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "onUpdActivateNext", VALUEFUNC(_wrap_FXMDIClient_onUpdActivateNext), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "onUpdActivatePrev", VALUEFUNC(_wrap_FXMDIClient_onUpdActivatePrev), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "onUpdTileVertical", VALUEFUNC(_wrap_FXMDIClient_onUpdTileVertical), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "onUpdTileHorizontal", VALUEFUNC(_wrap_FXMDIClient_onUpdTileHorizontal), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "onUpdCascade", VALUEFUNC(_wrap_FXMDIClient_onUpdCascade), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "onUpdClose", VALUEFUNC(_wrap_FXMDIClient_onUpdClose), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "onUpdMenuClose", VALUEFUNC(_wrap_FXMDIClient_onUpdMenuClose), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "onUpdRestore", VALUEFUNC(_wrap_FXMDIClient_onUpdRestore), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "onUpdMenuRestore", VALUEFUNC(_wrap_FXMDIClient_onUpdMenuRestore), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "onUpdMinimize", VALUEFUNC(_wrap_FXMDIClient_onUpdMinimize), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "onUpdMenuMinimize", VALUEFUNC(_wrap_FXMDIClient_onUpdMenuMinimize), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "onUpdMaximize", VALUEFUNC(_wrap_FXMDIClient_onUpdMaximize), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "onUpdMenuWindow", VALUEFUNC(_wrap_FXMDIClient_onUpdMenuWindow), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "onCmdWindowSelect", VALUEFUNC(_wrap_FXMDIClient_onCmdWindowSelect), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "onUpdWindowSelect", VALUEFUNC(_wrap_FXMDIClient_onUpdWindowSelect), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "onCmdOthersWindows", VALUEFUNC(_wrap_FXMDIClient_onCmdOthersWindows), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "onUpdOthersWindows", VALUEFUNC(_wrap_FXMDIClient_onUpdOthersWindows), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "onUpdAnyWindows", VALUEFUNC(_wrap_FXMDIClient_onUpdAnyWindows), -1);
+  rb_define_const(SwigClassFXMDIClient.klass, "ID_MDI_ANY", SWIG_From_int(static_cast< int >(FXMDIClient::ID_MDI_ANY)));
+  rb_define_const(SwigClassFXMDIClient.klass, "ID_MDI_1", SWIG_From_int(static_cast< int >(FXMDIClient::ID_MDI_1)));
+  rb_define_const(SwigClassFXMDIClient.klass, "ID_MDI_2", SWIG_From_int(static_cast< int >(FXMDIClient::ID_MDI_2)));
+  rb_define_const(SwigClassFXMDIClient.klass, "ID_MDI_3", SWIG_From_int(static_cast< int >(FXMDIClient::ID_MDI_3)));
+  rb_define_const(SwigClassFXMDIClient.klass, "ID_MDI_4", SWIG_From_int(static_cast< int >(FXMDIClient::ID_MDI_4)));
+  rb_define_const(SwigClassFXMDIClient.klass, "ID_MDI_5", SWIG_From_int(static_cast< int >(FXMDIClient::ID_MDI_5)));
+  rb_define_const(SwigClassFXMDIClient.klass, "ID_MDI_6", SWIG_From_int(static_cast< int >(FXMDIClient::ID_MDI_6)));
+  rb_define_const(SwigClassFXMDIClient.klass, "ID_MDI_7", SWIG_From_int(static_cast< int >(FXMDIClient::ID_MDI_7)));
+  rb_define_const(SwigClassFXMDIClient.klass, "ID_MDI_8", SWIG_From_int(static_cast< int >(FXMDIClient::ID_MDI_8)));
+  rb_define_const(SwigClassFXMDIClient.klass, "ID_MDI_9", SWIG_From_int(static_cast< int >(FXMDIClient::ID_MDI_9)));
+  rb_define_const(SwigClassFXMDIClient.klass, "ID_MDI_10", SWIG_From_int(static_cast< int >(FXMDIClient::ID_MDI_10)));
+  rb_define_const(SwigClassFXMDIClient.klass, "ID_MDI_OVER_1", SWIG_From_int(static_cast< int >(FXMDIClient::ID_MDI_OVER_1)));
+  rb_define_const(SwigClassFXMDIClient.klass, "ID_MDI_OVER_2", SWIG_From_int(static_cast< int >(FXMDIClient::ID_MDI_OVER_2)));
+  rb_define_const(SwigClassFXMDIClient.klass, "ID_MDI_OVER_3", SWIG_From_int(static_cast< int >(FXMDIClient::ID_MDI_OVER_3)));
+  rb_define_const(SwigClassFXMDIClient.klass, "ID_MDI_OVER_4", SWIG_From_int(static_cast< int >(FXMDIClient::ID_MDI_OVER_4)));
+  rb_define_const(SwigClassFXMDIClient.klass, "ID_MDI_OVER_5", SWIG_From_int(static_cast< int >(FXMDIClient::ID_MDI_OVER_5)));
+  rb_define_const(SwigClassFXMDIClient.klass, "ID_MDI_OVER_6", SWIG_From_int(static_cast< int >(FXMDIClient::ID_MDI_OVER_6)));
+  rb_define_const(SwigClassFXMDIClient.klass, "ID_MDI_OVER_7", SWIG_From_int(static_cast< int >(FXMDIClient::ID_MDI_OVER_7)));
+  rb_define_const(SwigClassFXMDIClient.klass, "ID_MDI_OVER_8", SWIG_From_int(static_cast< int >(FXMDIClient::ID_MDI_OVER_8)));
+  rb_define_const(SwigClassFXMDIClient.klass, "ID_MDI_OVER_9", SWIG_From_int(static_cast< int >(FXMDIClient::ID_MDI_OVER_9)));
+  rb_define_const(SwigClassFXMDIClient.klass, "ID_MDI_OVER_10", SWIG_From_int(static_cast< int >(FXMDIClient::ID_MDI_OVER_10)));
+  rb_define_const(SwigClassFXMDIClient.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXMDIClient::ID_LAST)));
+  rb_define_method(SwigClassFXMDIClient.klass, "forallWindows", VALUEFUNC(_wrap_FXMDIClient_forallWindows), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "forallDocuments", VALUEFUNC(_wrap_FXMDIClient_forallDocuments), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "forallDocWindows", VALUEFUNC(_wrap_FXMDIClient_forallDocWindows), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "getActiveChild", VALUEFUNC(_wrap_FXMDIClient_getActiveChild), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "setCascadeX", VALUEFUNC(_wrap_FXMDIClient_setCascadeX), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "setCascadeY", VALUEFUNC(_wrap_FXMDIClient_setCascadeY), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "getCascadeX", VALUEFUNC(_wrap_FXMDIClient_getCascadeX), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "getCascadeY", VALUEFUNC(_wrap_FXMDIClient_getCascadeY), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "save", VALUEFUNC(_wrap_FXMDIClient_save), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "load", VALUEFUNC(_wrap_FXMDIClient_load), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "create", VALUEFUNC(_wrap_FXMDIClient_create), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "detach", VALUEFUNC(_wrap_FXMDIClient_detach), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "destroy", VALUEFUNC(_wrap_FXMDIClient_destroy), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "resize", VALUEFUNC(_wrap_FXMDIClient_resize), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXMDIClient_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXMDIClient_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXMDIClient_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXMDIClient_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "canFocus", VALUEFUNC(_wrap_FXMDIClient_canFocus), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "setFocus", VALUEFUNC(_wrap_FXMDIClient_setFocus), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "killFocus", VALUEFUNC(_wrap_FXMDIClient_killFocus), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "changeFocus", VALUEFUNC(_wrap_FXMDIClient_changeFocus), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "setDefault", VALUEFUNC(_wrap_FXMDIClient_setDefault), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "enable", VALUEFUNC(_wrap_FXMDIClient_enable), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "disable", VALUEFUNC(_wrap_FXMDIClient_disable), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "raiseWindow", VALUEFUNC(_wrap_FXMDIClient_raiseWindow), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "lower", VALUEFUNC(_wrap_FXMDIClient_lower), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "move", VALUEFUNC(_wrap_FXMDIClient_move), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "position", VALUEFUNC(_wrap_FXMDIClient_position), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "layout", VALUEFUNC(_wrap_FXMDIClient_layout), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "recalc", VALUEFUNC(_wrap_FXMDIClient_recalc), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "reparent", VALUEFUNC(_wrap_FXMDIClient_reparent), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "show", VALUEFUNC(_wrap_FXMDIClient_show), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "hide", VALUEFUNC(_wrap_FXMDIClient_hide), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "isComposite", VALUEFUNC(_wrap_FXMDIClient_isComposite), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "contains", VALUEFUNC(_wrap_FXMDIClient_contains), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXMDIClient_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "setBackColor", VALUEFUNC(_wrap_FXMDIClient_setBackColor), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "tr", VALUEFUNC(_wrap_FXMDIClient_tr), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "dropEnable", VALUEFUNC(_wrap_FXMDIClient_dropEnable), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "dropDisable", VALUEFUNC(_wrap_FXMDIClient_dropDisable), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "setShape", VALUEFUNC(_wrap_FXMDIClient_setShape), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "clearShape", VALUEFUNC(_wrap_FXMDIClient_clearShape), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "setActiveChild", VALUEFUNC(_wrap_FXMDIClient_setActiveChild), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "cascade", VALUEFUNC(_wrap_FXMDIClient_cascade), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "horizontal", VALUEFUNC(_wrap_FXMDIClient_horizontal), -1);
+  rb_define_method(SwigClassFXMDIClient.klass, "vertical", VALUEFUNC(_wrap_FXMDIClient_vertical), -1);
+  SwigClassFXMDIClient.mark = (void (*)(void *)) FXRbMDIClient::markfunc;
+  SwigClassFXMDIClient.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXMDIClient.trackObjects = 0;
+  rb_define_const(mFox, "MDI_NORMAL", SWIG_From_int(static_cast< int >(MDI_NORMAL)));
+  rb_define_const(mFox, "MDI_MAXIMIZED", SWIG_From_int(static_cast< int >(MDI_MAXIMIZED)));
+  rb_define_const(mFox, "MDI_MINIMIZED", SWIG_From_int(static_cast< int >(MDI_MINIMIZED)));
+  rb_define_const(mFox, "MDI_TRACKING", SWIG_From_int(static_cast< int >(MDI_TRACKING)));
+  
+  SwigClassFXMDIChild.klass = rb_define_class_under(mFox, "FXMDIChild", ((swig_class *) SWIGTYPE_p_FXComposite->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMDIChild, (void *) &SwigClassFXMDIChild);
+  rb_define_alloc_func(SwigClassFXMDIChild.klass, _wrap_FXMDIChild_allocate);
+  rb_define_method(SwigClassFXMDIChild.klass, "initialize", VALUEFUNC(_wrap_new_FXMDIChild), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onPaint", VALUEFUNC(_wrap_FXMDIChild_onPaint), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onFocusSelf", VALUEFUNC(_wrap_FXMDIChild_onFocusSelf), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onFocusIn", VALUEFUNC(_wrap_FXMDIChild_onFocusIn), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onFocusOut", VALUEFUNC(_wrap_FXMDIChild_onFocusOut), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onRightBtnPress", VALUEFUNC(_wrap_FXMDIChild_onRightBtnPress), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onRightBtnRelease", VALUEFUNC(_wrap_FXMDIChild_onRightBtnRelease), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXMDIChild_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXMDIChild_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onMiddleBtnPress", VALUEFUNC(_wrap_FXMDIChild_onMiddleBtnPress), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onMiddleBtnRelease", VALUEFUNC(_wrap_FXMDIChild_onMiddleBtnRelease), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onMotion", VALUEFUNC(_wrap_FXMDIChild_onMotion), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onSelected", VALUEFUNC(_wrap_FXMDIChild_onSelected), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onDeselected", VALUEFUNC(_wrap_FXMDIChild_onDeselected), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onCmdClose", VALUEFUNC(_wrap_FXMDIChild_onCmdClose), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onUpdClose", VALUEFUNC(_wrap_FXMDIChild_onUpdClose), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onCmdRestore", VALUEFUNC(_wrap_FXMDIChild_onCmdRestore), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onUpdRestore", VALUEFUNC(_wrap_FXMDIChild_onUpdRestore), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onUpdMaximize", VALUEFUNC(_wrap_FXMDIChild_onUpdMaximize), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onUpdMinimize", VALUEFUNC(_wrap_FXMDIChild_onUpdMinimize), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onCmdMaximize", VALUEFUNC(_wrap_FXMDIChild_onCmdMaximize), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onCmdMinimize", VALUEFUNC(_wrap_FXMDIChild_onCmdMinimize), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onUpdWindow", VALUEFUNC(_wrap_FXMDIChild_onUpdWindow), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onUpdMenuRestore", VALUEFUNC(_wrap_FXMDIChild_onUpdMenuRestore), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onUpdMenuMinimize", VALUEFUNC(_wrap_FXMDIChild_onUpdMenuMinimize), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onUpdMenuClose", VALUEFUNC(_wrap_FXMDIChild_onUpdMenuClose), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onUpdMenuWindow", VALUEFUNC(_wrap_FXMDIChild_onUpdMenuWindow), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onCmdSetStringValue", VALUEFUNC(_wrap_FXMDIChild_onCmdSetStringValue), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onCmdGetStringValue", VALUEFUNC(_wrap_FXMDIChild_onCmdGetStringValue), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onCmdSetIconValue", VALUEFUNC(_wrap_FXMDIChild_onCmdSetIconValue), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "onCmdGetIconValue", VALUEFUNC(_wrap_FXMDIChild_onCmdGetIconValue), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "setNormalX", VALUEFUNC(_wrap_FXMDIChild_setNormalX), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "setNormalY", VALUEFUNC(_wrap_FXMDIChild_setNormalY), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "setNormalWidth", VALUEFUNC(_wrap_FXMDIChild_setNormalWidth), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "setNormalHeight", VALUEFUNC(_wrap_FXMDIChild_setNormalHeight), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "getNormalX", VALUEFUNC(_wrap_FXMDIChild_getNormalX), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "getNormalY", VALUEFUNC(_wrap_FXMDIChild_getNormalY), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "getNormalWidth", VALUEFUNC(_wrap_FXMDIChild_getNormalWidth), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "getNormalHeight", VALUEFUNC(_wrap_FXMDIChild_getNormalHeight), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "setIconX", VALUEFUNC(_wrap_FXMDIChild_setIconX), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "setIconY", VALUEFUNC(_wrap_FXMDIChild_setIconY), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "setIconWidth", VALUEFUNC(_wrap_FXMDIChild_setIconWidth), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "setIconHeight", VALUEFUNC(_wrap_FXMDIChild_setIconHeight), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "getIconX", VALUEFUNC(_wrap_FXMDIChild_getIconX), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "getIconY", VALUEFUNC(_wrap_FXMDIChild_getIconY), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "getIconWidth", VALUEFUNC(_wrap_FXMDIChild_getIconWidth), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "getIconHeight", VALUEFUNC(_wrap_FXMDIChild_getIconHeight), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "contentWindow", VALUEFUNC(_wrap_FXMDIChild_contentWindow), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "setTitle", VALUEFUNC(_wrap_FXMDIChild_setTitle), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "getTitle", VALUEFUNC(_wrap_FXMDIChild_getTitle), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "getHiliteColor", VALUEFUNC(_wrap_FXMDIChild_getHiliteColor), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "getShadowColor", VALUEFUNC(_wrap_FXMDIChild_getShadowColor), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "getBaseColor", VALUEFUNC(_wrap_FXMDIChild_getBaseColor), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "getBorderColor", VALUEFUNC(_wrap_FXMDIChild_getBorderColor), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "getTitleColor", VALUEFUNC(_wrap_FXMDIChild_getTitleColor), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "getTitleBackColor", VALUEFUNC(_wrap_FXMDIChild_getTitleBackColor), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "setHiliteColor", VALUEFUNC(_wrap_FXMDIChild_setHiliteColor), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "setShadowColor", VALUEFUNC(_wrap_FXMDIChild_setShadowColor), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "setBaseColor", VALUEFUNC(_wrap_FXMDIChild_setBaseColor), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "setBorderColor", VALUEFUNC(_wrap_FXMDIChild_setBorderColor), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "setTitleColor", VALUEFUNC(_wrap_FXMDIChild_setTitleColor), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "setTitleBackColor", VALUEFUNC(_wrap_FXMDIChild_setTitleBackColor), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "isMaximized", VALUEFUNC(_wrap_FXMDIChild_isMaximized), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "isMinimized", VALUEFUNC(_wrap_FXMDIChild_isMinimized), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "getIcon", VALUEFUNC(_wrap_FXMDIChild_getIcon), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "setIcon", VALUEFUNC(_wrap_FXMDIChild_setIcon), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "getMenu", VALUEFUNC(_wrap_FXMDIChild_getMenu), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "setMenu", VALUEFUNC(_wrap_FXMDIChild_setMenu), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "setTracking", VALUEFUNC(_wrap_FXMDIChild_setTracking), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "getTracking", VALUEFUNC(_wrap_FXMDIChild_getTracking), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "setFont", VALUEFUNC(_wrap_FXMDIChild_setFont), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "getFont", VALUEFUNC(_wrap_FXMDIChild_getFont), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "save", VALUEFUNC(_wrap_FXMDIChild_save), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "load", VALUEFUNC(_wrap_FXMDIChild_load), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "create", VALUEFUNC(_wrap_FXMDIChild_create), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "detach", VALUEFUNC(_wrap_FXMDIChild_detach), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "destroy", VALUEFUNC(_wrap_FXMDIChild_destroy), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "resize", VALUEFUNC(_wrap_FXMDIChild_resize), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXMDIChild_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXMDIChild_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXMDIChild_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXMDIChild_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "canFocus", VALUEFUNC(_wrap_FXMDIChild_canFocus), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "setFocus", VALUEFUNC(_wrap_FXMDIChild_setFocus), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "killFocus", VALUEFUNC(_wrap_FXMDIChild_killFocus), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "changeFocus", VALUEFUNC(_wrap_FXMDIChild_changeFocus), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "setDefault", VALUEFUNC(_wrap_FXMDIChild_setDefault), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "enable", VALUEFUNC(_wrap_FXMDIChild_enable), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "disable", VALUEFUNC(_wrap_FXMDIChild_disable), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "raiseWindow", VALUEFUNC(_wrap_FXMDIChild_raiseWindow), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "lower", VALUEFUNC(_wrap_FXMDIChild_lower), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "move", VALUEFUNC(_wrap_FXMDIChild_move), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "position", VALUEFUNC(_wrap_FXMDIChild_position), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "layout", VALUEFUNC(_wrap_FXMDIChild_layout), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "recalc", VALUEFUNC(_wrap_FXMDIChild_recalc), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "reparent", VALUEFUNC(_wrap_FXMDIChild_reparent), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "show", VALUEFUNC(_wrap_FXMDIChild_show), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "hide", VALUEFUNC(_wrap_FXMDIChild_hide), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "isComposite", VALUEFUNC(_wrap_FXMDIChild_isComposite), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "contains", VALUEFUNC(_wrap_FXMDIChild_contains), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXMDIChild_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "setBackColor", VALUEFUNC(_wrap_FXMDIChild_setBackColor), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "tr", VALUEFUNC(_wrap_FXMDIChild_tr), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "dropEnable", VALUEFUNC(_wrap_FXMDIChild_dropEnable), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "dropDisable", VALUEFUNC(_wrap_FXMDIChild_dropDisable), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "setShape", VALUEFUNC(_wrap_FXMDIChild_setShape), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "clearShape", VALUEFUNC(_wrap_FXMDIChild_clearShape), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "minimize", VALUEFUNC(_wrap_FXMDIChild_minimize), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "maximize", VALUEFUNC(_wrap_FXMDIChild_maximize), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "restore", VALUEFUNC(_wrap_FXMDIChild_restore), -1);
+  rb_define_method(SwigClassFXMDIChild.klass, "close", VALUEFUNC(_wrap_FXMDIChild_close), -1);
+  SwigClassFXMDIChild.mark = (void (*)(void *)) FXRbMDIChild::markfunc;
+  SwigClassFXMDIChild.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXMDIChild.trackObjects = 0;
+}
+
diff --git a/ext/fox16_c/menu_wrap.cpp b/ext/fox16_c/menu_wrap.cpp
new file mode 100644
index 00000000..8c84cbda
--- /dev/null
+++ b/ext/fox16_c/menu_wrap.cpp
@@ -0,0 +1,20274 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 3.0.12
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+
+#ifndef SWIGRUBY
+#define SWIGRUBY
+#endif
+
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
+};
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic C API SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "4"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/*  Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN           0x1
+
+
+/*
+   Flags/methods for returning states.
+
+   The SWIG conversion methods, as ConvertPtr, return an integer
+   that tells if the conversion was successful or not. And if not,
+   an error code can be returned (see swigerrors.swg for the codes).
+
+   Use the following macros/flags to set or process the returning
+   states.
+
+   In old versions of SWIG, code such as the following was usually written:
+
+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+       // success code
+     } else {
+       //fail code
+     }
+
+   Now you can be more explicit:
+
+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+    } else {
+      // fail code
+    }
+
+   which is the same really, but now you can also do
+
+    Type *ptr;
+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+      if (SWIG_IsNewObj(res) {
+        ...
+	delete *ptr;
+      } else {
+        ...
+      }
+    } else {
+      // fail code
+    }
+
+   I.e., now SWIG_ConvertPtr can return new objects and you can
+   identify the case and take care of the deallocation. Of course that
+   also requires SWIG_ConvertPtr to return new result values, such as
+
+      int SWIG_ConvertPtr(obj, ptr,...) {
+        if (<obj is ok>) {
+          if (<need new object>) {
+            *ptr = <ptr to new allocated object>;
+            return SWIG_NEWOBJ;
+          } else {
+            *ptr = <ptr to old object>;
+            return SWIG_OLDOBJ;
+          }
+        } else {
+          return SWIG_BADOBJ;
+        }
+      }
+
+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+   SWIG errors code.
+
+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+   allows to return the 'cast rank', for example, if you have this
+
+       int food(double)
+       int fooi(int);
+
+   and you call
+
+      food(1)   // cast rank '1'  (1 -> 1.0)
+      fooi(1)   // cast rank '0'
+
+   just use the SWIG_AddCast()/SWIG_CheckState()
+*/
+
+#define SWIG_OK                    (0)
+#define SWIG_ERROR                 (-1)
+#define SWIG_IsOK(r)               (r >= 0)
+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT         (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ                (SWIG_ERROR)
+#define SWIG_OLDOBJ                (SWIG_OK)
+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+#  ifndef SWIG_TypeRank
+#    define SWIG_TypeRank             unsigned long
+#  endif
+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
+#    define SWIG_MAXCASTRANK          (2)
+#  endif
+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+#  define SWIG_AddCast(r) (r)
+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *, int *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store information on one type */
+typedef struct swig_type_info {
+  const char             *name;			/* mangled name of this type */
+  const char             *str;			/* human readable name of this type */
+  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
+  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
+  void                   *clientdata;		/* language specific type data */
+  int                    owndata;		/* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
+  swig_converter_func     converter;		/* function to cast the void pointers */
+  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
+  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
+  size_t                 size;		        /* Number of types in this module */
+  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
+  swig_type_info         **type_initial;	/* Array of initially generated type structures */
+  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
+  void                    *clientdata;		/* Language specific module data */
+} swig_module_info;
+
+/*
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+  }
+  return (int)((l1 - f1) - (l2 - f2));
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCmp(const char *nb, const char *tb) {
+  int equiv = 1;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (equiv != 0 && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
+}
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
+}
+
+/*
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+  swig_type_info *lastty = ty;
+  if (!ty || !ty->dcast) return ty;
+  while (ty && (ty->dcast)) {
+    ty = (*ty->dcast)(ptr);
+    if (ty) lastty = ty;
+  }
+  return lastty;
+}
+
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+  return ty->name;
+}
+
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (!type) return NULL;
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
+  }
+  else
+    return type->name;
+}
+
+/*
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+  swig_cast_info *cast = ti->cast;
+  /* if (ti->clientdata == clientdata) return; */
+  ti->clientdata = clientdata;
+
+  while (cast) {
+    if (!cast->converter) {
+      swig_type_info *tc = cast->type;
+      if (!tc->clientdata) {
+	SWIG_TypeClientData(tc, clientdata);
+      }
+    }
+    cast = cast->next;
+  }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientData(ti, clientdata);
+  ti->owndata = 1;
+}
+
+/*
+  Search for a swig_type_info structure only by mangled name
+  Search is a O(log #types)
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+                            swig_module_info *end,
+		            const char *name) {
+  swig_module_info *iter = start;
+  do {
+    if (iter->size) {
+      size_t l = 0;
+      size_t r = iter->size - 1;
+      do {
+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
+	size_t i = (l + r) >> 1;
+	const char *iname = iter->types[i]->name;
+	if (iname) {
+	  int compare = strcmp(name, iname);
+	  if (compare == 0) {
+	    return iter->types[i];
+	  } else if (compare < 0) {
+	    if (i) {
+	      r = i - 1;
+	    } else {
+	      break;
+	    }
+	  } else if (compare > 0) {
+	    l = i + 1;
+	  }
+	} else {
+	  break; /* should never happen */
+	}
+      } while (l <= r);
+    }
+    iter = iter->next;
+  } while (iter != end);
+  return 0;
+}
+
+/*
+  Search for a swig_type_info structure for either a mangled name or a human readable name.
+  It first searches the mangled names of the types, which is a O(log #types)
+  If a type is not found it then searches the human readable names, which is O(#types).
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+                     swig_module_info *end,
+		     const char *name) {
+  /* STEP 1: Search the name field using binary search */
+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+  if (ret) {
+    return ret;
+  } else {
+    /* STEP 2: If the type hasn't been found, do a complete search
+       of the str field (the human readable name) */
+    swig_module_info *iter = start;
+    do {
+      size_t i = 0;
+      for (; i < iter->size; ++i) {
+	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+	  return iter->types[i];
+      }
+      iter = iter->next;
+    } while (iter != end);
+  }
+
+  /* neither found a match */
+  return 0;
+}
+
+/*
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+
+/*
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = (unsigned char)((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = (unsigned char)((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (unsigned char)(d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (unsigned char)(d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/*
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/*  Errors in SWIG */
+#define  SWIG_UnknownError    	   -1
+#define  SWIG_IOError        	   -2
+#define  SWIG_RuntimeError   	   -3
+#define  SWIG_IndexError     	   -4
+#define  SWIG_TypeError      	   -5
+#define  SWIG_DivisionByZero 	   -6
+#define  SWIG_OverflowError  	   -7
+#define  SWIG_SyntaxError    	   -8
+#define  SWIG_ValueError     	   -9
+#define  SWIG_SystemError    	   -10
+#define  SWIG_AttributeError 	   -11
+#define  SWIG_MemoryError    	   -12
+#define  SWIG_NullReferenceError   -13
+
+
+
+      #include <ruby.h>
+
+      #if defined(RB_METHOD_DEFINITION_DECL)
+      # define RUBY_VALUE_METHOD_FUNC(func) (func)
+      # define RUBY_INT_METHOD_FUNC(func) (func)
+      # define RUBY_VOID_METHOD_FUNC(func) (func)
+      # define RUBY_VOIDP_METHOD_FUNC(func) (func)
+      #else
+      # define RUBY_VALUE_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
+      # define RUBY_INT_METHOD_FUNC(func) ((int (*)(ANYARGS))(func))
+      # define RUBY_VOID_METHOD_FUNC(func) ((void (*)(ANYARGS))(func))
+      # define RUBY_VOIDP_METHOD_FUNC(func) ((void *(*)(ANYARGS))(func))
+      #endif
+
+
+/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
+ * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
+ * issue for now by disabling this.
+ * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
+ */
+#ifdef rb_intern
+# undef rb_intern
+#endif
+
+/* Remove global macros defined in Ruby's win32.h */
+#ifdef write
+# undef write
+#endif
+#ifdef read
+# undef read
+#endif
+#ifdef bind
+# undef bind
+#endif
+#ifdef close
+# undef close
+#endif
+#ifdef connect
+# undef connect
+#endif
+
+
+/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
+#ifndef NUM2LL
+#define NUM2LL(x) NUM2LONG((x))
+#endif
+#ifndef LL2NUM
+#define LL2NUM(x) INT2NUM((long) (x))
+#endif
+#ifndef ULL2NUM
+#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
+#endif
+
+/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
+#ifndef NUM2ULL
+#ifdef HAVE_LONG_LONG
+#define NUM2ULL(x) rb_num2ull((x))
+#else
+#define NUM2ULL(x) NUM2ULONG(x)
+#endif
+#endif
+
+/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
+/* Define these for older versions so we can just write code the new way */
+#ifndef RSTRING_LEN
+# define RSTRING_LEN(x) RSTRING(x)->len
+#endif
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(x) RSTRING(x)->ptr
+#endif
+#ifndef RSTRING_END
+# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
+#endif
+#ifndef RARRAY_LEN
+# define RARRAY_LEN(x) RARRAY(x)->len
+#endif
+#ifndef RARRAY_PTR
+# define RARRAY_PTR(x) RARRAY(x)->ptr
+#endif
+#ifndef RFLOAT_VALUE
+# define RFLOAT_VALUE(x) RFLOAT(x)->value
+#endif
+#ifndef DOUBLE2NUM
+# define DOUBLE2NUM(x) rb_float_new(x)
+#endif
+#ifndef RHASH_TBL
+# define RHASH_TBL(x) (RHASH(x)->tbl)
+#endif
+#ifndef RHASH_ITER_LEV
+# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
+#endif
+#ifndef RHASH_IFNONE
+# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
+#endif
+#ifndef RHASH_SIZE
+# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
+#endif
+#ifndef RHASH_EMPTY_P
+# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
+#endif
+#ifndef RSTRUCT_LEN
+# define RSTRUCT_LEN(x) RSTRUCT(x)->len
+#endif
+#ifndef RSTRUCT_PTR
+# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
+#endif
+
+
+
+/*
+ * Need to be very careful about how these macros are defined, especially
+ * when compiling C++ code or C code with an ANSI C compiler.
+ *
+ * VALUEFUNC(f) is a macro used to typecast a C function that implements
+ * a Ruby method so that it can be passed as an argument to API functions
+ * like rb_define_method() and rb_define_singleton_method().
+ *
+ * VOIDFUNC(f) is a macro used to typecast a C function that implements
+ * either the "mark" or "free" stuff for a Ruby Data object, so that it
+ * can be passed as an argument to API functions like Data_Wrap_Struct()
+ * and Data_Make_Struct().
+ */
+ 
+#ifdef __cplusplus
+#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
+#    define PROTECTFUNC(f) ((VALUE (*)()) f)
+#    define VALUEFUNC(f) ((VALUE (*)()) f)
+#    define VOIDFUNC(f)  ((void (*)()) f)
+#  else
+#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
+#      define PROTECTFUNC(f) ((VALUE (*)()) f)
+#      define VALUEFUNC(f) ((VALUE (*)()) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    else /* These definitions should work for Ruby 1.7+ */
+#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
+#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    endif
+#  endif
+#else
+#  define VALUEFUNC(f) (f)
+#  define VOIDFUNC(f) (f)
+#endif
+
+/* Don't use for expressions have side effect */
+#ifndef RB_STRING_VALUE
+#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
+#endif
+#ifndef StringValue
+#define StringValue(s) RB_STRING_VALUE(s)
+#endif
+#ifndef StringValuePtr
+#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
+#endif
+#ifndef StringValueLen
+#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
+#endif
+#ifndef SafeStringValue
+#define SafeStringValue(v) do {\
+    StringValue(v);\
+    rb_check_safe_str(v);\
+} while (0)
+#endif
+
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
+#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
+#endif
+
+static VALUE _mSWIG = Qnil;
+
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+
+/* Define some additional error types */
+#define SWIG_ObjectPreviouslyDeletedError  -100
+
+
+/* Define custom exceptions for errors that do not map to existing Ruby
+   exceptions.  Note this only works for C++ since a global cannot be
+   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/
+
+SWIGINTERN VALUE 
+getNullReferenceError(void) {
+  static int init = 0;
+  static VALUE rb_eNullReferenceError ;
+  if (!init) {
+    init = 1;
+    rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
+  }
+  return rb_eNullReferenceError;
+} 
+
+SWIGINTERN VALUE 
+getObjectPreviouslyDeletedError(void) {
+  static int init = 0;
+  static VALUE rb_eObjectPreviouslyDeleted ;
+  if (!init) {
+    init = 1;
+    rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
+  }
+  return rb_eObjectPreviouslyDeleted;
+} 
+
+
+SWIGINTERN VALUE
+SWIG_Ruby_ErrorType(int SWIG_code) {
+  VALUE type;
+  switch (SWIG_code) {
+  case SWIG_MemoryError:
+    type = rb_eNoMemError;
+    break;
+  case SWIG_IOError:
+    type = rb_eIOError;
+    break;
+  case SWIG_RuntimeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_IndexError:
+    type = rb_eIndexError;
+    break;
+  case SWIG_TypeError:
+    type = rb_eTypeError;
+    break;
+  case SWIG_DivisionByZero:
+    type = rb_eZeroDivError;
+    break;
+  case SWIG_OverflowError:
+    type = rb_eRangeError;
+    break;
+  case SWIG_SyntaxError:
+    type = rb_eSyntaxError;
+    break;
+  case SWIG_ValueError:
+    type = rb_eArgError;
+    break;
+  case SWIG_SystemError:
+    type = rb_eFatal;
+    break;
+  case SWIG_AttributeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_NullReferenceError:
+    type = getNullReferenceError();
+    break;
+  case SWIG_ObjectPreviouslyDeletedError:
+    type = getObjectPreviouslyDeletedError();
+    break;
+  case SWIG_UnknownError:
+    type = rb_eRuntimeError;
+    break;
+  default:
+    type = rb_eRuntimeError;
+  }
+  return type;
+}
+
+
+/* This function is called when a user inputs a wrong argument to
+   a method.
+ */
+SWIGINTERN 
+const char* Ruby_Format_TypeError( const char* msg,
+				   const char* type, 
+				   const char* name, 
+				   const int argn,
+				   VALUE input )
+{
+  char buf[128];
+  VALUE str;
+  VALUE asStr;
+  if ( msg && *msg )
+    {
+      str = rb_str_new2(msg);
+    }
+  else
+    {
+      str = rb_str_new(NULL, 0);
+    }
+
+  str = rb_str_cat2( str, "Expected argument " );
+  sprintf( buf, "%d of type ", argn-1 );
+  str = rb_str_cat2( str, buf );
+  str = rb_str_cat2( str, type );
+  str = rb_str_cat2( str, ", but got " );
+  str = rb_str_cat2( str, rb_obj_classname(input) );
+  str = rb_str_cat2( str, " " );
+  asStr = rb_inspect(input);
+  if ( RSTRING_LEN(asStr) > 30 )
+    {
+      str = rb_str_cat( str, StringValuePtr(asStr), 30 );
+      str = rb_str_cat2( str, "..." );
+    }
+  else
+    {
+      str = rb_str_append( str, asStr );
+    }
+
+  if ( name )
+    {
+      str = rb_str_cat2( str, "\n\tin SWIG method '" );
+      str = rb_str_cat2( str, name );
+      str = rb_str_cat2( str, "'" );
+    }
+
+  return StringValuePtr( str );
+}
+
+/* This function is called when an overloaded method fails */
+SWIGINTERN 
+void Ruby_Format_OverloadedError(
+				 const int argc,
+				 const int maxargs,
+				 const char* method, 
+				 const char* prototypes 
+				 )
+{
+  const char* msg = "Wrong # of arguments";
+  if ( argc <= maxargs ) msg = "Wrong arguments";
+  rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
+	   "Possible C/C++ prototypes are:\n%s",
+	   msg, method, prototypes);
+}
+
+/* -----------------------------------------------------------------------------
+ * rubytracking.swg
+ *
+ * This file contains support for tracking mappings from 
+ * Ruby objects to C++ objects.  This functionality is needed
+ * to implement mark functions for Ruby's mark and sweep
+ * garbage collector.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(ST_DATA_T_DEFINED)
+/* Needs to be explicitly included for Ruby 1.8 and earlier */
+#include <st.h>
+#endif
+
+/* Ruby 1.8 actually assumes the first case. */
+#if SIZEOF_VOIDP == SIZEOF_LONG
+#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
+#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
+#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
+#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
+#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
+#else
+#  error sizeof(void*) is not the same as long or long long
+#endif
+
+/* Global hash table to store Trackings from C/C++
+   structs to Ruby Objects. 
+*/
+static st_table* swig_ruby_trackings = NULL;
+
+static VALUE swig_ruby_trackings_count(ID id, VALUE *var) {
+  return SWIG2NUM(swig_ruby_trackings->num_entries);
+}
+
+
+/* Setup a hash table to store Trackings */
+SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
+  /* Create a hash table to store Trackings from C++
+     objects to Ruby objects. */
+
+  /* Try to see if some other .so has already created a 
+     tracking hash table, which we keep hidden in an instance var
+     in the SWIG module.
+     This is done to allow multiple DSOs to share the same
+     tracking table.
+  */
+  VALUE trackings_value = Qnil;
+  /* change the variable name so that we can mix modules
+     compiled with older SWIG's - this used to be called "@__trackings__" */
+  ID trackings_id = rb_intern( "@__safetrackings__" );
+  VALUE verbose = rb_gv_get("VERBOSE");
+  rb_gv_set("VERBOSE", Qfalse);
+  trackings_value = rb_ivar_get( _mSWIG, trackings_id );
+  rb_gv_set("VERBOSE", verbose);
+
+  /* The trick here is that we have to store the hash table
+  pointer in a Ruby variable. We do not want Ruby's GC to
+  treat this pointer as a Ruby object, so we convert it to
+  a Ruby numeric value. */
+  if (trackings_value == Qnil) {
+    /* No, it hasn't.  Create one ourselves */
+    swig_ruby_trackings = st_init_numtable();
+    rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
+  } else {
+    swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
+  }
+
+        rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", RUBY_VALUE_METHOD_FUNC(swig_ruby_trackings_count), RUBY_VOID_METHOD_FUNC((rb_gvar_setter_t*)NULL))
+;
+}
+
+/* Add a Tracking from a C/C++ struct to a Ruby object */
+SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
+  /* Store the mapping to the global hash table. */
+  st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
+}
+
+/* Get the Ruby object that owns the specified C/C++ struct */
+SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
+  /* Now lookup the value stored in the global hash table */
+  VALUE value;
+
+  if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
+    return value;
+  } else {
+    return Qnil;
+  }
+}
+
+/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
+   is very important to remove objects once they are destroyed
+   since the same memory address may be reused later to create
+   a new object. */
+SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
+  /* Delete the object from the hash table */
+  st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
+}
+
+/* This is a helper method that unlinks a Ruby object from its
+   underlying C++ object.  This is needed if the lifetime of the
+   Ruby object is longer than the C++ object */
+SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
+  VALUE object = SWIG_RubyInstanceFor(ptr);
+
+  if (object != Qnil) {
+    if (TYPE(object) != T_DATA)
+      abort();
+    DATA_PTR(object) = 0;
+  }
+}
+
+/* This is a helper method that iterates over all the trackings
+   passing the C++ object pointer and its related Ruby object
+   to the passed callback function. */
+
+/* Proxy method to abstract the internal trackings datatype */
+      static int swig_ruby_internal_iterate_callback(st_data_t ptr, st_data_t obj, st_data_t meth) {
+        ((void(*)(void*, VALUE))meth)((void*)ptr, (VALUE)obj);
+
+  return ST_CONTINUE;
+}
+
+SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
+  st_foreach(swig_ruby_trackings, RUBY_INT_METHOD_FUNC(swig_ruby_internal_iterate_callback), (st_data_t)meth);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Ruby API portion that goes into the runtime
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGINTERN VALUE
+SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
+  if (NIL_P(target)) {
+    target = o;
+  } else {
+    if (TYPE(target) != T_ARRAY) {
+      VALUE o2 = target;
+      target = rb_ary_new();
+      rb_ary_push(target, o2);
+    }
+    rb_ary_push(target, o);
+  }
+  return target;
+}
+
+/* For ruby1.8.4 and earlier. */
+#ifndef RUBY_INIT_STACK
+   RUBY_EXTERN void Init_stack(VALUE* addr);
+#  define RUBY_INIT_STACK \
+   VALUE variable_in_this_stack_frame; \
+   Init_stack(&variable_in_this_stack_frame);
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* -----------------------------------------------------------------------------
+ * rubyrun.swg
+ *
+ * This file contains the runtime support for Ruby modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
+#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
+#define swig_owntype                                    swig_ruby_owntype
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) 		SWIG_Ruby_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
+#define SWIG_Error(code, msg)            		rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
+#define SWIG_fail                        		goto fail				 
+
+
+/* Ruby-specific SWIG API */
+
+#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
+#define SWIG_define_class(ty)                        	SWIG_Ruby_define_class(ty)
+#define SWIG_NewClassInstance(value, ty)             	SWIG_Ruby_NewClassInstance(value, ty)
+#define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
+#define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  
+
+#include "assert.h"
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  VALUE klass;
+  VALUE mImpl;
+  void  (*mark)(void *);
+  void  (*destroy)(void *);
+  int trackObjects;
+} swig_class;
+
+
+/* Global pointer used to keep some internal SWIG stuff */
+static VALUE _cSWIG_Pointer = Qnil;
+static VALUE swig_runtime_data_type_pointer = Qnil;
+
+/* Global IDs used to keep some internal SWIG stuff */
+static ID swig_arity_id = 0;
+static ID swig_call_id  = 0;
+
+/*
+  If your swig extension is to be run within an embedded ruby and has
+  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
+  This will reset ruby's stack frame on each entry point from the main 
+  program the first time a virtual director function is invoked (in a 
+  non-recursive way).
+  If this is not done, you run the risk of Ruby trashing the stack.
+*/
+
+#ifdef RUBY_EMBEDDED
+
+#  define SWIG_INIT_STACK                            \
+      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
+      ++swig_virtual_calls;
+#  define SWIG_RELEASE_STACK --swig_virtual_calls;
+#  define Ruby_DirectorTypeMismatchException(x) \
+          rb_raise( rb_eTypeError, "%s", x ); return c_result;
+
+      static unsigned int swig_virtual_calls = 0;
+
+#else  /* normal non-embedded extension */
+
+#  define SWIG_INIT_STACK
+#  define SWIG_RELEASE_STACK
+#  define Ruby_DirectorTypeMismatchException(x) \
+          throw Swig::DirectorTypeMismatchException( x );
+
+#endif  /* RUBY_EMBEDDED */
+
+
+SWIGRUNTIME VALUE 
+getExceptionClass(void) {
+  static int init = 0;
+  static VALUE rubyExceptionClass ;
+  if (!init) {
+    init = 1;
+    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
+  }
+  return rubyExceptionClass;
+} 
+
+/* This code checks to see if the Ruby object being raised as part
+   of an exception inherits from the Ruby class Exception.  If so,
+   the object is simply returned.  If not, then a new Ruby exception
+   object is created and that will be returned to Ruby.*/
+SWIGRUNTIME VALUE
+SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
+  VALUE exceptionClass = getExceptionClass();
+  if (rb_obj_is_kind_of(obj, exceptionClass)) {
+    return obj;
+  }  else {
+    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
+  }
+}
+
+/* Initialize Ruby runtime support */
+SWIGRUNTIME void
+SWIG_Ruby_InitRuntime(void)
+{
+  if (_mSWIG == Qnil) {
+    _mSWIG = rb_define_module("SWIG");
+    swig_call_id  = rb_intern("call");
+    swig_arity_id = rb_intern("arity");
+  }
+}
+
+/* Define Ruby class for C type */
+SWIGRUNTIME void
+SWIG_Ruby_define_class(swig_type_info *type)
+{
+  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+  sprintf(klass_name, "TYPE%s", type->name);
+  if (NIL_P(_cSWIG_Pointer)) {
+    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
+    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
+  }
+  rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
+  free((void *) klass_name);
+}
+
+/* Create a new pointer object */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
+{
+  int own =  flags & SWIG_POINTER_OWN; 
+  int track;
+  char *klass_name;
+  swig_class *sklass;
+  VALUE klass;
+  VALUE obj;
+  
+  if (!ptr)
+    return Qnil;
+  
+  if (type->clientdata) {
+    sklass = (swig_class *) type->clientdata;
+		
+    /* Are we tracking this class and have we already returned this Ruby object? */
+    track = sklass->trackObjects;
+    if (track) {
+      obj = SWIG_RubyInstanceFor(ptr);
+      
+      /* Check the object's type and make sure it has the correct type.
+        It might not in cases where methods do things like 
+        downcast methods. */
+      if (obj != Qnil) {
+        VALUE value = rb_iv_get(obj, "@__swigtype__");
+        const char* type_name = RSTRING_PTR(value);
+				
+        if (strcmp(type->name, type_name) == 0) {
+          return obj;
+        }
+      }
+    }
+
+    /* Create a new Ruby object */
+    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
+			   ( own ? VOIDFUNC(sklass->destroy) : 
+			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
+			     ), ptr);
+
+    /* If tracking is on for this class then track this object. */
+    if (track) {
+      SWIG_RubyAddTracking(ptr, obj);
+    }
+  } else {
+    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+    sprintf(klass_name, "TYPE%s", type->name);
+    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
+    free((void *) klass_name);
+    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
+  }
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  
+  return obj;
+}
+
+/* Create a new class instance (always owned) */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
+{
+  VALUE obj;
+  swig_class *sklass = (swig_class *) type->clientdata;
+  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  return obj;
+}
+
+/* Get type mangle from class name */
+SWIGRUNTIMEINLINE char *
+SWIG_Ruby_MangleStr(VALUE obj)
+{
+  VALUE stype = rb_iv_get(obj, "@__swigtype__");
+  return StringValuePtr(stype);
+}
+
+/* Acquire a pointer value */
+typedef struct {
+  void (*datafree)(void *);
+  int own;
+} swig_ruby_owntype;
+
+SWIGRUNTIME swig_ruby_owntype
+SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
+  swig_ruby_owntype oldown = {0, 0};
+  if (obj) {
+    oldown.datafree = RDATA(obj)->dfree;
+    RDATA(obj)->dfree = own.datafree;
+  }
+  return oldown;
+}
+
+/* Convert a pointer value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
+{
+  char *c;
+  swig_cast_info *tc;
+  void *vptr = 0;
+
+  /* Grab the pointer */
+  if (NIL_P(obj)) {
+    if (ptr)
+      *ptr = 0;
+    return SWIG_OK;
+  } else {
+    if (TYPE(obj) != T_DATA) {
+      return SWIG_ERROR;
+    }
+    Data_Get_Struct(obj, void, vptr);
+  }
+  
+  if (own) {
+    own->datafree = RDATA(obj)->dfree;
+    own->own = 0;
+  }
+    
+  /* Check to see if the input object is giving up ownership
+     of the underlying C struct or C++ object.  If so then we
+     need to reset the destructor since the Ruby object no 
+     longer owns the underlying C++ object.*/ 
+  if (flags & SWIG_POINTER_DISOWN) {
+    /* Is tracking on for this class? */
+    int track = 0;
+    if (ty && ty->clientdata) {
+      swig_class *sklass = (swig_class *) ty->clientdata;
+      track = sklass->trackObjects;
+    }
+		
+    if (track) {
+      /* We are tracking objects for this class.  Thus we change the destructor
+       * to SWIG_RubyRemoveTracking.  This allows us to
+       * remove the mapping from the C++ to Ruby object
+       * when the Ruby object is garbage collected.  If we don't
+       * do this, then it is possible we will return a reference 
+       * to a Ruby object that no longer exists thereby crashing Ruby. */
+      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
+    } else {    
+      RDATA(obj)->dfree = 0;
+    }
+  }
+
+  /* Do type-checking if type info was provided */
+  if (ty) {
+    if (ty->clientdata) {
+      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
+        if (vptr == 0) {
+          /* The object has already been deleted */
+          return SWIG_ObjectPreviouslyDeletedError;
+        }
+      }
+    }
+    if ((c = SWIG_MangleStr(obj)) == NULL) {
+      return SWIG_ERROR;
+    }
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) {
+      return SWIG_ERROR;
+    } else {
+      if (ptr) {
+        if (tc->type == ty) {
+          *ptr = vptr;
+        } else {
+          int newmemory = 0;
+          *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
+          if (newmemory == SWIG_CAST_NEW_MEMORY) {
+            assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+            if (own)
+              own->own = own->own | SWIG_CAST_NEW_MEMORY;
+          }
+        }
+      }
+    }
+  } else {
+    if (ptr)
+      *ptr = vptr;
+  }
+  
+  return SWIG_OK;
+}
+
+/* Check convert */
+SWIGRUNTIMEINLINE int
+SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
+{
+  char *c = SWIG_MangleStr(obj);
+  if (!c) return 0;
+  return SWIG_TypeCheck(c,ty) != 0;
+}
+
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r, ptr, sz);
+  strcpy(r, type->name);
+  return rb_str_new2(result);
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c;
+
+  if (TYPE(obj) != T_STRING) goto type_error;
+  c = StringValuePtr(obj);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') goto type_error;
+  c++;
+  c = SWIG_UnpackData(c, ptr, sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) goto type_error;
+  }
+  return SWIG_OK;
+
+ type_error:
+  return SWIG_ERROR;
+}
+
+SWIGRUNTIME swig_module_info *
+SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
+{
+  VALUE pointer;
+  swig_module_info *ret = 0;
+  VALUE verbose = rb_gv_get("VERBOSE");
+
+ /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
+  rb_gv_set("VERBOSE", Qfalse);
+  
+  /* first check if pointer already created */
+  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  if (pointer != Qnil) {
+    Data_Get_Struct(pointer, swig_module_info, ret);
+  }
+
+  /* reinstate warnings */
+  rb_gv_set("VERBOSE", verbose);
+  return ret;
+}
+
+SWIGRUNTIME void 
+SWIG_Ruby_SetModule(swig_module_info *pointer)
+{
+  /* register a new class */
+  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
+  /* create and store the structure pointer to a global variable */
+  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
+  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
+}
+
+/* This function can be used to check whether a proc or method or similarly
+   callable function has been passed.  Usually used in a %typecheck, like:
+
+   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
+        $result = SWIG_Ruby_isCallable( $input );
+   }
+ */
+SWIGINTERN
+int SWIG_Ruby_isCallable( VALUE proc )
+{
+  if ( rb_respond_to( proc, swig_call_id ) )
+    return 1;
+  return 0;
+}
+
+/* This function can be used to check the arity (number of arguments)
+   a proc or method can take.  Usually used in a %typecheck.
+   Valid arities will be that equal to minimal or those < 0
+   which indicate a variable number of parameters at the end.
+ */
+SWIGINTERN
+int SWIG_Ruby_arity( VALUE proc, int minimal )
+{
+  if ( rb_respond_to( proc, swig_arity_id ) )
+    {
+      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
+      int arity = NUM2INT(num);
+      if ( arity < 0 && (arity+1) < -minimal ) return 1;
+      if ( arity == minimal ) return 1;
+      return 1;
+    }
+  return 0;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
+
+
+
+  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) 
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_p_FX4Splitter swig_types[0]
+#define SWIGTYPE_p_FX7Segment swig_types[1]
+#define SWIGTYPE_p_FXAccelTable swig_types[2]
+#define SWIGTYPE_p_FXApp swig_types[3]
+#define SWIGTYPE_p_FXArrowButton swig_types[4]
+#define SWIGTYPE_p_FXBitmap swig_types[5]
+#define SWIGTYPE_p_FXBitmapFrame swig_types[6]
+#define SWIGTYPE_p_FXCURCursor swig_types[7]
+#define SWIGTYPE_p_FXCanvas swig_types[8]
+#define SWIGTYPE_p_FXColorBar swig_types[9]
+#define SWIGTYPE_p_FXColorRing swig_types[10]
+#define SWIGTYPE_p_FXColorSelector swig_types[11]
+#define SWIGTYPE_p_FXColorWell swig_types[12]
+#define SWIGTYPE_p_FXColorWheel swig_types[13]
+#define SWIGTYPE_p_FXComboBox swig_types[14]
+#define SWIGTYPE_p_FXComposite swig_types[15]
+#define SWIGTYPE_p_FXCursor swig_types[16]
+#define SWIGTYPE_p_FXDataTarget swig_types[17]
+#define SWIGTYPE_p_FXDebugTarget swig_types[18]
+#define SWIGTYPE_p_FXDelegator swig_types[19]
+#define SWIGTYPE_p_FXDial swig_types[20]
+#define SWIGTYPE_p_FXDict swig_types[21]
+#define SWIGTYPE_p_FXDirBox swig_types[22]
+#define SWIGTYPE_p_FXDirSelector swig_types[23]
+#define SWIGTYPE_p_FXDockBar swig_types[24]
+#define SWIGTYPE_p_FXDockHandler swig_types[25]
+#define SWIGTYPE_p_FXDockSite swig_types[26]
+#define SWIGTYPE_p_FXDockTitle swig_types[27]
+#define SWIGTYPE_p_FXDocument swig_types[28]
+#define SWIGTYPE_p_FXDragCorner swig_types[29]
+#define SWIGTYPE_p_FXDrawable swig_types[30]
+#define SWIGTYPE_p_FXDriveBox swig_types[31]
+#define SWIGTYPE_p_FXFileDict swig_types[32]
+#define SWIGTYPE_p_FXFileSelector swig_types[33]
+#define SWIGTYPE_p_FXFileStream swig_types[34]
+#define SWIGTYPE_p_FXFont swig_types[35]
+#define SWIGTYPE_p_FXFontSelector swig_types[36]
+#define SWIGTYPE_p_FXFrame swig_types[37]
+#define SWIGTYPE_p_FXGIFCursor swig_types[38]
+#define SWIGTYPE_p_FXGradientBar swig_types[39]
+#define SWIGTYPE_p_FXGroupBox swig_types[40]
+#define SWIGTYPE_p_FXHeader swig_types[41]
+#define SWIGTYPE_p_FXHeaderItem swig_types[42]
+#define SWIGTYPE_p_FXHorizontalFrame swig_types[43]
+#define SWIGTYPE_p_FXHorizontalSeparator swig_types[44]
+#define SWIGTYPE_p_FXIcon swig_types[45]
+#define SWIGTYPE_p_FXIconDict swig_types[46]
+#define SWIGTYPE_p_FXId swig_types[47]
+#define SWIGTYPE_p_FXImageFrame swig_types[48]
+#define SWIGTYPE_p_FXImageView swig_types[49]
+#define SWIGTYPE_p_FXKnob swig_types[50]
+#define SWIGTYPE_p_FXListBox swig_types[51]
+#define SWIGTYPE_p_FXMainWindow swig_types[52]
+#define SWIGTYPE_p_FXMatrix swig_types[53]
+#define SWIGTYPE_p_FXMemoryStream swig_types[54]
+#define SWIGTYPE_p_FXMenuBar swig_types[55]
+#define SWIGTYPE_p_FXMenuCaption swig_types[56]
+#define SWIGTYPE_p_FXMenuCascade swig_types[57]
+#define SWIGTYPE_p_FXMenuCheck swig_types[58]
+#define SWIGTYPE_p_FXMenuCommand swig_types[59]
+#define SWIGTYPE_p_FXMenuPane swig_types[60]
+#define SWIGTYPE_p_FXMenuRadio swig_types[61]
+#define SWIGTYPE_p_FXMenuSeparator swig_types[62]
+#define SWIGTYPE_p_FXMenuTitle swig_types[63]
+#define SWIGTYPE_p_FXObject swig_types[64]
+#define SWIGTYPE_p_FXPacker swig_types[65]
+#define SWIGTYPE_p_FXPopup swig_types[66]
+#define SWIGTYPE_p_FXProgressBar swig_types[67]
+#define SWIGTYPE_p_FXRealSlider swig_types[68]
+#define SWIGTYPE_p_FXRealSpinner swig_types[69]
+#define SWIGTYPE_p_FXRecentFiles swig_types[70]
+#define SWIGTYPE_p_FXRegion swig_types[71]
+#define SWIGTYPE_p_FXRegistry swig_types[72]
+#define SWIGTYPE_p_FXRootWindow swig_types[73]
+#define SWIGTYPE_p_FXRuler swig_types[74]
+#define SWIGTYPE_p_FXRulerView swig_types[75]
+#define SWIGTYPE_p_FXScrollArea swig_types[76]
+#define SWIGTYPE_p_FXScrollBar swig_types[77]
+#define SWIGTYPE_p_FXScrollCorner swig_types[78]
+#define SWIGTYPE_p_FXScrollPane swig_types[79]
+#define SWIGTYPE_p_FXScrollWindow swig_types[80]
+#define SWIGTYPE_p_FXSeparator swig_types[81]
+#define SWIGTYPE_p_FXSettings swig_types[82]
+#define SWIGTYPE_p_FXShell swig_types[83]
+#define SWIGTYPE_p_FXShutter swig_types[84]
+#define SWIGTYPE_p_FXShutterItem swig_types[85]
+#define SWIGTYPE_p_FXSlider swig_types[86]
+#define SWIGTYPE_p_FXSpinner swig_types[87]
+#define SWIGTYPE_p_FXSplashWindow swig_types[88]
+#define SWIGTYPE_p_FXSplitter swig_types[89]
+#define SWIGTYPE_p_FXSpring swig_types[90]
+#define SWIGTYPE_p_FXStatusBar swig_types[91]
+#define SWIGTYPE_p_FXStatusLine swig_types[92]
+#define SWIGTYPE_p_FXStream swig_types[93]
+#define SWIGTYPE_p_FXStringDict swig_types[94]
+#define SWIGTYPE_p_FXSwitcher swig_types[95]
+#define SWIGTYPE_p_FXTabBar swig_types[96]
+#define SWIGTYPE_p_FXTabBook swig_types[97]
+#define SWIGTYPE_p_FXTextField swig_types[98]
+#define SWIGTYPE_p_FXToolBar swig_types[99]
+#define SWIGTYPE_p_FXToolBarGrip swig_types[100]
+#define SWIGTYPE_p_FXToolBarShell swig_types[101]
+#define SWIGTYPE_p_FXToolBarTab swig_types[102]
+#define SWIGTYPE_p_FXToolTip swig_types[103]
+#define SWIGTYPE_p_FXTopWindow swig_types[104]
+#define SWIGTYPE_p_FXTranslator swig_types[105]
+#define SWIGTYPE_p_FXTreeListBox swig_types[106]
+#define SWIGTYPE_p_FXVerticalFrame swig_types[107]
+#define SWIGTYPE_p_FXVerticalSeparator swig_types[108]
+#define SWIGTYPE_p_FXVisual swig_types[109]
+#define SWIGTYPE_p_FXWindow swig_types[110]
+#define SWIGTYPE_p_char swig_types[111]
+#define SWIGTYPE_p_double swig_types[112]
+#define SWIGTYPE_p_float swig_types[113]
+#define SWIGTYPE_p_int swig_types[114]
+#define SWIGTYPE_p_long swig_types[115]
+#define SWIGTYPE_p_short swig_types[116]
+#define SWIGTYPE_p_unsigned_char swig_types[117]
+#define SWIGTYPE_p_unsigned_int swig_types[118]
+#define SWIGTYPE_p_unsigned_long swig_types[119]
+#define SWIGTYPE_p_unsigned_short swig_types[120]
+static swig_type_info *swig_types[122];
+static swig_module_info swig_module = {swig_types, 121, 0, 0, 0, 0};
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
+
+/* -------- TYPES TABLE (END) -------- */
+
+#define SWIG_init    Init_menu
+#define SWIG_name    "Menu"
+
+
+
+#define SWIG_RUBY_THREAD_BEGIN_BLOCK
+#define SWIG_RUBY_THREAD_END_BLOCK
+
+
+#define SWIGVERSION 0x030012 
+#define SWIG_VERSION SWIGVERSION
+
+
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
+
+
+#include <stdexcept>
+
+
+#include "FXRbCommon.h"
+
+
+inline FXColor to_FXColor(VALUE obj){
+  if(TYPE(obj)==T_STRING){
+    return fxcolorfromname(StringValuePtr(obj));
+    }
+  else if(TYPE(obj)==T_SYMBOL){
+    return fxcolorfromname(rb_id2name(SYM2ID(obj)));
+    }
+  else{
+    return NUM2ULONG(obj);
+    }
+  }
+
+
+inline FXString to_FXString(VALUE obj){
+  if(!NIL_P(obj)){
+    Check_Type(obj,T_STRING);
+    return FXString(StringValuePtr(obj));
+    }
+  else{
+    return FXString::null;
+    }
+  }
+
+
+inline FXbool to_FXbool(VALUE obj){
+  if (obj == Qtrue || obj == Qfalse){
+    return (obj == Qtrue) ? TRUE : FALSE;
+    }
+  else{
+    return static_cast<FXbool>(NUM2UINT(obj));
+    }
+  }
+
+
+static swig_type_info* FXEventTypeInfo=0;
+
+inline void* to_FXEvent(VALUE obj){
+  void* ptr;
+  if(!FXEventTypeInfo){
+    FXEventTypeInfo=SWIG_TypeQuery("FXEvent *");
+    FXASSERT(FXEventTypeInfo!=0);
+    }
+  SWIG_ConvertPtr(obj,&ptr,FXEventTypeInfo,1);
+  return ptr;
+  }
+
+SWIGINTERN FXMenuPane *new_FXMenuPane(FXWindow *owner,FXuint opts=0){
+      return new FXRbMenuPane(owner,opts);
+      }
+
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
+
+
+  #define SWIG_From_long   LONG2NUM 
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_int  (int value)
+{    
+  return SWIG_From_long  (value);
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_bool  (bool value)
+{
+  return value ? Qtrue : Qfalse;
+}
+
+
+SWIGINTERN swig_type_info*
+SWIG_pchar_descriptor(void)
+{
+  static int init = 0;
+  static swig_type_info* info = 0;
+  if (!init) {
+    info = SWIG_TypeQuery("_p_char");
+    init = 1;
+  }
+  return info;
+}
+
+
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
+{
+  if (TYPE(obj) == T_STRING) {
+    char *cstr = StringValuePtr(obj); 
+    size_t size = RSTRING_LEN(obj) + 1;
+    if (cptr)  {
+      if (alloc) {
+	if (*alloc == SWIG_NEWOBJ) {
+	  *cptr = reinterpret_cast< char* >(memcpy(new char[size], cstr, sizeof(char)*(size)));
+	} else {
+	  *cptr = cstr;
+	  *alloc = SWIG_OLDOBJ;
+	}
+      }
+    }
+    if (psize) *psize = size;
+    return SWIG_OK;
+  } else {
+    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+    if (pchar_descriptor) {
+      void* vptr = 0;
+      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
+	if (cptr) *cptr = (char *)vptr;
+	if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
+	if (alloc) *alloc = SWIG_OLDOBJ;
+	return SWIG_OK;
+      }
+    }
+  }  
+  return SWIG_TypeError;
+}
+
+
+
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+  if (carray) {
+    if (size > LONG_MAX) {
+      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+      return pchar_descriptor ? 
+	SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : Qnil;
+    } else {
+      return rb_str_new(carray, static_cast< long >(size));
+    }
+  } else {
+    return Qnil;
+  }
+}
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtr(const char *cptr)
+{ 
+  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
+}
+
+
+static swig_type_info *FXMenuPane_dynamic_cast(void **ptr) {
+    FXMenuPane **ppMenuPane = reinterpret_cast<FXMenuPane **>(ptr);
+    FXMDIMenu *pMDIMenu=dynamic_cast<FXMDIMenu*>(*ppMenuPane);
+    if(pMDIMenu){
+      *ptr=reinterpret_cast<void*>(pMDIMenu);
+      return SWIG_TypeQuery("FXMDIMenu *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXScrollPane *new_FXScrollPane(FXWindow *owner,FXint nvis,FXuint opts=0){
+      return new FXRbScrollPane(owner,nvis,opts);
+      }
+SWIGINTERN FXMenuCaption *new_FXMenuCaption(FXComposite *p,FXString const &text,FXIcon *ic=0,FXuint opts=0){
+      return new FXRbMenuCaption(p,text,ic,opts);
+      }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_long  (unsigned long value)
+{
+  return ULONG2NUM(value); 
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_int  (unsigned int value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+
+static swig_type_info *FXMenuCaption_dynamic_cast(void **ptr) {
+    FXMenuCaption **ppMenuCaption = reinterpret_cast<FXMenuCaption **>(ptr);
+    FXMenuCascade *pMenuCascade=dynamic_cast<FXMenuCascade*>(*ppMenuCaption);
+    if(pMenuCascade){
+      *ptr=reinterpret_cast<void*>(pMenuCascade);
+      return SWIG_TypeQuery("FXMenuCascade *");
+      }
+    FXMenuCommand *pMenuCommand=dynamic_cast<FXMenuCommand*>(*ppMenuCaption);
+    if(pMenuCommand){
+      *ptr=reinterpret_cast<void*>(pMenuCommand);
+      return SWIG_TypeQuery("FXMenuCommand *");
+      }
+    FXMenuTitle *pMenuTitle=dynamic_cast<FXMenuTitle*>(*ppMenuCaption);
+    if(pMenuTitle){
+      *ptr=reinterpret_cast<void*>(pMenuTitle);
+      return SWIG_TypeQuery("FXMenuTitle *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXMenuSeparator *new_FXMenuSeparator(FXComposite *p,FXuint opts=0){
+      return new FXRbMenuSeparator(p,opts);
+      }
+SWIGINTERN FXMenuTitle *new_FXMenuTitle(FXComposite *p,FXString const &text,FXIcon *ic=0,FXPopup *pup=0,FXuint opts=0){
+      return new FXRbMenuTitle(p,text,ic,pup,opts);
+      }
+SWIGINTERN FXMenuCascade *new_FXMenuCascade(FXComposite *p,FXString const &text,FXIcon *ic=0,FXPopup *pup=0,FXuint opts=0){
+      return new FXRbMenuCascade(p,text,ic,pup,opts);
+      }
+SWIGINTERN FXMenuCommand *new_FXMenuCommand(FXComposite *p,FXString const &text,FXIcon *ic=0,FXObject *tgt=0,FXSelector sel=0,FXuint opts=0){
+      return new FXRbMenuCommand(p,text,ic,tgt,sel,opts);
+      }
+SWIGINTERN FXMenuBar *new_FXMenuBar__SWIG_0(FXComposite *p,FXComposite *q,FXuint opts=LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=3,FXint pr=3,FXint pt=2,FXint pb=2,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING){
+      return new FXRbMenuBar(p,q,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+SWIGINTERN FXMenuBar *new_FXMenuBar__SWIG_1(FXComposite *p,FXuint opts,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=3,FXint pr=3,FXint pt=2,FXint pb=2,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING){
+      return new FXRbMenuBar(p,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+SWIGINTERN FXMenuCheck *new_FXMenuCheck(FXComposite *p,FXString const &text,FXObject *tgt=0,FXSelector sel=0,FXuint opts=0){
+      return new FXRbMenuCheck(p,text,tgt,sel,opts);
+      }
+SWIGINTERN FXbool FXMenuCheck_getCheck(FXMenuCheck const *self){
+      rb_warning("FXMenuCheck#getCheck is deprecated; use checked?, unchecked? or maybe?");
+      return self->getCheck();
+      }
+SWIGINTERN FXuchar FXMenuCheck_getCheckState(FXMenuCheck const *self){ return self->getCheck(); }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_char  (unsigned char value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+SWIGINTERN FXMenuRadio *new_FXMenuRadio(FXComposite *p,FXString const &text,FXObject *tgt=0,FXSelector sel=0,FXuint opts=0){
+      return new FXRbMenuRadio(p,text,tgt,sel,opts);
+      }
+SWIGINTERN FXbool FXMenuRadio_getCheck(FXMenuRadio const *self){
+      rb_warning("FXMenuRadio#getCheck is deprecated; use checked?, unchecked? or maybe?");
+      return self->getCheck();
+      }
+SWIGINTERN FXuchar FXMenuRadio_getCheckState(FXMenuRadio const *self){ return self->getCheck(); }
+static swig_class SwigClassFXMenuPane;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMenuPane_allocate(VALUE self)
+#else
+_wrap_FXMenuPane_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMenuPane);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMenuPane(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXuint arg2 = (FXuint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMenuPane *result = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXMenuPane", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXMenuPane *)new_FXMenuPane(arg1,arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_save(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMenuPane_save((FXMenuPane const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_load(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMenuPane_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_create(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  FXMenuPane_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_detach(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  FXMenuPane_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_destroy(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  FXMenuPane_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_resize(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMenuPane_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  result = (FXint)FXMenuPane_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  result = (FXint)FXMenuPane_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMenuPane_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMenuPane_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  result = (bool)FXMenuPane_canFocus((FXMenuPane const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  FXMenuPane_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  FXMenuPane_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXMenuPane_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMenuPane_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_enable(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  FXMenuPane_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_disable(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  FXMenuPane_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  FXMenuPane_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_lower(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  FXMenuPane_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_move(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMenuPane_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_position(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXMenuPane_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_layout(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  FXMenuPane_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_recalc(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  FXMenuPane_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_reparent(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXMenuPane_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_show(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  FXMenuPane_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_hide(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  FXMenuPane_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  result = (bool)FXMenuPane_isComposite((FXMenuPane const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_contains(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXMenuPane_contains((FXMenuPane const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  result = (bool)FXMenuPane_doesSaveUnder((FXMenuPane const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXMenuPane_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_tr(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXMenuPane_tr((FXMenuPane const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  FXMenuPane_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  FXMenuPane_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXMenuPane_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXMenuPane_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXMenuPane_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMenuPane_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuPane, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuPane_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuPane, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuPane_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuPane, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuPane_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  FXMenuPane_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_popup(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 3) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","popup", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","popup", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  if (argc > 3) {
+    arg5 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg6 = NUM2INT(argv[4]);
+  }
+  FXMenuPane_popup(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuPane_popdown(int argc, VALUE *argv, VALUE self) {
+  FXMenuPane *arg1 = (FXMenuPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuPane *","popdown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuPane * >(argp1);
+  FXMenuPane_popdown(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXScrollPane;
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_onCmdIncrement(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","onCmdIncrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdIncrement", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdIncrement(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_onCmdDecrement(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","onCmdDecrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDecrement", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDecrement(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXScrollPane_allocate(VALUE self)
+#else
+_wrap_FXScrollPane_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXScrollPane);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXScrollPane(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXint arg2 ;
+  FXuint arg3 = (FXuint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXScrollPane *result = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXScrollPane", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  arg2 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXScrollPane *)new_FXScrollPane(arg1,arg2,arg3);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_numVisible(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane const *","getNumVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  result = (FXint)((FXScrollPane const *)arg1)->getNumVisible();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_numVisiblee___(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","setNumVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setNumVisible(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_getTopItem(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane const *","getTopItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  result = (FXint)((FXScrollPane const *)arg1)->getTopItem();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_setTopItem(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","setTopItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setTopItem(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_save(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXScrollPane_save((FXScrollPane const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_load(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXScrollPane_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_create(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  FXScrollPane_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_detach(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  FXScrollPane_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_destroy(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  FXScrollPane_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_resize(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXScrollPane_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  result = (FXint)FXScrollPane_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  result = (FXint)FXScrollPane_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXScrollPane_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXScrollPane_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  result = (bool)FXScrollPane_canFocus((FXScrollPane const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  FXScrollPane_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  FXScrollPane_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXScrollPane_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXScrollPane_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_enable(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  FXScrollPane_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_disable(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  FXScrollPane_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  FXScrollPane_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_lower(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  FXScrollPane_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_move(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXScrollPane_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_position(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXScrollPane_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_layout(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  FXScrollPane_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_recalc(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  FXScrollPane_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_reparent(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXScrollPane_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_show(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  FXScrollPane_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_hide(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  FXScrollPane_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  result = (bool)FXScrollPane_isComposite((FXScrollPane const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_contains(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXScrollPane_contains((FXScrollPane const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  result = (bool)FXScrollPane_doesSaveUnder((FXScrollPane const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXScrollPane_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_tr(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXScrollPane_tr((FXScrollPane const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  FXScrollPane_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  FXScrollPane_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXScrollPane_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXScrollPane_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXScrollPane_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXScrollPane_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScrollPane, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXScrollPane_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScrollPane, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXScrollPane_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScrollPane, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXScrollPane_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  FXScrollPane_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_popup(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 3) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","popup", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","popup", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  if (argc > 3) {
+    arg5 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg6 = NUM2INT(argv[4]);
+  }
+  FXScrollPane_popup(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollPane_popdown(int argc, VALUE *argv, VALUE self) {
+  FXScrollPane *arg1 = (FXScrollPane *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollPane, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollPane *","popdown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollPane * >(argp1);
+  FXScrollPane_popdown(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMenuCaption;
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_onUpdate(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","onUpdate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdate", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdate(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_onCmdSetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","onCmdSetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_onCmdGetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","onCmdGetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_onCmdSetIconValue(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *tmp4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","onCmdSetIconValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIconValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    tmp4 = FXRbConvertPtr(argv[2], FXRbTypeQuery("FXIcon *"));
+    arg4 = (void *) &tmp4;
+  }
+  result = (long)(arg1)->onCmdSetIconValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_onCmdGetIconValue(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","onCmdGetIconValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIconValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIconValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_onCmdSetHelp(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","onCmdSetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_onCmdGetHelp(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","onCmdGetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_onCmdSetTip(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","onCmdSetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_onCmdGetTip(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","onCmdGetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMenuCaption_allocate(VALUE self)
+#else
+_wrap_FXMenuCaption_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMenuCaption);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMenuCaption(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXMenuCaption *result = 0 ;
+  
+  if ((argc < 2) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXMenuCaption", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","FXMenuCaption", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXMenuCaption *)new_FXMenuCaption(arg1,(FXString const &)*arg2,arg3,arg4);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_setText(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","setText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_getText(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption const *","getText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  result = ((FXMenuCaption const *)arg1)->getText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_setIcon(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","setIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  (arg1)->setIcon(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_getIcon(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption const *","getIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  result = (FXIcon *)((FXMenuCaption const *)arg1)->getIcon();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_setFont(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  (arg1)->setFont(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_getFont(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  result = (FXFont *)((FXMenuCaption const *)arg1)->getFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_setMenuStyle(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","setMenuStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setMenuStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_getMenuStyle(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption const *","getMenuStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  result = (FXuint)((FXMenuCaption const *)arg1)->getMenuStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_getTextColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption const *","getTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  result = (FXColor)((FXMenuCaption const *)arg1)->getTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_setTextColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","setTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_getSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption const *","getSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  result = (FXColor)((FXMenuCaption const *)arg1)->getSelBackColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_setSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","setSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelBackColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_getSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption const *","getSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  result = (FXColor)((FXMenuCaption const *)arg1)->getSelTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_setSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","setSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_setHiliteColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","setHiliteColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setHiliteColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_getHiliteColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption const *","getHiliteColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  result = (FXColor)((FXMenuCaption const *)arg1)->getHiliteColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_setShadowColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","setShadowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setShadowColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_getShadowColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption const *","getShadowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  result = (FXColor)((FXMenuCaption const *)arg1)->getShadowColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  result = (FXString *) &((FXMenuCaption const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_tipTexte___(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_tipText(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  result = (FXString *) &((FXMenuCaption const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_save(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMenuCaption_save((FXMenuCaption const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_load(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMenuCaption_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_create(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  FXMenuCaption_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_detach(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  FXMenuCaption_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_destroy(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  FXMenuCaption_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_resize(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMenuCaption_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  result = (FXint)FXMenuCaption_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  result = (FXint)FXMenuCaption_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMenuCaption_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMenuCaption_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  result = (bool)FXMenuCaption_canFocus((FXMenuCaption const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  FXMenuCaption_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  FXMenuCaption_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXMenuCaption_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMenuCaption_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_enable(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  FXMenuCaption_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_disable(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  FXMenuCaption_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  FXMenuCaption_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_lower(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  FXMenuCaption_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_move(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMenuCaption_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_position(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXMenuCaption_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_layout(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  FXMenuCaption_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_recalc(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  FXMenuCaption_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_reparent(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXMenuCaption_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_show(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  FXMenuCaption_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_hide(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  FXMenuCaption_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  result = (bool)FXMenuCaption_isComposite((FXMenuCaption const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_contains(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXMenuCaption_contains((FXMenuCaption const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  result = (bool)FXMenuCaption_doesSaveUnder((FXMenuCaption const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXMenuCaption_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_tr(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXMenuCaption_tr((FXMenuCaption const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  FXMenuCaption_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  FXMenuCaption_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXMenuCaption_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXMenuCaption_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXMenuCaption_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMenuCaption_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuCaption, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuCaption_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuCaption, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuCaption_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuCaption, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuCaption_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCaption_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXMenuCaption *arg1 = (FXMenuCaption *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCaption, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCaption *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCaption * >(argp1);
+  FXMenuCaption_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMenuSeparator;
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMenuSeparator_allocate(VALUE self)
+#else
+_wrap_FXMenuSeparator_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMenuSeparator);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMenuSeparator(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXuint arg2 = (FXuint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMenuSeparator *result = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXMenuSeparator", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXMenuSeparator *)new_FXMenuSeparator(arg1,arg2);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_setHiliteColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","setHiliteColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setHiliteColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_getHiliteColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator const *","getHiliteColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  result = (FXColor)((FXMenuSeparator const *)arg1)->getHiliteColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_setShadowColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","setShadowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setShadowColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_getShadowColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator const *","getShadowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  result = (FXColor)((FXMenuSeparator const *)arg1)->getShadowColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_save(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMenuSeparator_save((FXMenuSeparator const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_load(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMenuSeparator_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_create(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  FXMenuSeparator_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_detach(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  FXMenuSeparator_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_destroy(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  FXMenuSeparator_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_resize(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMenuSeparator_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  result = (FXint)FXMenuSeparator_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  result = (FXint)FXMenuSeparator_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMenuSeparator_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMenuSeparator_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  result = (bool)FXMenuSeparator_canFocus((FXMenuSeparator const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  FXMenuSeparator_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  FXMenuSeparator_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXMenuSeparator_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMenuSeparator_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_enable(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  FXMenuSeparator_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_disable(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  FXMenuSeparator_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  FXMenuSeparator_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_lower(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  FXMenuSeparator_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_move(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMenuSeparator_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_position(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXMenuSeparator_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_layout(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  FXMenuSeparator_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_recalc(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  FXMenuSeparator_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_reparent(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXMenuSeparator_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_show(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  FXMenuSeparator_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_hide(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  FXMenuSeparator_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  result = (bool)FXMenuSeparator_isComposite((FXMenuSeparator const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_contains(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXMenuSeparator_contains((FXMenuSeparator const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  result = (bool)FXMenuSeparator_doesSaveUnder((FXMenuSeparator const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXMenuSeparator_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_tr(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXMenuSeparator_tr((FXMenuSeparator const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  FXMenuSeparator_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  FXMenuSeparator_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXMenuSeparator_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXMenuSeparator_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXMenuSeparator_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMenuSeparator_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuSeparator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuSeparator_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuSeparator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuSeparator_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuSeparator, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuSeparator_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuSeparator_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXMenuSeparator *arg1 = (FXMenuSeparator *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuSeparator, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuSeparator *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuSeparator * >(argp1);
+  FXMenuSeparator_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMenuTitle;
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_onEnter(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","onEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_onLeave(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","onLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_onHotKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","onHotKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_onHotKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","onHotKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onHotKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_onFocusUp(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","onFocusUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onFocusUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_onFocusDown(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","onFocusDown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusDown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onFocusDown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_onFocusIn(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","onFocusIn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusIn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusIn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_onFocusOut(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","onFocusOut", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusOut", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusOut(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_onCmdPost(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","onCmdPost", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdPost", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdPost(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_onCmdUnpost(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","onCmdUnpost", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdUnpost", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdUnpost(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMenuTitle_allocate(VALUE self)
+#else
+_wrap_FXMenuTitle_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMenuTitle);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMenuTitle(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXPopup *arg4 = (FXPopup *) 0 ;
+  FXuint arg5 = (FXuint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXMenuTitle *result = 0 ;
+  
+  if ((argc < 2) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXMenuTitle", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","FXMenuTitle", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 3) {
+    res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_FXPopup, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXPopup *","FXMenuTitle", 4, argv[3] )); 
+    }
+    arg4 = reinterpret_cast< FXPopup * >(argp4);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXMenuTitle *)new_FXMenuTitle(arg1,(FXString const &)*arg2,arg3,arg4,arg5);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_setMenu(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXPopup *arg2 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","setMenu", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXPopup *","setMenu", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXPopup * >(argp2);
+  (arg1)->setMenu(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_getMenu(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPopup *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle const *","getMenu", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  result = (FXPopup *)((FXMenuTitle const *)arg1)->getMenu();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXPopup, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_save(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMenuTitle_save((FXMenuTitle const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_load(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMenuTitle_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_create(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  FXMenuTitle_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_detach(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  FXMenuTitle_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_destroy(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  FXMenuTitle_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_resize(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMenuTitle_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  result = (FXint)FXMenuTitle_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  result = (FXint)FXMenuTitle_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMenuTitle_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMenuTitle_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  result = (bool)FXMenuTitle_canFocus((FXMenuTitle const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  FXMenuTitle_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  FXMenuTitle_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXMenuTitle_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMenuTitle_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_enable(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  FXMenuTitle_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_disable(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  FXMenuTitle_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  FXMenuTitle_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_lower(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  FXMenuTitle_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_move(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMenuTitle_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_position(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXMenuTitle_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_layout(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  FXMenuTitle_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_recalc(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  FXMenuTitle_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_reparent(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXMenuTitle_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_show(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  FXMenuTitle_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_hide(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  FXMenuTitle_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  result = (bool)FXMenuTitle_isComposite((FXMenuTitle const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_contains(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXMenuTitle_contains((FXMenuTitle const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  result = (bool)FXMenuTitle_doesSaveUnder((FXMenuTitle const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXMenuTitle_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_tr(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXMenuTitle_tr((FXMenuTitle const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  FXMenuTitle_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  FXMenuTitle_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXMenuTitle_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXMenuTitle_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXMenuTitle_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMenuTitle_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuTitle, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuTitle_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuTitle, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuTitle_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuTitle, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuTitle_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuTitle_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXMenuTitle *arg1 = (FXMenuTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuTitle *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuTitle * >(argp1);
+  FXMenuTitle_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMenuCascade;
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_onEnter(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","onEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_onLeave(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","onLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_onButtonPress(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","onButtonPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onButtonPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onButtonPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_onButtonRelease(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","onButtonRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onButtonRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onButtonRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_onHotKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","onHotKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_onHotKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","onHotKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onHotKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_onCmdPost(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","onCmdPost", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdPost", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdPost(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_onCmdUnpost(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","onCmdUnpost", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdUnpost", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdUnpost(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMenuCascade_allocate(VALUE self)
+#else
+_wrap_FXMenuCascade_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMenuCascade);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMenuCascade(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXPopup *arg4 = (FXPopup *) 0 ;
+  FXuint arg5 = (FXuint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXMenuCascade *result = 0 ;
+  
+  if ((argc < 2) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXMenuCascade", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","FXMenuCascade", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 3) {
+    res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_FXPopup, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXPopup *","FXMenuCascade", 4, argv[3] )); 
+    }
+    arg4 = reinterpret_cast< FXPopup * >(argp4);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXMenuCascade *)new_FXMenuCascade(arg1,(FXString const &)*arg2,arg3,arg4,arg5);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_setMenu(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXPopup *arg2 = (FXPopup *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","setMenu", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXPopup, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXPopup *","setMenu", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXPopup * >(argp2);
+  (arg1)->setMenu(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_getMenu(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXPopup *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade const *","getMenu", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  result = (FXPopup *)((FXMenuCascade const *)arg1)->getMenu();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXPopup, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_save(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMenuCascade_save((FXMenuCascade const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_load(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMenuCascade_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_create(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  FXMenuCascade_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_detach(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  FXMenuCascade_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_destroy(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  FXMenuCascade_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_resize(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMenuCascade_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  result = (FXint)FXMenuCascade_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  result = (FXint)FXMenuCascade_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMenuCascade_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMenuCascade_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  result = (bool)FXMenuCascade_canFocus((FXMenuCascade const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  FXMenuCascade_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  FXMenuCascade_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXMenuCascade_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMenuCascade_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_enable(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  FXMenuCascade_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_disable(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  FXMenuCascade_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  FXMenuCascade_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_lower(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  FXMenuCascade_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_move(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMenuCascade_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_position(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXMenuCascade_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_layout(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  FXMenuCascade_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_recalc(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  FXMenuCascade_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_reparent(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXMenuCascade_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_show(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  FXMenuCascade_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_hide(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  FXMenuCascade_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  result = (bool)FXMenuCascade_isComposite((FXMenuCascade const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_contains(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXMenuCascade_contains((FXMenuCascade const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  result = (bool)FXMenuCascade_doesSaveUnder((FXMenuCascade const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXMenuCascade_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_tr(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXMenuCascade_tr((FXMenuCascade const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  FXMenuCascade_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  FXMenuCascade_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXMenuCascade_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXMenuCascade_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXMenuCascade_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMenuCascade_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuCascade, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuCascade_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuCascade, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuCascade_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuCascade, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuCascade_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCascade_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXMenuCascade *arg1 = (FXMenuCascade *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCascade, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCascade *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCascade * >(argp1);
+  FXMenuCascade_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMenuCommand;
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_onEnter(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","onEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_onLeave(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","onLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_onButtonPress(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","onButtonPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onButtonPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onButtonPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_onButtonRelease(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","onButtonRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onButtonRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onButtonRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_onHotKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","onHotKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_onHotKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","onHotKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_onCmdAccel(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","onCmdAccel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdAccel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdAccel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMenuCommand_allocate(VALUE self)
+#else
+_wrap_FXMenuCommand_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMenuCommand);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMenuCommand(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXObject *arg4 = (FXObject *) 0 ;
+  FXSelector arg5 = (FXSelector) 0 ;
+  FXuint arg6 = (FXuint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXMenuCommand *result = 0 ;
+  
+  if ((argc < 2) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXMenuCommand", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","FXMenuCommand", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 3) {
+    res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXObject *","FXMenuCommand", 4, argv[3] )); 
+    }
+    arg4 = reinterpret_cast< FXObject * >(argp4);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2UINT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXMenuCommand *)new_FXMenuCommand(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_setAccelText(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","setAccelText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setAccelText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_getAccelText(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand const *","getAccelText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  result = ((FXMenuCommand const *)arg1)->getAccelText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_save(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMenuCommand_save((FXMenuCommand const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_load(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMenuCommand_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_create(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  FXMenuCommand_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_detach(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  FXMenuCommand_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_destroy(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  FXMenuCommand_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_resize(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMenuCommand_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  result = (FXint)FXMenuCommand_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  result = (FXint)FXMenuCommand_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMenuCommand_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMenuCommand_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  result = (bool)FXMenuCommand_canFocus((FXMenuCommand const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  FXMenuCommand_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  FXMenuCommand_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXMenuCommand_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMenuCommand_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_enable(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  FXMenuCommand_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_disable(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  FXMenuCommand_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  FXMenuCommand_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_lower(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  FXMenuCommand_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_move(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMenuCommand_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_position(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXMenuCommand_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_layout(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  FXMenuCommand_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_recalc(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  FXMenuCommand_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_reparent(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXMenuCommand_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_show(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  FXMenuCommand_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_hide(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  FXMenuCommand_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  result = (bool)FXMenuCommand_isComposite((FXMenuCommand const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_contains(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXMenuCommand_contains((FXMenuCommand const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  result = (bool)FXMenuCommand_doesSaveUnder((FXMenuCommand const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXMenuCommand_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_tr(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXMenuCommand_tr((FXMenuCommand const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  FXMenuCommand_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  FXMenuCommand_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXMenuCommand_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXMenuCommand_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXMenuCommand_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMenuCommand_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuCommand, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuCommand_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuCommand, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuCommand_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuCommand, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuCommand_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCommand_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXMenuCommand *arg1 = (FXMenuCommand *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCommand, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCommand *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCommand * >(argp1);
+  FXMenuCommand_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMenuBar;
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_onFocusLeft(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","onFocusLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusLeft", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusLeft(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_onFocusRight(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","onFocusRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusRight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusRight(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_onEnter(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","onEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_onLeave(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","onLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_onButtonPress(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","onButtonPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onButtonPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onButtonPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_onButtonRelease(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","onButtonRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onButtonRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onButtonRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_onCmdUnpost(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","onCmdUnpost", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdUnpost", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdUnpost(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMenuBar__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXComposite *arg2 = (FXComposite *) 0 ;
+  FXuint arg3 = (FXuint) LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 3 ;
+  FXint arg9 = (FXint) 3 ;
+  FXint arg10 = (FXint) 2 ;
+  FXint arg11 = (FXint) 2 ;
+  FXint arg12 = (FXint) DEFAULT_SPACING ;
+  FXint arg13 = (FXint) DEFAULT_SPACING ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXMenuBar *result = 0 ;
+  
+  if ((argc < 2) || (argc > 13)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXMenuBar", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXComposite *","FXMenuBar", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXComposite * >(argp2);
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXMenuBar *)new_FXMenuBar__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMenuBar_allocate(VALUE self)
+#else
+_wrap_FXMenuBar_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMenuBar);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMenuBar__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXuint arg2 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 3 ;
+  FXint arg8 = (FXint) 3 ;
+  FXint arg9 = (FXint) 2 ;
+  FXint arg10 = (FXint) 2 ;
+  FXint arg11 = (FXint) DEFAULT_SPACING ;
+  FXint arg12 = (FXint) DEFAULT_SPACING ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXMenuBar *result = 0 ;
+  
+  if ((argc < 2) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXMenuBar", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  arg2 = NUM2UINT(argv[1]);
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXMenuBar *)new_FXMenuBar__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXMenuBar(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[13];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 13) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 2) && (argc <= 13)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComposite, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXComposite, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_new_FXMenuBar__SWIG_0(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXMenuBar__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXMenuBar__SWIG_0(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXMenuBar__SWIG_0(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXMenuBar__SWIG_0(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  if (argc <= 7) {
+                    return _wrap_new_FXMenuBar__SWIG_0(nargs, args, self);
+                  }
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    if (argc <= 8) {
+                      return _wrap_new_FXMenuBar__SWIG_0(nargs, args, self);
+                    }
+                    {
+                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
+                    }
+                    if (_v) {
+                      if (argc <= 9) {
+                        return _wrap_new_FXMenuBar__SWIG_0(nargs, args, self);
+                      }
+                      {
+                        _v = (TYPE(argv[9]) == T_FIXNUM || TYPE(argv[9]) == T_BIGNUM) ? 1 : 0;
+                      }
+                      if (_v) {
+                        if (argc <= 10) {
+                          return _wrap_new_FXMenuBar__SWIG_0(nargs, args, self);
+                        }
+                        {
+                          _v = (TYPE(argv[10]) == T_FIXNUM || TYPE(argv[10]) == T_BIGNUM) ? 1 : 0;
+                        }
+                        if (_v) {
+                          if (argc <= 11) {
+                            return _wrap_new_FXMenuBar__SWIG_0(nargs, args, self);
+                          }
+                          {
+                            _v = (TYPE(argv[11]) == T_FIXNUM || TYPE(argv[11]) == T_BIGNUM) ? 1 : 0;
+                          }
+                          if (_v) {
+                            if (argc <= 12) {
+                              return _wrap_new_FXMenuBar__SWIG_0(nargs, args, self);
+                            }
+                            {
+                              _v = (TYPE(argv[12]) == T_FIXNUM || TYPE(argv[12]) == T_BIGNUM) ? 1 : 0;
+                            }
+                            if (_v) {
+                              return _wrap_new_FXMenuBar__SWIG_0(nargs, args, self);
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 2) && (argc <= 12)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComposite, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_new_FXMenuBar__SWIG_1(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXMenuBar__SWIG_1(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXMenuBar__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXMenuBar__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXMenuBar__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  if (argc <= 7) {
+                    return _wrap_new_FXMenuBar__SWIG_1(nargs, args, self);
+                  }
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    if (argc <= 8) {
+                      return _wrap_new_FXMenuBar__SWIG_1(nargs, args, self);
+                    }
+                    {
+                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
+                    }
+                    if (_v) {
+                      if (argc <= 9) {
+                        return _wrap_new_FXMenuBar__SWIG_1(nargs, args, self);
+                      }
+                      {
+                        _v = (TYPE(argv[9]) == T_FIXNUM || TYPE(argv[9]) == T_BIGNUM) ? 1 : 0;
+                      }
+                      if (_v) {
+                        if (argc <= 10) {
+                          return _wrap_new_FXMenuBar__SWIG_1(nargs, args, self);
+                        }
+                        {
+                          _v = (TYPE(argv[10]) == T_FIXNUM || TYPE(argv[10]) == T_BIGNUM) ? 1 : 0;
+                        }
+                        if (_v) {
+                          if (argc <= 11) {
+                            return _wrap_new_FXMenuBar__SWIG_1(nargs, args, self);
+                          }
+                          {
+                            _v = (TYPE(argv[11]) == T_FIXNUM || TYPE(argv[11]) == T_BIGNUM) ? 1 : 0;
+                          }
+                          if (_v) {
+                            return _wrap_new_FXMenuBar__SWIG_1(nargs, args, self);
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 13, "FXMenuBar.new", 
+    "    FXMenuBar.new(FXComposite *p, FXComposite *q, FXuint opts, FXint x, FXint y, FXint w, FXint h, FXint pl, FXint pr, FXint pt, FXint pb, FXint hs, FXint vs)\n"
+    "    FXMenuBar.new(FXComposite *p, FXuint opts, FXint x, FXint y, FXint w, FXint h, FXint pl, FXint pr, FXint pt, FXint pb, FXint hs, FXint vs)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_save(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMenuBar_save((FXMenuBar const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_load(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMenuBar_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_create(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  FXMenuBar_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_detach(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  FXMenuBar_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_destroy(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  FXMenuBar_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_resize(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMenuBar_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  result = (FXint)FXMenuBar_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  result = (FXint)FXMenuBar_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMenuBar_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMenuBar_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  result = (bool)FXMenuBar_canFocus((FXMenuBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  FXMenuBar_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  FXMenuBar_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXMenuBar_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMenuBar_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_enable(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  FXMenuBar_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_disable(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  FXMenuBar_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  FXMenuBar_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_lower(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  FXMenuBar_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_move(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMenuBar_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_position(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXMenuBar_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_layout(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  FXMenuBar_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_recalc(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  FXMenuBar_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_reparent(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXMenuBar_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_show(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  FXMenuBar_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_hide(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  FXMenuBar_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  result = (bool)FXMenuBar_isComposite((FXMenuBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_contains(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXMenuBar_contains((FXMenuBar const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  result = (bool)FXMenuBar_doesSaveUnder((FXMenuBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXMenuBar_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_tr(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXMenuBar_tr((FXMenuBar const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  FXMenuBar_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  FXMenuBar_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXMenuBar_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXMenuBar_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXMenuBar_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMenuBar_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuBar_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuBar_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuBar_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  FXMenuBar_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_dock__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXDockSite *arg2 = (FXDockSite *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","dock", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDockSite *","dock", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXDockSite * >(argp2);
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","dock", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXWindow * >(argp3);
+  }
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  FXMenuBar_dock(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_dock__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXDockSite *arg2 = (FXDockSite *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXbool arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","dock", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDockSite *","dock", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXDockSite * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = to_FXbool(argv[3]);
+  FXMenuBar_dock(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMenuBar_dock(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 2) && (argc <= 4)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXDockSite, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_FXMenuBar_dock__SWIG_0(nargs, args, self);
+        }
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXWindow, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXMenuBar_dock__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (argv[3] == Qtrue || argv[3] == Qfalse) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_FXMenuBar_dock__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXDockSite, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (argv[4] == Qtrue || argv[4] == Qfalse) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXMenuBar_dock__SWIG_1(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "dock", 
+    "    void dock(FXDockSite *docksite, FXWindow *before, FXbool notify)\n"
+    "    void dock(FXDockSite *docksite, FXint localx, FXint localy, FXbool notify)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuBar_undock(int argc, VALUE *argv, VALUE self) {
+  FXMenuBar *arg1 = (FXMenuBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuBar *","undock", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  FXMenuBar_undock(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMenuCheck;
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_onButtonPress(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","onButtonPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onButtonPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onButtonPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_onButtonRelease(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","onButtonRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onButtonRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onButtonRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_onHotKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","onHotKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_onHotKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","onHotKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_onCheck(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","onCheck", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCheck", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCheck(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_onUncheck(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","onUncheck", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUncheck", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUncheck(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_onUnknown(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","onUnknown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUnknown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUnknown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_onCmdAccel(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","onCmdAccel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdAccel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdAccel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMenuCheck_allocate(VALUE self)
+#else
+_wrap_FXMenuCheck_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMenuCheck);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMenuCheck(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXString *arg2 = 0 ;
+  FXObject *arg3 = (FXObject *) 0 ;
+  FXSelector arg4 = (FXSelector) 0 ;
+  FXuint arg5 = (FXuint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXMenuCheck *result = 0 ;
+  
+  if ((argc < 2) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXMenuCheck", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXObject *","FXMenuCheck", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXObject * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXMenuCheck *)new_FXMenuCheck(arg1,(FXString const &)*arg2,arg3,arg4,arg5);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_setCheck(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","setCheck", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->setCheck(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_getCheck(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck const *","getCheck", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  result = (FXbool)FXMenuCheck_getCheck((FXMenuCheck const *)arg1);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_getCheckState(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuchar result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck const *","getCheckState", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  result = (FXuchar)FXMenuCheck_getCheckState((FXMenuCheck const *)arg1);
+  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_getBoxColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck const *","getBoxColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  result = (FXColor)((FXMenuCheck const *)arg1)->getBoxColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_setBoxColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","setBoxColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setBoxColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_save(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMenuCheck_save((FXMenuCheck const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_load(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMenuCheck_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_create(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  FXMenuCheck_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_detach(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  FXMenuCheck_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_destroy(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  FXMenuCheck_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_resize(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMenuCheck_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  result = (FXint)FXMenuCheck_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  result = (FXint)FXMenuCheck_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMenuCheck_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMenuCheck_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  result = (bool)FXMenuCheck_canFocus((FXMenuCheck const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  FXMenuCheck_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  FXMenuCheck_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXMenuCheck_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMenuCheck_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_enable(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  FXMenuCheck_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_disable(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  FXMenuCheck_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  FXMenuCheck_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_lower(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  FXMenuCheck_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_move(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMenuCheck_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_position(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXMenuCheck_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_layout(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  FXMenuCheck_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_recalc(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  FXMenuCheck_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_reparent(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXMenuCheck_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_show(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  FXMenuCheck_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_hide(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  FXMenuCheck_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  result = (bool)FXMenuCheck_isComposite((FXMenuCheck const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_contains(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXMenuCheck_contains((FXMenuCheck const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  result = (bool)FXMenuCheck_doesSaveUnder((FXMenuCheck const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXMenuCheck_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_tr(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXMenuCheck_tr((FXMenuCheck const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  FXMenuCheck_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  FXMenuCheck_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXMenuCheck_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXMenuCheck_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXMenuCheck_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMenuCheck_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuCheck, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuCheck_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuCheck, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuCheck_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuCheck, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuCheck_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuCheck_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXMenuCheck *arg1 = (FXMenuCheck *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuCheck, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuCheck *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuCheck * >(argp1);
+  FXMenuCheck_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXMenuRadio;
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_onButtonPress(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","onButtonPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onButtonPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onButtonPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_onButtonRelease(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","onButtonRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onButtonRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onButtonRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_onHotKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","onHotKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_onHotKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","onHotKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHotKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onHotKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_onCheck(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","onCheck", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCheck", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCheck(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_onUncheck(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","onUncheck", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUncheck", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUncheck(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_onUnknown(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","onUnknown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUnknown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUnknown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXint) NUM2INT(argv[2]);
+    arg4 = static_cast<void*>(&value4);
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_onCmdAccel(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","onCmdAccel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdAccel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdAccel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXMenuRadio_allocate(VALUE self)
+#else
+_wrap_FXMenuRadio_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXMenuRadio);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXMenuRadio(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXString *arg2 = 0 ;
+  FXObject *arg3 = (FXObject *) 0 ;
+  FXSelector arg4 = (FXSelector) 0 ;
+  FXuint arg5 = (FXuint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXMenuRadio *result = 0 ;
+  
+  if ((argc < 2) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXMenuRadio", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXObject *","FXMenuRadio", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXObject * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXMenuRadio *)new_FXMenuRadio(arg1,(FXString const &)*arg2,arg3,arg4,arg5);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_setCheck(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","setCheck", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->setCheck(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_getCheck(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio const *","getCheck", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  result = (FXbool)FXMenuRadio_getCheck((FXMenuRadio const *)arg1);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_getCheckState(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuchar result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio const *","getCheckState", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  result = (FXuchar)FXMenuRadio_getCheckState((FXMenuRadio const *)arg1);
+  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_getRadioColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio const *","getRadioColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  result = (FXColor)((FXMenuRadio const *)arg1)->getRadioColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_setRadioColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","setRadioColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setRadioColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_save(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMenuRadio_save((FXMenuRadio const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_load(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXMenuRadio_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_create(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  FXMenuRadio_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_detach(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  FXMenuRadio_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_destroy(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  FXMenuRadio_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_resize(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMenuRadio_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  result = (FXint)FXMenuRadio_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  result = (FXint)FXMenuRadio_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMenuRadio_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXMenuRadio_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  result = (bool)FXMenuRadio_canFocus((FXMenuRadio const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  FXMenuRadio_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  FXMenuRadio_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXMenuRadio_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXMenuRadio_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_enable(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  FXMenuRadio_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_disable(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  FXMenuRadio_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  FXMenuRadio_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_lower(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  FXMenuRadio_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_move(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXMenuRadio_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_position(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXMenuRadio_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_layout(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  FXMenuRadio_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_recalc(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  FXMenuRadio_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_reparent(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXMenuRadio_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_show(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  FXMenuRadio_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_hide(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  FXMenuRadio_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  result = (bool)FXMenuRadio_isComposite((FXMenuRadio const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_contains(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXMenuRadio_contains((FXMenuRadio const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  result = (bool)FXMenuRadio_doesSaveUnder((FXMenuRadio const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXMenuRadio_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_tr(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXMenuRadio_tr((FXMenuRadio const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  FXMenuRadio_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  FXMenuRadio_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXMenuRadio_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXMenuRadio_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXMenuRadio_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXMenuRadio_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuRadio, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuRadio_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuRadio, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuRadio_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXMenuRadio, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXMenuRadio_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXMenuRadio_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXMenuRadio *arg1 = (FXMenuRadio *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXMenuRadio, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXMenuRadio *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXMenuRadio * >(argp1);
+  FXMenuRadio_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_FXScrollPaneTo_p_FXMenuPane(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXMenuPane *)  ((FXScrollPane *) x));
+}
+static void *_p_FXMenuBarTo_p_FXToolBar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXToolBar *)  ((FXMenuBar *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXMenuPaneTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXPopup *) ((FXMenuPane *) x));
+}
+static void *_p_FXToolBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXMenuBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXDockBar *)(FXToolBar *) ((FXMenuBar *) x));
+}
+static void *_p_FXToolTipTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXTabBookTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXShell *) x));
+}
+static void *_p_FXStatusBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXScrollArea *) x));
+}
+static void *_p_FXPopupTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXComboBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FX4SplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXSplitter *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXPackerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXPacker *) x));
+}
+static void *_p_FXDirBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXSwitcherTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXShutterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXDockSiteTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXRulerViewTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXMatrixTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXShutterItemTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXDockBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXImageViewTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXSpringTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXScrollPaneTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXPopup *)(FXMenuPane *) ((FXScrollPane *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXPopupTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *)  ((FXPopup *) x));
+}
+static void *_p_FXTopWindowTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *)  ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXToolTipTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *)  ((FXToolTip *) x));
+}
+static void *_p_FXMenuPaneTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXPopup *) ((FXMenuPane *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXScrollPaneTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXPopup *)(FXMenuPane *) ((FXScrollPane *) x));
+}
+static void *_p_FXMenuPaneTo_p_FXPopup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPopup *)  ((FXMenuPane *) x));
+}
+static void *_p_FXScrollPaneTo_p_FXPopup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPopup *) (FXMenuPane *) ((FXScrollPane *) x));
+}
+static void *_p_FXGradientBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShutterItemTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXMenuCheckTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXMenuCaption *)(FXMenuCommand *) ((FXMenuCheck *) x));
+}
+static void *_p_FXTabBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXMatrixTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXMenuPaneTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXPopup *) ((FXMenuPane *) x));
+}
+static void *_p_FXHeaderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXSplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSpringTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXMenuSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXMenuSeparator *) x));
+}
+static void *_p_FXProgressBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXToolTipTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXDockSiteTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXMenuCascadeTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXMenuCaption *) ((FXMenuCascade *) x));
+}
+static void *_p_FXColorRingTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXCanvasTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXCanvas *) x));
+}
+static void *_p_FXColorWheelTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXScrollBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXScrollBar *) x));
+}
+static void *_p_FXComboBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStatusBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXKnobTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXMenuCommandTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXMenuCaption *) ((FXMenuCommand *) x));
+}
+static void *_p_FXRulerViewTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXMenuCaptionTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXMenuCaption *) x));
+}
+static void *_p_FXStatusLineTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXMenuTitleTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXMenuCaption *) ((FXMenuTitle *) x));
+}
+static void *_p_FXMenuBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXDockBar *)(FXToolBar *) ((FXMenuBar *) x));
+}
+static void *_p_FXDockBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXMenuRadioTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXMenuCaption *)(FXMenuCommand *) ((FXMenuRadio *) x));
+}
+static void *_p_FXShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXToolBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXScrollPaneTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXPopup *)(FXMenuPane *) ((FXScrollPane *) x));
+}
+static void *_p_FXDirBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXDocumentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDocument *) x));
+}
+static void *_p_FXGradientBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXRegistryTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *)(FXSettings *) ((FXRegistry *) x));
+}
+static void *_p_FXHeaderItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXHeaderItem *) x));
+}
+static void *_p_FXShutterItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXMenuCheckTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXMenuCaption *)(FXMenuCommand *) ((FXMenuCheck *) x));
+}
+static void *_p_FXTabBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXIconDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXIconDict *) x));
+}
+static void *_p_FXMatrixTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXFileDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXFileDict *) x));
+}
+static void *_p_FXRecentFilesTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXRecentFiles *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXDrawableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXDrawable *) x));
+}
+static void *_p_FXMenuPaneTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXPopup *) ((FXMenuPane *) x));
+}
+static void *_p_FXAppTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXApp *) x));
+}
+static void *_p_FXHeaderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXTranslatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXTranslator *) x));
+}
+static void *_p_FX4SplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FXSpringTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXMenuSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXMenuSeparator *) x));
+}
+static void *_p_FXIdTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXId *) x));
+}
+static void *_p_FXProgressBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXToolTipTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXSettingsTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXSettings *) x));
+}
+static void *_p_FXDockSiteTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXMenuCascadeTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXMenuCaption *) ((FXMenuCascade *) x));
+}
+static void *_p_FXColorRingTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDebugTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDebugTarget *) x));
+}
+static void *_p_FXDataTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDataTarget *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXCanvasTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXListBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXColorWheelTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXVisualTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXVisual *) x));
+}
+static void *_p_FXScrollBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXFontTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXFont *) x));
+}
+static void *_p_FXComboBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStringDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXStringDict *) x));
+}
+static void *_p_FXStatusBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXDelegatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDelegator *) x));
+}
+static void *_p_FXAccelTableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXAccelTable *) x));
+}
+static void *_p_FXCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXKnobTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXMenuCommandTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXMenuCaption *) ((FXMenuCommand *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRulerViewTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXStatusLineTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMenuCaptionTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXMenuCaption *) x));
+}
+static void *_p_FXMenuTitleTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXMenuCaption *) ((FXMenuTitle *) x));
+}
+static void *_p_FXMenuBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *)(FXToolBar *) ((FXMenuBar *) x));
+}
+static void *_p_FXDockBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXMenuRadioTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXMenuCaption *)(FXMenuCommand *) ((FXMenuRadio *) x));
+}
+static void *_p_FXDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDict *) x));
+}
+static void *_p_FXShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXToolBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDirBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXScrollPaneTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXPopup *)(FXMenuPane *) ((FXScrollPane *) x));
+}
+static void *_p_FXToolBarTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *) (FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXDockSiteTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXDockSite *) x));
+}
+static void *_p_FXListBoxTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXListBox *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXTreeListBox *) x));
+}
+static void *_p_FXComboBoxTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXComboBox *) x));
+}
+static void *_p_FXShutterItemTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *) (FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXDockBarTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXDockBar *) x));
+}
+static void *_p_FXStatusBarTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *) (FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXDirBoxTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *) (FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXTabBarTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXTabBar *) x));
+}
+static void *_p_FXTabBookTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *) (FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXGroupBox *) x));
+}
+static void *_p_FXShutterTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *) (FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXHorizontalFrame *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXSpinner *) x));
+}
+static void *_p_FXMatrixTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXMatrix *) x));
+}
+static void *_p_FXSpringTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXSpring *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXFontSelector *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *) (FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXMenuBarTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *) (FXDockBar *)(FXToolBar *) ((FXMenuBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXSwitcher *) x));
+}
+static void *_p_FXMenuCheckTo_p_FXMenuCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXMenuCommand *)  ((FXMenuCheck *) x));
+}
+static void *_p_FXMenuRadioTo_p_FXMenuCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXMenuCommand *)  ((FXMenuRadio *) x));
+}
+static void *_p_FXMenuCommandTo_p_FXMenuCaption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXMenuCaption *)  ((FXMenuCommand *) x));
+}
+static void *_p_FXMenuCheckTo_p_FXMenuCaption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXMenuCaption *) (FXMenuCommand *) ((FXMenuCheck *) x));
+}
+static void *_p_FXMenuRadioTo_p_FXMenuCaption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXMenuCaption *) (FXMenuCommand *) ((FXMenuRadio *) x));
+}
+static void *_p_FXMenuTitleTo_p_FXMenuCaption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXMenuCaption *)  ((FXMenuTitle *) x));
+}
+static void *_p_FXMenuCascadeTo_p_FXMenuCaption(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXMenuCaption *)  ((FXMenuCascade *) x));
+}
+static void *_p_FXGradientBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShutterItemTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXMenuCheckTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXMenuCaption *)(FXMenuCommand *) ((FXMenuCheck *) x));
+}
+static void *_p_FXTabBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXMatrixTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXMenuPaneTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXPopup *) ((FXMenuPane *) x));
+}
+static void *_p_FXHeaderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXSplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSpringTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXMenuSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXMenuSeparator *) x));
+}
+static void *_p_FXProgressBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXToolTipTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXDockSiteTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXMenuCascadeTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXMenuCaption *) ((FXMenuCascade *) x));
+}
+static void *_p_FXColorRingTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXCanvasTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXColorWheelTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXScrollBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXComboBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStatusBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXKnobTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXMenuCommandTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXMenuCaption *) ((FXMenuCommand *) x));
+}
+static void *_p_FXRulerViewTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXStatusLineTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *)  ((FXWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXMenuCaptionTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXMenuCaption *) x));
+}
+static void *_p_FXMenuTitleTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXMenuCaption *) ((FXMenuTitle *) x));
+}
+static void *_p_FXMenuBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *)(FXToolBar *) ((FXMenuBar *) x));
+}
+static void *_p_FXDockBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXMenuRadioTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXMenuCaption *)(FXMenuCommand *) ((FXMenuRadio *) x));
+}
+static void *_p_FXShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXToolBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXScrollPaneTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXPopup *)(FXMenuPane *) ((FXScrollPane *) x));
+}
+static void *_p_FXDirBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXFileStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXFileStream *) x));
+}
+static void *_p_FXMemoryStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXMemoryStream *) x));
+}
+static void *_p_FXMenuBarTo_p_FXDockBar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDockBar *) (FXToolBar *) ((FXMenuBar *) x));
+}
+static void *_p_FXToolBarTo_p_FXDockBar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDockBar *)  ((FXToolBar *) x));
+}
+static void *_p_FXGradientBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShutterItemTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXMenuCheckTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXMenuCaption *)(FXMenuCommand *) ((FXMenuCheck *) x));
+}
+static void *_p_FXTabBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXMatrixTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXDrawableTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXDrawable *) x));
+}
+static void *_p_FXMenuPaneTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXPopup *) ((FXMenuPane *) x));
+}
+static void *_p_FXHeaderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXSplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSpringTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXMenuSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXMenuSeparator *) x));
+}
+static void *_p_FXProgressBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXToolTipTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXDockSiteTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXMenuCascadeTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXMenuCaption *) ((FXMenuCascade *) x));
+}
+static void *_p_FXColorRingTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXCanvasTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXColorWheelTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXVisualTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXVisual *) x));
+}
+static void *_p_FXScrollBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXFontTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXFont *) x));
+}
+static void *_p_FXComboBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStatusBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXCursor *) x));
+}
+static void *_p_FXKnobTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXMenuCommandTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXMenuCaption *) ((FXMenuCommand *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRulerViewTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXStatusLineTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXMainWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXMenuCaptionTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXMenuCaption *) x));
+}
+static void *_p_FXMenuTitleTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXMenuCaption *) ((FXMenuTitle *) x));
+}
+static void *_p_FXMenuBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *)(FXToolBar *) ((FXMenuBar *) x));
+}
+static void *_p_FXDockBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXMenuRadioTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXMenuCaption *)(FXMenuCommand *) ((FXMenuRadio *) x));
+}
+static void *_p_FXShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXToolBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDirBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXScrollPaneTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXPopup *)(FXMenuPane *) ((FXScrollPane *) x));
+}
+static swig_type_info _swigt__p_FXBitmap = {"_p_FXBitmap", "FXBitmap *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXComposite = {"_p_FXComposite", "FXComposite *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDriveBox = {"_p_FXDriveBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolTip = {"_p_FXToolTip", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTabBook = {"_p_FXTabBook", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGroupBox = {"_p_FXGroupBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusBar = {"_p_FXStatusBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollArea = {"_p_FXScrollArea", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRootWindow = {"_p_FXRootWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollWindow = {"_p_FXScrollWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTopWindow = {"_p_FXTopWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMainWindow = {"_p_FXMainWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplashWindow = {"_p_FXSplashWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXComboBox = {"_p_FXComboBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalFrame = {"_p_FXHorizontalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalFrame = {"_p_FXVerticalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FX4Splitter = {"_p_FX4Splitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplitter = {"_p_FXSplitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRealSpinner = {"_p_FXRealSpinner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSpinner = {"_p_FXSpinner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDirBox = {"_p_FXDirBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDirSelector = {"_p_FXDirSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileSelector = {"_p_FXFileSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorSelector = {"_p_FXColorSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFontSelector = {"_p_FXFontSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSwitcher = {"_p_FXSwitcher", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutter = {"_p_FXShutter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRulerView = {"_p_FXRulerView", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXListBox = {"_p_FXListBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTreeListBox = {"_p_FXTreeListBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutterItem = {"_p_FXShutterItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMatrix = {"_p_FXMatrix", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTabBar = {"_p_FXTabBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImageView = {"_p_FXImageView", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSpring = {"_p_FXSpring", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarShell = {"_p_FXToolBarShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockBar = {"_p_FXDockBar", "FXDockBar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDockSite = {"_p_FXDockSite", "FXDockSite *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDrawable = {"_p_FXDrawable", "FXDrawable *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGradientBar = {"_p_FXGradientBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorBar = {"_p_FXColorBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTextField = {"_p_FXTextField", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarTab = {"_p_FXToolBarTab", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollCorner = {"_p_FXScrollCorner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXArrowButton = {"_p_FXArrowButton", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHeader = {"_p_FXHeader", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImageFrame = {"_p_FXImageFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSeparator = {"_p_FXSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalSeparator = {"_p_FXHorizontalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalSeparator = {"_p_FXVerticalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXKnob = {"_p_FXKnob", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXProgressBar = {"_p_FXProgressBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXBitmapFrame = {"_p_FXBitmapFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSlider = {"_p_FXSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRealSlider = {"_p_FXRealSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorRing = {"_p_FXColorRing", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockHandler = {"_p_FXDockHandler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCanvas = {"_p_FXCanvas", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWheel = {"_p_FXColorWheel", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDial = {"_p_FXDial", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarGrip = {"_p_FXToolBarGrip", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollBar = {"_p_FXScrollBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFrame = {"_p_FXFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FX7Segment = {"_p_FX7Segment", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockTitle = {"_p_FXDockTitle", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusLine = {"_p_FXStatusLine", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWell = {"_p_FXColorWell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDragCorner = {"_p_FXDragCorner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRuler = {"_p_FXRuler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFont = {"_p_FXFont", "FXFont *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXIcon = {"_p_FXIcon", "FXIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXId = {"_p_FXId", "FXId *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXVisual = {"_p_FXVisual", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCursor = {"_p_FXCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCURCursor = {"_p_FXCURCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGIFCursor = {"_p_FXGIFCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMenuBar = {"_p_FXMenuBar", "FXMenuBar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMenuCaption = {"_p_FXMenuCaption", "FXMenuCaption *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMenuCascade = {"_p_FXMenuCascade", "FXMenuCascade *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMenuCheck = {"_p_FXMenuCheck", "FXMenuCheck *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMenuCommand = {"_p_FXMenuCommand", "FXMenuCommand *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMenuPane = {"_p_FXMenuPane", "FXMenuPane *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMenuRadio = {"_p_FXMenuRadio", "FXMenuRadio *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMenuSeparator = {"_p_FXMenuSeparator", "FXMenuSeparator *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXMenuTitle = {"_p_FXMenuTitle", "FXMenuTitle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXObject = {"_p_FXObject", "FXObject *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDocument = {"_p_FXDocument", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRegistry = {"_p_FXRegistry", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHeaderItem = {"_p_FXHeaderItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXIconDict = {"_p_FXIconDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileDict = {"_p_FXFileDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRecentFiles = {"_p_FXRecentFiles", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTranslator = {"_p_FXTranslator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXApp = {"_p_FXApp", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDict = {"_p_FXDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSettings = {"_p_FXSettings", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDataTarget = {"_p_FXDataTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDebugTarget = {"_p_FXDebugTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStringDict = {"_p_FXStringDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDelegator = {"_p_FXDelegator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXAccelTable = {"_p_FXAccelTable", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPacker = {"_p_FXPacker", "FXPacker *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXPopup = {"_p_FXPopup", "FXPopup *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRegion = {"_p_FXRegion", "FXRegion *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXScrollPane = {"_p_FXScrollPane", "FXScrollPane *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXShell = {"_p_FXShell", "FXShell *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXStream = {"_p_FXStream", "FXStream *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFileStream = {"_p_FXFileStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMemoryStream = {"_p_FXMemoryStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBar = {"_p_FXToolBar", "FXToolBar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXWindow = {"_p_FXWindow", "FXWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_char = {"_p_char", "char *|FXchar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "double *|FXdouble *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_float = {"_p_float", "float *|FXfloat *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "FXint *|int *|FXInputHandle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_long = {"_p_long", "long *|FXTime *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_short = {"_p_short", "short *|FXshort *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "FXuchar *|unsigned char *|FXbool *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "FXwchar *|FXDragType *|unsigned int *|FXuint *|FXColor *|FXSelector *|FXHotKey *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|FXuval *|FXPixel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|FXushort *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_FX4Splitter,
+  &_swigt__p_FX7Segment,
+  &_swigt__p_FXAccelTable,
+  &_swigt__p_FXApp,
+  &_swigt__p_FXArrowButton,
+  &_swigt__p_FXBitmap,
+  &_swigt__p_FXBitmapFrame,
+  &_swigt__p_FXCURCursor,
+  &_swigt__p_FXCanvas,
+  &_swigt__p_FXColorBar,
+  &_swigt__p_FXColorRing,
+  &_swigt__p_FXColorSelector,
+  &_swigt__p_FXColorWell,
+  &_swigt__p_FXColorWheel,
+  &_swigt__p_FXComboBox,
+  &_swigt__p_FXComposite,
+  &_swigt__p_FXCursor,
+  &_swigt__p_FXDataTarget,
+  &_swigt__p_FXDebugTarget,
+  &_swigt__p_FXDelegator,
+  &_swigt__p_FXDial,
+  &_swigt__p_FXDict,
+  &_swigt__p_FXDirBox,
+  &_swigt__p_FXDirSelector,
+  &_swigt__p_FXDockBar,
+  &_swigt__p_FXDockHandler,
+  &_swigt__p_FXDockSite,
+  &_swigt__p_FXDockTitle,
+  &_swigt__p_FXDocument,
+  &_swigt__p_FXDragCorner,
+  &_swigt__p_FXDrawable,
+  &_swigt__p_FXDriveBox,
+  &_swigt__p_FXFileDict,
+  &_swigt__p_FXFileSelector,
+  &_swigt__p_FXFileStream,
+  &_swigt__p_FXFont,
+  &_swigt__p_FXFontSelector,
+  &_swigt__p_FXFrame,
+  &_swigt__p_FXGIFCursor,
+  &_swigt__p_FXGradientBar,
+  &_swigt__p_FXGroupBox,
+  &_swigt__p_FXHeader,
+  &_swigt__p_FXHeaderItem,
+  &_swigt__p_FXHorizontalFrame,
+  &_swigt__p_FXHorizontalSeparator,
+  &_swigt__p_FXIcon,
+  &_swigt__p_FXIconDict,
+  &_swigt__p_FXId,
+  &_swigt__p_FXImageFrame,
+  &_swigt__p_FXImageView,
+  &_swigt__p_FXKnob,
+  &_swigt__p_FXListBox,
+  &_swigt__p_FXMainWindow,
+  &_swigt__p_FXMatrix,
+  &_swigt__p_FXMemoryStream,
+  &_swigt__p_FXMenuBar,
+  &_swigt__p_FXMenuCaption,
+  &_swigt__p_FXMenuCascade,
+  &_swigt__p_FXMenuCheck,
+  &_swigt__p_FXMenuCommand,
+  &_swigt__p_FXMenuPane,
+  &_swigt__p_FXMenuRadio,
+  &_swigt__p_FXMenuSeparator,
+  &_swigt__p_FXMenuTitle,
+  &_swigt__p_FXObject,
+  &_swigt__p_FXPacker,
+  &_swigt__p_FXPopup,
+  &_swigt__p_FXProgressBar,
+  &_swigt__p_FXRealSlider,
+  &_swigt__p_FXRealSpinner,
+  &_swigt__p_FXRecentFiles,
+  &_swigt__p_FXRegion,
+  &_swigt__p_FXRegistry,
+  &_swigt__p_FXRootWindow,
+  &_swigt__p_FXRuler,
+  &_swigt__p_FXRulerView,
+  &_swigt__p_FXScrollArea,
+  &_swigt__p_FXScrollBar,
+  &_swigt__p_FXScrollCorner,
+  &_swigt__p_FXScrollPane,
+  &_swigt__p_FXScrollWindow,
+  &_swigt__p_FXSeparator,
+  &_swigt__p_FXSettings,
+  &_swigt__p_FXShell,
+  &_swigt__p_FXShutter,
+  &_swigt__p_FXShutterItem,
+  &_swigt__p_FXSlider,
+  &_swigt__p_FXSpinner,
+  &_swigt__p_FXSplashWindow,
+  &_swigt__p_FXSplitter,
+  &_swigt__p_FXSpring,
+  &_swigt__p_FXStatusBar,
+  &_swigt__p_FXStatusLine,
+  &_swigt__p_FXStream,
+  &_swigt__p_FXStringDict,
+  &_swigt__p_FXSwitcher,
+  &_swigt__p_FXTabBar,
+  &_swigt__p_FXTabBook,
+  &_swigt__p_FXTextField,
+  &_swigt__p_FXToolBar,
+  &_swigt__p_FXToolBarGrip,
+  &_swigt__p_FXToolBarShell,
+  &_swigt__p_FXToolBarTab,
+  &_swigt__p_FXToolTip,
+  &_swigt__p_FXTopWindow,
+  &_swigt__p_FXTranslator,
+  &_swigt__p_FXTreeListBox,
+  &_swigt__p_FXVerticalFrame,
+  &_swigt__p_FXVerticalSeparator,
+  &_swigt__p_FXVisual,
+  &_swigt__p_FXWindow,
+  &_swigt__p_char,
+  &_swigt__p_double,
+  &_swigt__p_float,
+  &_swigt__p_int,
+  &_swigt__p_long,
+  &_swigt__p_short,
+  &_swigt__p_unsigned_char,
+  &_swigt__p_unsigned_int,
+  &_swigt__p_unsigned_long,
+  &_swigt__p_unsigned_short,
+};
+
+static swig_cast_info _swigc__p_FXBitmap[] = {  {&_swigt__p_FXBitmap, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDriveBox[] = {{&_swigt__p_FXDriveBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolTip[] = {{&_swigt__p_FXToolTip, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabBook[] = {{&_swigt__p_FXTabBook, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGroupBox[] = {{&_swigt__p_FXGroupBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusBar[] = {{&_swigt__p_FXStatusBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollArea[] = {{&_swigt__p_FXScrollArea, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRootWindow[] = {{&_swigt__p_FXRootWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollWindow[] = {{&_swigt__p_FXScrollWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTopWindow[] = {{&_swigt__p_FXTopWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMainWindow[] = {{&_swigt__p_FXMainWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplashWindow[] = {{&_swigt__p_FXSplashWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComboBox[] = {{&_swigt__p_FXComboBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalFrame[] = {{&_swigt__p_FXHorizontalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalFrame[] = {{&_swigt__p_FXVerticalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FX4Splitter[] = {{&_swigt__p_FX4Splitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplitter[] = {{&_swigt__p_FXSplitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSpinner[] = {{&_swigt__p_FXRealSpinner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpinner[] = {{&_swigt__p_FXSpinner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirBox[] = {{&_swigt__p_FXDirBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirSelector[] = {{&_swigt__p_FXDirSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileSelector[] = {{&_swigt__p_FXFileSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorSelector[] = {{&_swigt__p_FXColorSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFontSelector[] = {{&_swigt__p_FXFontSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSwitcher[] = {{&_swigt__p_FXSwitcher, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutter[] = {{&_swigt__p_FXShutter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRulerView[] = {{&_swigt__p_FXRulerView, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXListBox[] = {{&_swigt__p_FXListBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTreeListBox[] = {{&_swigt__p_FXTreeListBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutterItem[] = {{&_swigt__p_FXShutterItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMatrix[] = {{&_swigt__p_FXMatrix, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabBar[] = {{&_swigt__p_FXTabBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageView[] = {{&_swigt__p_FXImageView, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpring[] = {{&_swigt__p_FXSpring, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarShell[] = {{&_swigt__p_FXToolBarShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComposite[] = {  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMenuPane, _p_FXMenuPaneTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMenuBar, _p_FXMenuBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXComposite, 0, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXComposite, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXComposite, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXComposite, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollPane, _p_FXScrollPaneTo_p_FXComposite, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXComposite, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockBar[] = {  {&_swigt__p_FXMenuBar, _p_FXMenuBarTo_p_FXDockBar, 0, 0},  {&_swigt__p_FXDockBar, 0, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXDockBar, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockSite[] = {  {&_swigt__p_FXDockSite, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGradientBar[] = {{&_swigt__p_FXGradientBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorBar[] = {{&_swigt__p_FXColorBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTextField[] = {{&_swigt__p_FXTextField, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarTab[] = {{&_swigt__p_FXToolBarTab, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollCorner[] = {{&_swigt__p_FXScrollCorner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXArrowButton[] = {{&_swigt__p_FXArrowButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeader[] = {{&_swigt__p_FXHeader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageFrame[] = {{&_swigt__p_FXImageFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSeparator[] = {{&_swigt__p_FXSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalSeparator[] = {{&_swigt__p_FXHorizontalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalSeparator[] = {{&_swigt__p_FXVerticalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXKnob[] = {{&_swigt__p_FXKnob, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXProgressBar[] = {{&_swigt__p_FXProgressBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBitmapFrame[] = {{&_swigt__p_FXBitmapFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSlider[] = {{&_swigt__p_FXSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSlider[] = {{&_swigt__p_FXRealSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorRing[] = {{&_swigt__p_FXColorRing, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockHandler[] = {{&_swigt__p_FXDockHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCanvas[] = {{&_swigt__p_FXCanvas, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWheel[] = {{&_swigt__p_FXColorWheel, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDial[] = {{&_swigt__p_FXDial, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarGrip[] = {{&_swigt__p_FXToolBarGrip, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollBar[] = {{&_swigt__p_FXScrollBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFrame[] = {{&_swigt__p_FXFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FX7Segment[] = {{&_swigt__p_FX7Segment, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockTitle[] = {{&_swigt__p_FXDockTitle, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusLine[] = {{&_swigt__p_FXStatusLine, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWell[] = {{&_swigt__p_FXColorWell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDragCorner[] = {{&_swigt__p_FXDragCorner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRuler[] = {{&_swigt__p_FXRuler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDrawable[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMenuCheck, _p_FXMenuCheckTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDrawable, 0, 0, 0},  {&_swigt__p_FXMenuPane, _p_FXMenuPaneTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMenuSeparator, _p_FXMenuSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMenuCascade, _p_FXMenuCascadeTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMenuCommand, _p_FXMenuCommandTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMenuBar, _p_FXMenuBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMenuCaption, _p_FXMenuCaptionTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMenuTitle, _p_FXMenuTitleTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMenuRadio, _p_FXMenuRadioTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollPane, _p_FXScrollPaneTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXDrawable, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFont[] = {  {&_swigt__p_FXFont, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIcon[] = {  {&_swigt__p_FXIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVisual[] = {{&_swigt__p_FXVisual, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCursor[] = {{&_swigt__p_FXCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCURCursor[] = {{&_swigt__p_FXCURCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGIFCursor[] = {{&_swigt__p_FXGIFCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXId[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXId, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXId, 0, 0},  {&_swigt__p_FXMenuCheck, _p_FXMenuCheckTo_p_FXId, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXId, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXId, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXId, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXId, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXId, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXId, 0, 0},  {&_swigt__p_FXMenuPane, _p_FXMenuPaneTo_p_FXId, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXId, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXId, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXId, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXId, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXId, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXId, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXId, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXMenuSeparator, _p_FXMenuSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXId, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXId, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXId, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXId, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXId, 0, 0},  {&_swigt__p_FXMenuCascade, _p_FXMenuCascadeTo_p_FXId, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXId, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXId, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXId, 0, 0},  {&_swigt__p_FXId, 0, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXId, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXId, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXId, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXId, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXId, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXId, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXMenuCommand, _p_FXMenuCommandTo_p_FXId, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXId, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXId, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXMenuBar, _p_FXMenuBarTo_p_FXId, 0, 0},  {&_swigt__p_FXMenuCaption, _p_FXMenuCaptionTo_p_FXId, 0, 0},  {&_swigt__p_FXMenuTitle, _p_FXMenuTitleTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXId, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXId, 0, 0},  {&_swigt__p_FXMenuRadio, _p_FXMenuRadioTo_p_FXId, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXId, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXId, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXId, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXId, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollPane, _p_FXScrollPaneTo_p_FXId, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXId, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMenuBar[] = {  {&_swigt__p_FXMenuBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMenuCaption[] = {  {&_swigt__p_FXMenuCaption, 0, 0, 0},  {&_swigt__p_FXMenuCommand, _p_FXMenuCommandTo_p_FXMenuCaption, 0, 0},  {&_swigt__p_FXMenuCheck, _p_FXMenuCheckTo_p_FXMenuCaption, 0, 0},  {&_swigt__p_FXMenuRadio, _p_FXMenuRadioTo_p_FXMenuCaption, 0, 0},  {&_swigt__p_FXMenuTitle, _p_FXMenuTitleTo_p_FXMenuCaption, 0, 0},  {&_swigt__p_FXMenuCascade, _p_FXMenuCascadeTo_p_FXMenuCaption, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMenuCascade[] = {  {&_swigt__p_FXMenuCascade, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMenuCheck[] = {  {&_swigt__p_FXMenuCheck, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMenuCommand[] = {  {&_swigt__p_FXMenuCommand, 0, 0, 0},  {&_swigt__p_FXMenuCheck, _p_FXMenuCheckTo_p_FXMenuCommand, 0, 0},  {&_swigt__p_FXMenuRadio, _p_FXMenuRadioTo_p_FXMenuCommand, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMenuPane[] = {  {&_swigt__p_FXMenuPane, 0, 0, 0},  {&_swigt__p_FXScrollPane, _p_FXScrollPaneTo_p_FXMenuPane, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMenuRadio[] = {  {&_swigt__p_FXMenuRadio, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMenuSeparator[] = {  {&_swigt__p_FXMenuSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMenuTitle[] = {  {&_swigt__p_FXMenuTitle, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDocument[] = {{&_swigt__p_FXDocument, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegistry[] = {{&_swigt__p_FXRegistry, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeaderItem[] = {{&_swigt__p_FXHeaderItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIconDict[] = {{&_swigt__p_FXIconDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileDict[] = {{&_swigt__p_FXFileDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRecentFiles[] = {{&_swigt__p_FXRecentFiles, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTranslator[] = {{&_swigt__p_FXTranslator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXApp[] = {{&_swigt__p_FXApp, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDict[] = {{&_swigt__p_FXDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSettings[] = {{&_swigt__p_FXSettings, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDataTarget[] = {{&_swigt__p_FXDataTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDebugTarget[] = {{&_swigt__p_FXDebugTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStringDict[] = {{&_swigt__p_FXStringDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDelegator[] = {{&_swigt__p_FXDelegator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXAccelTable[] = {{&_swigt__p_FXAccelTable, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXObject[] = {  {&_swigt__p_FXDocument, _p_FXDocumentTo_p_FXObject, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXRegistry, _p_FXRegistryTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeaderItem, _p_FXHeaderItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXMenuCheck, _p_FXMenuCheckTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXObject, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXObject, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXIconDict, _p_FXIconDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileDict, _p_FXFileDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXRecentFiles, _p_FXRecentFilesTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXObject, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXObject, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXObject, 0, 0},  {&_swigt__p_FXMenuPane, _p_FXMenuPaneTo_p_FXObject, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FXTranslator, _p_FXTranslatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXObject, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXObject, 0, 0},  {&_swigt__p_FXApp, _p_FXAppTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXMenuSeparator, _p_FXMenuSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXObject, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXObject, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXObject, 0, 0},  {&_swigt__p_FXDict, _p_FXDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXSettings, _p_FXSettingsTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXObject, 0, 0},  {&_swigt__p_FXMenuCascade, _p_FXMenuCascadeTo_p_FXObject, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXObject, 0, 0},  {&_swigt__p_FXDataTarget, _p_FXDataTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDebugTarget, _p_FXDebugTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXObject, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXObject, 0, 0},  {&_swigt__p_FXId, _p_FXIdTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXObject, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXObject, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXStringDict, _p_FXStringDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXDelegator, _p_FXDelegatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXAccelTable, _p_FXAccelTableTo_p_FXObject, 0, 0},  {&_swigt__p_FXObject, 0, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXMenuCommand, _p_FXMenuCommandTo_p_FXObject, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXObject, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXMenuBar, _p_FXMenuBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXMenuCaption, _p_FXMenuCaptionTo_p_FXObject, 0, 0},  {&_swigt__p_FXMenuTitle, _p_FXMenuTitleTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXObject, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXMenuRadio, _p_FXMenuRadioTo_p_FXObject, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXObject, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXObject, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXObject, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollPane, _p_FXScrollPaneTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXObject, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPacker[] = {  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXPacker, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXPacker, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXPacker, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXPacker, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXPacker, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXPacker, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXPacker, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXPacker, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXPacker, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXPacker, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXPacker, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXPacker, 0, 0},  {&_swigt__p_FXPacker, 0, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXPacker, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXPacker, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXPacker, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXPacker, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXPacker, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXPacker, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXPacker, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXPacker, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXPacker, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXPacker, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXPacker, 0, 0},  {&_swigt__p_FXMenuBar, _p_FXMenuBarTo_p_FXPacker, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXPacker, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXPacker, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPopup[] = {  {&_swigt__p_FXPopup, 0, 0, 0},  {&_swigt__p_FXMenuPane, _p_FXMenuPaneTo_p_FXPopup, 0, 0},  {&_swigt__p_FXScrollPane, _p_FXScrollPaneTo_p_FXPopup, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegion[] = {  {&_swigt__p_FXRegion, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollPane[] = {  {&_swigt__p_FXScrollPane, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShell[] = {  {&_swigt__p_FXShell, 0, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXShell, 0, 0},  {&_swigt__p_FXMenuPane, _p_FXMenuPaneTo_p_FXShell, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXShell, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXShell, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXShell, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXShell, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXShell, 0, 0},  {&_swigt__p_FXScrollPane, _p_FXScrollPaneTo_p_FXShell, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileStream[] = {{&_swigt__p_FXFileStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMemoryStream[] = {{&_swigt__p_FXMemoryStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStream[] = {  {&_swigt__p_FXFileStream, _p_FXFileStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXMemoryStream, _p_FXMemoryStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBar[] = {  {&_swigt__p_FXMenuBar, _p_FXMenuBarTo_p_FXToolBar, 0, 0},  {&_swigt__p_FXToolBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXWindow[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMenuCheck, _p_FXMenuCheckTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMenuPane, _p_FXMenuPaneTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXWindow, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMenuSeparator, _p_FXMenuSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXWindow, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXWindow, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMenuCascade, _p_FXMenuCascadeTo_p_FXWindow, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXWindow, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMenuCommand, _p_FXMenuCommandTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXWindow, 0, 0, 0},  {&_swigt__p_FXMenuBar, _p_FXMenuBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMenuCaption, _p_FXMenuCaptionTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMenuTitle, _p_FXMenuTitleTo_p_FXWindow, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMenuRadio, _p_FXMenuRadioTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollPane, _p_FXScrollPaneTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXWindow, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
+
+static swig_cast_info *swig_cast_initial[] = {
+  _swigc__p_FX4Splitter,
+  _swigc__p_FX7Segment,
+  _swigc__p_FXAccelTable,
+  _swigc__p_FXApp,
+  _swigc__p_FXArrowButton,
+  _swigc__p_FXBitmap,
+  _swigc__p_FXBitmapFrame,
+  _swigc__p_FXCURCursor,
+  _swigc__p_FXCanvas,
+  _swigc__p_FXColorBar,
+  _swigc__p_FXColorRing,
+  _swigc__p_FXColorSelector,
+  _swigc__p_FXColorWell,
+  _swigc__p_FXColorWheel,
+  _swigc__p_FXComboBox,
+  _swigc__p_FXComposite,
+  _swigc__p_FXCursor,
+  _swigc__p_FXDataTarget,
+  _swigc__p_FXDebugTarget,
+  _swigc__p_FXDelegator,
+  _swigc__p_FXDial,
+  _swigc__p_FXDict,
+  _swigc__p_FXDirBox,
+  _swigc__p_FXDirSelector,
+  _swigc__p_FXDockBar,
+  _swigc__p_FXDockHandler,
+  _swigc__p_FXDockSite,
+  _swigc__p_FXDockTitle,
+  _swigc__p_FXDocument,
+  _swigc__p_FXDragCorner,
+  _swigc__p_FXDrawable,
+  _swigc__p_FXDriveBox,
+  _swigc__p_FXFileDict,
+  _swigc__p_FXFileSelector,
+  _swigc__p_FXFileStream,
+  _swigc__p_FXFont,
+  _swigc__p_FXFontSelector,
+  _swigc__p_FXFrame,
+  _swigc__p_FXGIFCursor,
+  _swigc__p_FXGradientBar,
+  _swigc__p_FXGroupBox,
+  _swigc__p_FXHeader,
+  _swigc__p_FXHeaderItem,
+  _swigc__p_FXHorizontalFrame,
+  _swigc__p_FXHorizontalSeparator,
+  _swigc__p_FXIcon,
+  _swigc__p_FXIconDict,
+  _swigc__p_FXId,
+  _swigc__p_FXImageFrame,
+  _swigc__p_FXImageView,
+  _swigc__p_FXKnob,
+  _swigc__p_FXListBox,
+  _swigc__p_FXMainWindow,
+  _swigc__p_FXMatrix,
+  _swigc__p_FXMemoryStream,
+  _swigc__p_FXMenuBar,
+  _swigc__p_FXMenuCaption,
+  _swigc__p_FXMenuCascade,
+  _swigc__p_FXMenuCheck,
+  _swigc__p_FXMenuCommand,
+  _swigc__p_FXMenuPane,
+  _swigc__p_FXMenuRadio,
+  _swigc__p_FXMenuSeparator,
+  _swigc__p_FXMenuTitle,
+  _swigc__p_FXObject,
+  _swigc__p_FXPacker,
+  _swigc__p_FXPopup,
+  _swigc__p_FXProgressBar,
+  _swigc__p_FXRealSlider,
+  _swigc__p_FXRealSpinner,
+  _swigc__p_FXRecentFiles,
+  _swigc__p_FXRegion,
+  _swigc__p_FXRegistry,
+  _swigc__p_FXRootWindow,
+  _swigc__p_FXRuler,
+  _swigc__p_FXRulerView,
+  _swigc__p_FXScrollArea,
+  _swigc__p_FXScrollBar,
+  _swigc__p_FXScrollCorner,
+  _swigc__p_FXScrollPane,
+  _swigc__p_FXScrollWindow,
+  _swigc__p_FXSeparator,
+  _swigc__p_FXSettings,
+  _swigc__p_FXShell,
+  _swigc__p_FXShutter,
+  _swigc__p_FXShutterItem,
+  _swigc__p_FXSlider,
+  _swigc__p_FXSpinner,
+  _swigc__p_FXSplashWindow,
+  _swigc__p_FXSplitter,
+  _swigc__p_FXSpring,
+  _swigc__p_FXStatusBar,
+  _swigc__p_FXStatusLine,
+  _swigc__p_FXStream,
+  _swigc__p_FXStringDict,
+  _swigc__p_FXSwitcher,
+  _swigc__p_FXTabBar,
+  _swigc__p_FXTabBook,
+  _swigc__p_FXTextField,
+  _swigc__p_FXToolBar,
+  _swigc__p_FXToolBarGrip,
+  _swigc__p_FXToolBarShell,
+  _swigc__p_FXToolBarTab,
+  _swigc__p_FXToolTip,
+  _swigc__p_FXTopWindow,
+  _swigc__p_FXTranslator,
+  _swigc__p_FXTreeListBox,
+  _swigc__p_FXVerticalFrame,
+  _swigc__p_FXVerticalSeparator,
+  _swigc__p_FXVisual,
+  _swigc__p_FXWindow,
+  _swigc__p_char,
+  _swigc__p_double,
+  _swigc__p_float,
+  _swigc__p_int,
+  _swigc__p_long,
+  _swigc__p_short,
+  _swigc__p_unsigned_char,
+  _swigc__p_unsigned_int,
+  _swigc__p_unsigned_long,
+  _swigc__p_unsigned_short,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned statically to an initial
+ * array. We just loop through that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded.
+ * There are three cases to handle:
+ *  1) If the cast->type has already been loaded AND the type we are adding
+ *     casting info to has not been loaded (it is in this module), THEN we
+ *     replace the cast->type pointer with the type pointer that has already
+ *     been loaded.
+ *  2) If BOTH types (the one we are adding casting info to, and the
+ *     cast->type) are loaded, THEN the cast info has already been loaded by
+ *     the previous module so we just ignore it.
+ *  3) Finally, if cast->type has not already been loaded, then we add that
+ *     swig_cast_info to the linked list (because the cast->type) pointer will
+ *     be correct.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* c-mode */
+#endif
+#endif
+
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+  size_t i;
+  swig_module_info *module_head, *iter;
+  int init;
+
+  /* check to see if the circular list has been setup, if not, set it up */
+  if (swig_module.next==0) {
+    /* Initialize the swig_module */
+    swig_module.type_initial = swig_type_initial;
+    swig_module.cast_initial = swig_cast_initial;
+    swig_module.next = &swig_module;
+    init = 1;
+  } else {
+    init = 0;
+  }
+
+  /* Try and load any already created modules */
+  module_head = SWIG_GetModule(clientdata);
+  if (!module_head) {
+    /* This is the first module loaded for this interpreter */
+    /* so set the swig module into the interpreter */
+    SWIG_SetModule(clientdata, &swig_module);
+  } else {
+    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+    iter=module_head;
+    do {
+      if (iter==&swig_module) {
+        /* Our module is already in the list, so there's nothing more to do. */
+        return;
+      }
+      iter=iter->next;
+    } while (iter!= module_head);
+
+    /* otherwise we must add our module into the list */
+    swig_module.next = module_head->next;
+    module_head->next = &swig_module;
+  }
+
+  /* When multiple interpreters are used, a module could have already been initialized in
+     a different interpreter, but not yet have a pointer in this interpreter.
+     In this case, we do not want to continue adding types... everything should be
+     set up already */
+  if (init == 0) return;
+
+  /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+  for (i = 0; i < swig_module.size; ++i) {
+    swig_type_info *type = 0;
+    swig_type_info *ret;
+    swig_cast_info *cast;
+
+#ifdef SWIGRUNTIME_DEBUG
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+
+    /* if there is another module already loaded */
+    if (swig_module.next != &swig_module) {
+      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
+    }
+    if (type) {
+      /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+      if (swig_module.type_initial[i]->clientdata) {
+	type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+      }
+    } else {
+      type = swig_module.type_initial[i];
+    }
+
+    /* Insert casting types */
+    cast = swig_module.cast_initial[i];
+    while (cast->type) {
+
+      /* Don't need to add information already in the list */
+      ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+      if (swig_module.next != &swig_module) {
+        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+      }
+      if (ret) {
+	if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+	  cast->type = ret;
+	  ret = 0;
+	} else {
+	  /* Check for casting already in the list */
+	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+	  if (!ocast) ret = 0;
+	}
+      }
+
+      if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+        if (type->cast) {
+          type->cast->prev = cast;
+          cast->next = type->cast;
+        }
+        type->cast = cast;
+      }
+      cast++;
+    }
+    /* Set entry in modules->types array equal to the type */
+    swig_module.types[i] = type;
+  }
+  swig_module.types[i] = 0;
+
+#ifdef SWIGRUNTIME_DEBUG
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+  for (i = 0; i < swig_module.size; ++i) {
+    int j = 0;
+    swig_cast_info *cast = swig_module.cast_initial[i];
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    while (cast->type) {
+      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+      cast++;
+      ++j;
+    }
+  printf("---- Total casts: %d\n",j);
+  }
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types.  It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+  size_t i;
+  swig_cast_info *equiv;
+  static int init_run = 0;
+
+  if (init_run) return;
+  init_run = 1;
+
+  for (i = 0; i < swig_module.size; i++) {
+    if (swig_module.types[i]->clientdata) {
+      equiv = swig_module.types[i]->cast;
+      while (equiv) {
+        if (!equiv->converter) {
+          if (equiv->type && !equiv->type->clientdata)
+            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+        }
+        equiv = equiv->next;
+      }
+    }
+  }
+}
+
+#ifdef __cplusplus
+#if 0
+{ /* c-mode */
+#endif
+}
+#endif
+
+/*
+
+*/
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void Init_menu(void) {
+  size_t i;
+  
+  SWIG_InitRuntime();
+  
+  
+  SWIG_InitializeModule(0);
+  for (i = 0; i < swig_module.size; i++) {
+    SWIG_define_class(swig_module.types[i]);
+  }
+  
+  SWIG_RubyInitializeTrackings();
+  
+  
+  
+  
+  
+  SwigClassFXMenuPane.klass = rb_define_class_under(mFox, "FXMenuPane", ((swig_class *) SWIGTYPE_p_FXPopup->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMenuPane, (void *) &SwigClassFXMenuPane);
+  rb_define_alloc_func(SwigClassFXMenuPane.klass, _wrap_FXMenuPane_allocate);
+  rb_define_method(SwigClassFXMenuPane.klass, "initialize", VALUEFUNC(_wrap_new_FXMenuPane), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "save", VALUEFUNC(_wrap_FXMenuPane_save), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "load", VALUEFUNC(_wrap_FXMenuPane_load), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "create", VALUEFUNC(_wrap_FXMenuPane_create), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "detach", VALUEFUNC(_wrap_FXMenuPane_detach), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "destroy", VALUEFUNC(_wrap_FXMenuPane_destroy), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "resize", VALUEFUNC(_wrap_FXMenuPane_resize), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXMenuPane_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXMenuPane_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXMenuPane_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXMenuPane_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "canFocus", VALUEFUNC(_wrap_FXMenuPane_canFocus), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "setFocus", VALUEFUNC(_wrap_FXMenuPane_setFocus), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "killFocus", VALUEFUNC(_wrap_FXMenuPane_killFocus), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "changeFocus", VALUEFUNC(_wrap_FXMenuPane_changeFocus), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "setDefault", VALUEFUNC(_wrap_FXMenuPane_setDefault), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "enable", VALUEFUNC(_wrap_FXMenuPane_enable), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "disable", VALUEFUNC(_wrap_FXMenuPane_disable), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "raiseWindow", VALUEFUNC(_wrap_FXMenuPane_raiseWindow), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "lower", VALUEFUNC(_wrap_FXMenuPane_lower), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "move", VALUEFUNC(_wrap_FXMenuPane_move), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "position", VALUEFUNC(_wrap_FXMenuPane_position), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "layout", VALUEFUNC(_wrap_FXMenuPane_layout), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "recalc", VALUEFUNC(_wrap_FXMenuPane_recalc), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "reparent", VALUEFUNC(_wrap_FXMenuPane_reparent), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "show", VALUEFUNC(_wrap_FXMenuPane_show), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "hide", VALUEFUNC(_wrap_FXMenuPane_hide), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "isComposite", VALUEFUNC(_wrap_FXMenuPane_isComposite), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "contains", VALUEFUNC(_wrap_FXMenuPane_contains), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXMenuPane_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "setBackColor", VALUEFUNC(_wrap_FXMenuPane_setBackColor), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "tr", VALUEFUNC(_wrap_FXMenuPane_tr), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "dropEnable", VALUEFUNC(_wrap_FXMenuPane_dropEnable), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "dropDisable", VALUEFUNC(_wrap_FXMenuPane_dropDisable), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "setShape", VALUEFUNC(_wrap_FXMenuPane_setShape), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "clearShape", VALUEFUNC(_wrap_FXMenuPane_clearShape), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "popup", VALUEFUNC(_wrap_FXMenuPane_popup), -1);
+  rb_define_method(SwigClassFXMenuPane.klass, "popdown", VALUEFUNC(_wrap_FXMenuPane_popdown), -1);
+  SwigClassFXMenuPane.mark = (void (*)(void *)) FXRbMenuPane::markfunc;
+  SwigClassFXMenuPane.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXMenuPane.trackObjects = 0;
+  
+  SWIGTYPE_p_FXMenuPane->dcast = (swig_dycast_func) FXMenuPane_dynamic_cast;
+  
+  
+  SwigClassFXScrollPane.klass = rb_define_class_under(mFox, "FXScrollPane", ((swig_class *) SWIGTYPE_p_FXMenuPane->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXScrollPane, (void *) &SwigClassFXScrollPane);
+  rb_define_alloc_func(SwigClassFXScrollPane.klass, _wrap_FXScrollPane_allocate);
+  rb_define_method(SwigClassFXScrollPane.klass, "initialize", VALUEFUNC(_wrap_new_FXScrollPane), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "onCmdIncrement", VALUEFUNC(_wrap_FXScrollPane_onCmdIncrement), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "onCmdDecrement", VALUEFUNC(_wrap_FXScrollPane_onCmdDecrement), -1);
+  rb_define_const(SwigClassFXScrollPane.klass, "ID_SCROLL_DN", SWIG_From_int(static_cast< int >(FXScrollPane::ID_SCROLL_DN)));
+  rb_define_const(SwigClassFXScrollPane.klass, "ID_SCROLL_UP", SWIG_From_int(static_cast< int >(FXScrollPane::ID_SCROLL_UP)));
+  rb_define_const(SwigClassFXScrollPane.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXScrollPane::ID_LAST)));
+  rb_define_method(SwigClassFXScrollPane.klass, "numVisible", VALUEFUNC(_wrap_FXScrollPane_numVisible), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "numVisible=", VALUEFUNC(_wrap_FXScrollPane_numVisiblee___), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "getTopItem", VALUEFUNC(_wrap_FXScrollPane_getTopItem), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "setTopItem", VALUEFUNC(_wrap_FXScrollPane_setTopItem), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "save", VALUEFUNC(_wrap_FXScrollPane_save), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "load", VALUEFUNC(_wrap_FXScrollPane_load), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "create", VALUEFUNC(_wrap_FXScrollPane_create), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "detach", VALUEFUNC(_wrap_FXScrollPane_detach), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "destroy", VALUEFUNC(_wrap_FXScrollPane_destroy), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "resize", VALUEFUNC(_wrap_FXScrollPane_resize), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXScrollPane_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXScrollPane_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXScrollPane_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXScrollPane_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "canFocus", VALUEFUNC(_wrap_FXScrollPane_canFocus), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "setFocus", VALUEFUNC(_wrap_FXScrollPane_setFocus), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "killFocus", VALUEFUNC(_wrap_FXScrollPane_killFocus), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "changeFocus", VALUEFUNC(_wrap_FXScrollPane_changeFocus), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "setDefault", VALUEFUNC(_wrap_FXScrollPane_setDefault), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "enable", VALUEFUNC(_wrap_FXScrollPane_enable), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "disable", VALUEFUNC(_wrap_FXScrollPane_disable), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "raiseWindow", VALUEFUNC(_wrap_FXScrollPane_raiseWindow), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "lower", VALUEFUNC(_wrap_FXScrollPane_lower), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "move", VALUEFUNC(_wrap_FXScrollPane_move), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "position", VALUEFUNC(_wrap_FXScrollPane_position), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "layout", VALUEFUNC(_wrap_FXScrollPane_layout), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "recalc", VALUEFUNC(_wrap_FXScrollPane_recalc), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "reparent", VALUEFUNC(_wrap_FXScrollPane_reparent), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "show", VALUEFUNC(_wrap_FXScrollPane_show), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "hide", VALUEFUNC(_wrap_FXScrollPane_hide), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "isComposite", VALUEFUNC(_wrap_FXScrollPane_isComposite), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "contains", VALUEFUNC(_wrap_FXScrollPane_contains), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXScrollPane_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "setBackColor", VALUEFUNC(_wrap_FXScrollPane_setBackColor), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "tr", VALUEFUNC(_wrap_FXScrollPane_tr), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "dropEnable", VALUEFUNC(_wrap_FXScrollPane_dropEnable), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "dropDisable", VALUEFUNC(_wrap_FXScrollPane_dropDisable), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "setShape", VALUEFUNC(_wrap_FXScrollPane_setShape), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "clearShape", VALUEFUNC(_wrap_FXScrollPane_clearShape), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "popup", VALUEFUNC(_wrap_FXScrollPane_popup), -1);
+  rb_define_method(SwigClassFXScrollPane.klass, "popdown", VALUEFUNC(_wrap_FXScrollPane_popdown), -1);
+  SwigClassFXScrollPane.mark = (void (*)(void *)) FXRbScrollPane::markfunc;
+  SwigClassFXScrollPane.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXScrollPane.trackObjects = 0;
+  rb_define_const(mFox, "MENU_AUTOGRAY", SWIG_From_int(static_cast< int >(MENU_AUTOGRAY)));
+  rb_define_const(mFox, "MENU_AUTOHIDE", SWIG_From_int(static_cast< int >(MENU_AUTOHIDE)));
+  
+  SwigClassFXMenuCaption.klass = rb_define_class_under(mFox, "FXMenuCaption", ((swig_class *) SWIGTYPE_p_FXWindow->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMenuCaption, (void *) &SwigClassFXMenuCaption);
+  rb_define_alloc_func(SwigClassFXMenuCaption.klass, _wrap_FXMenuCaption_allocate);
+  rb_define_method(SwigClassFXMenuCaption.klass, "initialize", VALUEFUNC(_wrap_new_FXMenuCaption), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "onPaint", VALUEFUNC(_wrap_FXMenuCaption_onPaint), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "onUpdate", VALUEFUNC(_wrap_FXMenuCaption_onUpdate), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "onCmdSetStringValue", VALUEFUNC(_wrap_FXMenuCaption_onCmdSetStringValue), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "onCmdGetStringValue", VALUEFUNC(_wrap_FXMenuCaption_onCmdGetStringValue), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "onCmdSetIconValue", VALUEFUNC(_wrap_FXMenuCaption_onCmdSetIconValue), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "onCmdGetIconValue", VALUEFUNC(_wrap_FXMenuCaption_onCmdGetIconValue), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "onCmdSetHelp", VALUEFUNC(_wrap_FXMenuCaption_onCmdSetHelp), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "onCmdGetHelp", VALUEFUNC(_wrap_FXMenuCaption_onCmdGetHelp), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "onCmdSetTip", VALUEFUNC(_wrap_FXMenuCaption_onCmdSetTip), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "onCmdGetTip", VALUEFUNC(_wrap_FXMenuCaption_onCmdGetTip), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "onQueryHelp", VALUEFUNC(_wrap_FXMenuCaption_onQueryHelp), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "onQueryTip", VALUEFUNC(_wrap_FXMenuCaption_onQueryTip), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "setText", VALUEFUNC(_wrap_FXMenuCaption_setText), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "getText", VALUEFUNC(_wrap_FXMenuCaption_getText), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "setIcon", VALUEFUNC(_wrap_FXMenuCaption_setIcon), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "getIcon", VALUEFUNC(_wrap_FXMenuCaption_getIcon), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "setFont", VALUEFUNC(_wrap_FXMenuCaption_setFont), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "getFont", VALUEFUNC(_wrap_FXMenuCaption_getFont), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "setMenuStyle", VALUEFUNC(_wrap_FXMenuCaption_setMenuStyle), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "getMenuStyle", VALUEFUNC(_wrap_FXMenuCaption_getMenuStyle), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "getTextColor", VALUEFUNC(_wrap_FXMenuCaption_getTextColor), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "setTextColor", VALUEFUNC(_wrap_FXMenuCaption_setTextColor), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "getSelBackColor", VALUEFUNC(_wrap_FXMenuCaption_getSelBackColor), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "setSelBackColor", VALUEFUNC(_wrap_FXMenuCaption_setSelBackColor), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "getSelTextColor", VALUEFUNC(_wrap_FXMenuCaption_getSelTextColor), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "setSelTextColor", VALUEFUNC(_wrap_FXMenuCaption_setSelTextColor), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "setHiliteColor", VALUEFUNC(_wrap_FXMenuCaption_setHiliteColor), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "getHiliteColor", VALUEFUNC(_wrap_FXMenuCaption_getHiliteColor), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "setShadowColor", VALUEFUNC(_wrap_FXMenuCaption_setShadowColor), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "getShadowColor", VALUEFUNC(_wrap_FXMenuCaption_getShadowColor), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "setHelpText", VALUEFUNC(_wrap_FXMenuCaption_setHelpText), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "getHelpText", VALUEFUNC(_wrap_FXMenuCaption_getHelpText), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "tipText=", VALUEFUNC(_wrap_FXMenuCaption_tipTexte___), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "tipText", VALUEFUNC(_wrap_FXMenuCaption_tipText), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "save", VALUEFUNC(_wrap_FXMenuCaption_save), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "load", VALUEFUNC(_wrap_FXMenuCaption_load), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "create", VALUEFUNC(_wrap_FXMenuCaption_create), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "detach", VALUEFUNC(_wrap_FXMenuCaption_detach), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "destroy", VALUEFUNC(_wrap_FXMenuCaption_destroy), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "resize", VALUEFUNC(_wrap_FXMenuCaption_resize), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXMenuCaption_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXMenuCaption_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXMenuCaption_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXMenuCaption_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "canFocus", VALUEFUNC(_wrap_FXMenuCaption_canFocus), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "setFocus", VALUEFUNC(_wrap_FXMenuCaption_setFocus), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "killFocus", VALUEFUNC(_wrap_FXMenuCaption_killFocus), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "changeFocus", VALUEFUNC(_wrap_FXMenuCaption_changeFocus), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "setDefault", VALUEFUNC(_wrap_FXMenuCaption_setDefault), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "enable", VALUEFUNC(_wrap_FXMenuCaption_enable), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "disable", VALUEFUNC(_wrap_FXMenuCaption_disable), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "raiseWindow", VALUEFUNC(_wrap_FXMenuCaption_raiseWindow), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "lower", VALUEFUNC(_wrap_FXMenuCaption_lower), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "move", VALUEFUNC(_wrap_FXMenuCaption_move), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "position", VALUEFUNC(_wrap_FXMenuCaption_position), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "layout", VALUEFUNC(_wrap_FXMenuCaption_layout), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "recalc", VALUEFUNC(_wrap_FXMenuCaption_recalc), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "reparent", VALUEFUNC(_wrap_FXMenuCaption_reparent), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "show", VALUEFUNC(_wrap_FXMenuCaption_show), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "hide", VALUEFUNC(_wrap_FXMenuCaption_hide), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "isComposite", VALUEFUNC(_wrap_FXMenuCaption_isComposite), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "contains", VALUEFUNC(_wrap_FXMenuCaption_contains), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXMenuCaption_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "setBackColor", VALUEFUNC(_wrap_FXMenuCaption_setBackColor), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "tr", VALUEFUNC(_wrap_FXMenuCaption_tr), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "dropEnable", VALUEFUNC(_wrap_FXMenuCaption_dropEnable), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "dropDisable", VALUEFUNC(_wrap_FXMenuCaption_dropDisable), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "setShape", VALUEFUNC(_wrap_FXMenuCaption_setShape), -1);
+  rb_define_method(SwigClassFXMenuCaption.klass, "clearShape", VALUEFUNC(_wrap_FXMenuCaption_clearShape), -1);
+  SwigClassFXMenuCaption.mark = (void (*)(void *)) FXRbMenuCaption::markfunc;
+  SwigClassFXMenuCaption.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXMenuCaption.trackObjects = 0;
+  
+  SWIGTYPE_p_FXMenuCaption->dcast = (swig_dycast_func) FXMenuCaption_dynamic_cast;
+  
+  
+  SwigClassFXMenuSeparator.klass = rb_define_class_under(mFox, "FXMenuSeparator", ((swig_class *) SWIGTYPE_p_FXWindow->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMenuSeparator, (void *) &SwigClassFXMenuSeparator);
+  rb_define_alloc_func(SwigClassFXMenuSeparator.klass, _wrap_FXMenuSeparator_allocate);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "initialize", VALUEFUNC(_wrap_new_FXMenuSeparator), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "onPaint", VALUEFUNC(_wrap_FXMenuSeparator_onPaint), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "setHiliteColor", VALUEFUNC(_wrap_FXMenuSeparator_setHiliteColor), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "getHiliteColor", VALUEFUNC(_wrap_FXMenuSeparator_getHiliteColor), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "setShadowColor", VALUEFUNC(_wrap_FXMenuSeparator_setShadowColor), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "getShadowColor", VALUEFUNC(_wrap_FXMenuSeparator_getShadowColor), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "save", VALUEFUNC(_wrap_FXMenuSeparator_save), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "load", VALUEFUNC(_wrap_FXMenuSeparator_load), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "create", VALUEFUNC(_wrap_FXMenuSeparator_create), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "detach", VALUEFUNC(_wrap_FXMenuSeparator_detach), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "destroy", VALUEFUNC(_wrap_FXMenuSeparator_destroy), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "resize", VALUEFUNC(_wrap_FXMenuSeparator_resize), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXMenuSeparator_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXMenuSeparator_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXMenuSeparator_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXMenuSeparator_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "canFocus", VALUEFUNC(_wrap_FXMenuSeparator_canFocus), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "setFocus", VALUEFUNC(_wrap_FXMenuSeparator_setFocus), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "killFocus", VALUEFUNC(_wrap_FXMenuSeparator_killFocus), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "changeFocus", VALUEFUNC(_wrap_FXMenuSeparator_changeFocus), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "setDefault", VALUEFUNC(_wrap_FXMenuSeparator_setDefault), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "enable", VALUEFUNC(_wrap_FXMenuSeparator_enable), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "disable", VALUEFUNC(_wrap_FXMenuSeparator_disable), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "raiseWindow", VALUEFUNC(_wrap_FXMenuSeparator_raiseWindow), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "lower", VALUEFUNC(_wrap_FXMenuSeparator_lower), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "move", VALUEFUNC(_wrap_FXMenuSeparator_move), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "position", VALUEFUNC(_wrap_FXMenuSeparator_position), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "layout", VALUEFUNC(_wrap_FXMenuSeparator_layout), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "recalc", VALUEFUNC(_wrap_FXMenuSeparator_recalc), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "reparent", VALUEFUNC(_wrap_FXMenuSeparator_reparent), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "show", VALUEFUNC(_wrap_FXMenuSeparator_show), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "hide", VALUEFUNC(_wrap_FXMenuSeparator_hide), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "isComposite", VALUEFUNC(_wrap_FXMenuSeparator_isComposite), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "contains", VALUEFUNC(_wrap_FXMenuSeparator_contains), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXMenuSeparator_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "setBackColor", VALUEFUNC(_wrap_FXMenuSeparator_setBackColor), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "tr", VALUEFUNC(_wrap_FXMenuSeparator_tr), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "dropEnable", VALUEFUNC(_wrap_FXMenuSeparator_dropEnable), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "dropDisable", VALUEFUNC(_wrap_FXMenuSeparator_dropDisable), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "setShape", VALUEFUNC(_wrap_FXMenuSeparator_setShape), -1);
+  rb_define_method(SwigClassFXMenuSeparator.klass, "clearShape", VALUEFUNC(_wrap_FXMenuSeparator_clearShape), -1);
+  SwigClassFXMenuSeparator.mark = (void (*)(void *)) FXRbMenuSeparator::markfunc;
+  SwigClassFXMenuSeparator.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXMenuSeparator.trackObjects = 0;
+  
+  SwigClassFXMenuTitle.klass = rb_define_class_under(mFox, "FXMenuTitle", ((swig_class *) SWIGTYPE_p_FXMenuCaption->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMenuTitle, (void *) &SwigClassFXMenuTitle);
+  rb_define_alloc_func(SwigClassFXMenuTitle.klass, _wrap_FXMenuTitle_allocate);
+  rb_define_method(SwigClassFXMenuTitle.klass, "initialize", VALUEFUNC(_wrap_new_FXMenuTitle), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "onPaint", VALUEFUNC(_wrap_FXMenuTitle_onPaint), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "onEnter", VALUEFUNC(_wrap_FXMenuTitle_onEnter), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "onLeave", VALUEFUNC(_wrap_FXMenuTitle_onLeave), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXMenuTitle_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXMenuTitle_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "onKeyPress", VALUEFUNC(_wrap_FXMenuTitle_onKeyPress), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "onKeyRelease", VALUEFUNC(_wrap_FXMenuTitle_onKeyRelease), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "onHotKeyPress", VALUEFUNC(_wrap_FXMenuTitle_onHotKeyPress), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "onHotKeyRelease", VALUEFUNC(_wrap_FXMenuTitle_onHotKeyRelease), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "onFocusUp", VALUEFUNC(_wrap_FXMenuTitle_onFocusUp), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "onFocusDown", VALUEFUNC(_wrap_FXMenuTitle_onFocusDown), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "onFocusIn", VALUEFUNC(_wrap_FXMenuTitle_onFocusIn), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "onFocusOut", VALUEFUNC(_wrap_FXMenuTitle_onFocusOut), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "onCmdPost", VALUEFUNC(_wrap_FXMenuTitle_onCmdPost), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "onCmdUnpost", VALUEFUNC(_wrap_FXMenuTitle_onCmdUnpost), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "setMenu", VALUEFUNC(_wrap_FXMenuTitle_setMenu), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "getMenu", VALUEFUNC(_wrap_FXMenuTitle_getMenu), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "save", VALUEFUNC(_wrap_FXMenuTitle_save), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "load", VALUEFUNC(_wrap_FXMenuTitle_load), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "create", VALUEFUNC(_wrap_FXMenuTitle_create), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "detach", VALUEFUNC(_wrap_FXMenuTitle_detach), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "destroy", VALUEFUNC(_wrap_FXMenuTitle_destroy), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "resize", VALUEFUNC(_wrap_FXMenuTitle_resize), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXMenuTitle_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXMenuTitle_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXMenuTitle_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXMenuTitle_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "canFocus", VALUEFUNC(_wrap_FXMenuTitle_canFocus), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "setFocus", VALUEFUNC(_wrap_FXMenuTitle_setFocus), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "killFocus", VALUEFUNC(_wrap_FXMenuTitle_killFocus), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "changeFocus", VALUEFUNC(_wrap_FXMenuTitle_changeFocus), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "setDefault", VALUEFUNC(_wrap_FXMenuTitle_setDefault), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "enable", VALUEFUNC(_wrap_FXMenuTitle_enable), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "disable", VALUEFUNC(_wrap_FXMenuTitle_disable), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "raiseWindow", VALUEFUNC(_wrap_FXMenuTitle_raiseWindow), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "lower", VALUEFUNC(_wrap_FXMenuTitle_lower), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "move", VALUEFUNC(_wrap_FXMenuTitle_move), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "position", VALUEFUNC(_wrap_FXMenuTitle_position), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "layout", VALUEFUNC(_wrap_FXMenuTitle_layout), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "recalc", VALUEFUNC(_wrap_FXMenuTitle_recalc), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "reparent", VALUEFUNC(_wrap_FXMenuTitle_reparent), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "show", VALUEFUNC(_wrap_FXMenuTitle_show), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "hide", VALUEFUNC(_wrap_FXMenuTitle_hide), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "isComposite", VALUEFUNC(_wrap_FXMenuTitle_isComposite), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "contains", VALUEFUNC(_wrap_FXMenuTitle_contains), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXMenuTitle_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "setBackColor", VALUEFUNC(_wrap_FXMenuTitle_setBackColor), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "tr", VALUEFUNC(_wrap_FXMenuTitle_tr), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "dropEnable", VALUEFUNC(_wrap_FXMenuTitle_dropEnable), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "dropDisable", VALUEFUNC(_wrap_FXMenuTitle_dropDisable), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "setShape", VALUEFUNC(_wrap_FXMenuTitle_setShape), -1);
+  rb_define_method(SwigClassFXMenuTitle.klass, "clearShape", VALUEFUNC(_wrap_FXMenuTitle_clearShape), -1);
+  SwigClassFXMenuTitle.mark = (void (*)(void *)) FXRbMenuTitle::markfunc;
+  SwigClassFXMenuTitle.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXMenuTitle.trackObjects = 0;
+  
+  SwigClassFXMenuCascade.klass = rb_define_class_under(mFox, "FXMenuCascade", ((swig_class *) SWIGTYPE_p_FXMenuCaption->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMenuCascade, (void *) &SwigClassFXMenuCascade);
+  rb_define_alloc_func(SwigClassFXMenuCascade.klass, _wrap_FXMenuCascade_allocate);
+  rb_define_method(SwigClassFXMenuCascade.klass, "initialize", VALUEFUNC(_wrap_new_FXMenuCascade), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "onPaint", VALUEFUNC(_wrap_FXMenuCascade_onPaint), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "onEnter", VALUEFUNC(_wrap_FXMenuCascade_onEnter), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "onLeave", VALUEFUNC(_wrap_FXMenuCascade_onLeave), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "onButtonPress", VALUEFUNC(_wrap_FXMenuCascade_onButtonPress), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "onButtonRelease", VALUEFUNC(_wrap_FXMenuCascade_onButtonRelease), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "onKeyPress", VALUEFUNC(_wrap_FXMenuCascade_onKeyPress), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "onKeyRelease", VALUEFUNC(_wrap_FXMenuCascade_onKeyRelease), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "onHotKeyPress", VALUEFUNC(_wrap_FXMenuCascade_onHotKeyPress), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "onHotKeyRelease", VALUEFUNC(_wrap_FXMenuCascade_onHotKeyRelease), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "onCmdPost", VALUEFUNC(_wrap_FXMenuCascade_onCmdPost), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "onCmdUnpost", VALUEFUNC(_wrap_FXMenuCascade_onCmdUnpost), -1);
+  rb_define_const(SwigClassFXMenuCascade.klass, "ID_MENUTIMER", SWIG_From_int(static_cast< int >(FXMenuCascade::ID_MENUTIMER)));
+  rb_define_const(SwigClassFXMenuCascade.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXMenuCascade::ID_LAST)));
+  rb_define_method(SwigClassFXMenuCascade.klass, "setMenu", VALUEFUNC(_wrap_FXMenuCascade_setMenu), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "getMenu", VALUEFUNC(_wrap_FXMenuCascade_getMenu), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "save", VALUEFUNC(_wrap_FXMenuCascade_save), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "load", VALUEFUNC(_wrap_FXMenuCascade_load), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "create", VALUEFUNC(_wrap_FXMenuCascade_create), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "detach", VALUEFUNC(_wrap_FXMenuCascade_detach), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "destroy", VALUEFUNC(_wrap_FXMenuCascade_destroy), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "resize", VALUEFUNC(_wrap_FXMenuCascade_resize), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXMenuCascade_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXMenuCascade_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXMenuCascade_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXMenuCascade_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "canFocus", VALUEFUNC(_wrap_FXMenuCascade_canFocus), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "setFocus", VALUEFUNC(_wrap_FXMenuCascade_setFocus), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "killFocus", VALUEFUNC(_wrap_FXMenuCascade_killFocus), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "changeFocus", VALUEFUNC(_wrap_FXMenuCascade_changeFocus), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "setDefault", VALUEFUNC(_wrap_FXMenuCascade_setDefault), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "enable", VALUEFUNC(_wrap_FXMenuCascade_enable), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "disable", VALUEFUNC(_wrap_FXMenuCascade_disable), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "raiseWindow", VALUEFUNC(_wrap_FXMenuCascade_raiseWindow), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "lower", VALUEFUNC(_wrap_FXMenuCascade_lower), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "move", VALUEFUNC(_wrap_FXMenuCascade_move), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "position", VALUEFUNC(_wrap_FXMenuCascade_position), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "layout", VALUEFUNC(_wrap_FXMenuCascade_layout), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "recalc", VALUEFUNC(_wrap_FXMenuCascade_recalc), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "reparent", VALUEFUNC(_wrap_FXMenuCascade_reparent), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "show", VALUEFUNC(_wrap_FXMenuCascade_show), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "hide", VALUEFUNC(_wrap_FXMenuCascade_hide), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "isComposite", VALUEFUNC(_wrap_FXMenuCascade_isComposite), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "contains", VALUEFUNC(_wrap_FXMenuCascade_contains), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXMenuCascade_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "setBackColor", VALUEFUNC(_wrap_FXMenuCascade_setBackColor), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "tr", VALUEFUNC(_wrap_FXMenuCascade_tr), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "dropEnable", VALUEFUNC(_wrap_FXMenuCascade_dropEnable), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "dropDisable", VALUEFUNC(_wrap_FXMenuCascade_dropDisable), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "setShape", VALUEFUNC(_wrap_FXMenuCascade_setShape), -1);
+  rb_define_method(SwigClassFXMenuCascade.klass, "clearShape", VALUEFUNC(_wrap_FXMenuCascade_clearShape), -1);
+  SwigClassFXMenuCascade.mark = (void (*)(void *)) FXRbMenuCascade::markfunc;
+  SwigClassFXMenuCascade.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXMenuCascade.trackObjects = 0;
+  
+  SwigClassFXMenuCommand.klass = rb_define_class_under(mFox, "FXMenuCommand", ((swig_class *) SWIGTYPE_p_FXMenuCaption->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMenuCommand, (void *) &SwigClassFXMenuCommand);
+  rb_define_alloc_func(SwigClassFXMenuCommand.klass, _wrap_FXMenuCommand_allocate);
+  rb_define_method(SwigClassFXMenuCommand.klass, "initialize", VALUEFUNC(_wrap_new_FXMenuCommand), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "onPaint", VALUEFUNC(_wrap_FXMenuCommand_onPaint), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "onEnter", VALUEFUNC(_wrap_FXMenuCommand_onEnter), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "onLeave", VALUEFUNC(_wrap_FXMenuCommand_onLeave), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "onButtonPress", VALUEFUNC(_wrap_FXMenuCommand_onButtonPress), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "onButtonRelease", VALUEFUNC(_wrap_FXMenuCommand_onButtonRelease), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "onKeyPress", VALUEFUNC(_wrap_FXMenuCommand_onKeyPress), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "onKeyRelease", VALUEFUNC(_wrap_FXMenuCommand_onKeyRelease), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "onHotKeyPress", VALUEFUNC(_wrap_FXMenuCommand_onHotKeyPress), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "onHotKeyRelease", VALUEFUNC(_wrap_FXMenuCommand_onHotKeyRelease), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "onCmdAccel", VALUEFUNC(_wrap_FXMenuCommand_onCmdAccel), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "setAccelText", VALUEFUNC(_wrap_FXMenuCommand_setAccelText), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "getAccelText", VALUEFUNC(_wrap_FXMenuCommand_getAccelText), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "save", VALUEFUNC(_wrap_FXMenuCommand_save), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "load", VALUEFUNC(_wrap_FXMenuCommand_load), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "create", VALUEFUNC(_wrap_FXMenuCommand_create), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "detach", VALUEFUNC(_wrap_FXMenuCommand_detach), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "destroy", VALUEFUNC(_wrap_FXMenuCommand_destroy), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "resize", VALUEFUNC(_wrap_FXMenuCommand_resize), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXMenuCommand_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXMenuCommand_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXMenuCommand_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXMenuCommand_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "canFocus", VALUEFUNC(_wrap_FXMenuCommand_canFocus), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "setFocus", VALUEFUNC(_wrap_FXMenuCommand_setFocus), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "killFocus", VALUEFUNC(_wrap_FXMenuCommand_killFocus), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "changeFocus", VALUEFUNC(_wrap_FXMenuCommand_changeFocus), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "setDefault", VALUEFUNC(_wrap_FXMenuCommand_setDefault), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "enable", VALUEFUNC(_wrap_FXMenuCommand_enable), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "disable", VALUEFUNC(_wrap_FXMenuCommand_disable), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "raiseWindow", VALUEFUNC(_wrap_FXMenuCommand_raiseWindow), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "lower", VALUEFUNC(_wrap_FXMenuCommand_lower), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "move", VALUEFUNC(_wrap_FXMenuCommand_move), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "position", VALUEFUNC(_wrap_FXMenuCommand_position), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "layout", VALUEFUNC(_wrap_FXMenuCommand_layout), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "recalc", VALUEFUNC(_wrap_FXMenuCommand_recalc), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "reparent", VALUEFUNC(_wrap_FXMenuCommand_reparent), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "show", VALUEFUNC(_wrap_FXMenuCommand_show), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "hide", VALUEFUNC(_wrap_FXMenuCommand_hide), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "isComposite", VALUEFUNC(_wrap_FXMenuCommand_isComposite), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "contains", VALUEFUNC(_wrap_FXMenuCommand_contains), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXMenuCommand_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "setBackColor", VALUEFUNC(_wrap_FXMenuCommand_setBackColor), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "tr", VALUEFUNC(_wrap_FXMenuCommand_tr), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "dropEnable", VALUEFUNC(_wrap_FXMenuCommand_dropEnable), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "dropDisable", VALUEFUNC(_wrap_FXMenuCommand_dropDisable), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "setShape", VALUEFUNC(_wrap_FXMenuCommand_setShape), -1);
+  rb_define_method(SwigClassFXMenuCommand.klass, "clearShape", VALUEFUNC(_wrap_FXMenuCommand_clearShape), -1);
+  SwigClassFXMenuCommand.mark = (void (*)(void *)) FXRbMenuCommand::markfunc;
+  SwigClassFXMenuCommand.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXMenuCommand.trackObjects = 0;
+  
+  SwigClassFXMenuBar.klass = rb_define_class_under(mFox, "FXMenuBar", ((swig_class *) SWIGTYPE_p_FXToolBar->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMenuBar, (void *) &SwigClassFXMenuBar);
+  rb_define_alloc_func(SwigClassFXMenuBar.klass, _wrap_FXMenuBar_allocate);
+  rb_define_method(SwigClassFXMenuBar.klass, "initialize", VALUEFUNC(_wrap_new_FXMenuBar), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "onFocusLeft", VALUEFUNC(_wrap_FXMenuBar_onFocusLeft), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "onFocusRight", VALUEFUNC(_wrap_FXMenuBar_onFocusRight), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "onEnter", VALUEFUNC(_wrap_FXMenuBar_onEnter), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "onLeave", VALUEFUNC(_wrap_FXMenuBar_onLeave), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "onMotion", VALUEFUNC(_wrap_FXMenuBar_onMotion), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "onButtonPress", VALUEFUNC(_wrap_FXMenuBar_onButtonPress), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "onButtonRelease", VALUEFUNC(_wrap_FXMenuBar_onButtonRelease), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "onCmdUnpost", VALUEFUNC(_wrap_FXMenuBar_onCmdUnpost), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "save", VALUEFUNC(_wrap_FXMenuBar_save), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "load", VALUEFUNC(_wrap_FXMenuBar_load), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "create", VALUEFUNC(_wrap_FXMenuBar_create), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "detach", VALUEFUNC(_wrap_FXMenuBar_detach), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "destroy", VALUEFUNC(_wrap_FXMenuBar_destroy), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "resize", VALUEFUNC(_wrap_FXMenuBar_resize), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXMenuBar_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXMenuBar_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXMenuBar_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXMenuBar_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "canFocus", VALUEFUNC(_wrap_FXMenuBar_canFocus), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "setFocus", VALUEFUNC(_wrap_FXMenuBar_setFocus), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "killFocus", VALUEFUNC(_wrap_FXMenuBar_killFocus), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "changeFocus", VALUEFUNC(_wrap_FXMenuBar_changeFocus), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "setDefault", VALUEFUNC(_wrap_FXMenuBar_setDefault), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "enable", VALUEFUNC(_wrap_FXMenuBar_enable), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "disable", VALUEFUNC(_wrap_FXMenuBar_disable), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "raiseWindow", VALUEFUNC(_wrap_FXMenuBar_raiseWindow), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "lower", VALUEFUNC(_wrap_FXMenuBar_lower), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "move", VALUEFUNC(_wrap_FXMenuBar_move), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "position", VALUEFUNC(_wrap_FXMenuBar_position), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "layout", VALUEFUNC(_wrap_FXMenuBar_layout), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "recalc", VALUEFUNC(_wrap_FXMenuBar_recalc), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "reparent", VALUEFUNC(_wrap_FXMenuBar_reparent), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "show", VALUEFUNC(_wrap_FXMenuBar_show), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "hide", VALUEFUNC(_wrap_FXMenuBar_hide), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "isComposite", VALUEFUNC(_wrap_FXMenuBar_isComposite), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "contains", VALUEFUNC(_wrap_FXMenuBar_contains), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXMenuBar_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "setBackColor", VALUEFUNC(_wrap_FXMenuBar_setBackColor), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "tr", VALUEFUNC(_wrap_FXMenuBar_tr), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "dropEnable", VALUEFUNC(_wrap_FXMenuBar_dropEnable), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "dropDisable", VALUEFUNC(_wrap_FXMenuBar_dropDisable), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "setShape", VALUEFUNC(_wrap_FXMenuBar_setShape), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "clearShape", VALUEFUNC(_wrap_FXMenuBar_clearShape), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "dock", VALUEFUNC(_wrap_FXMenuBar_dock), -1);
+  rb_define_method(SwigClassFXMenuBar.klass, "undock", VALUEFUNC(_wrap_FXMenuBar_undock), -1);
+  SwigClassFXMenuBar.mark = (void (*)(void *)) FXRbMenuBar::markfunc;
+  SwigClassFXMenuBar.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXMenuBar.trackObjects = 0;
+  
+  SwigClassFXMenuCheck.klass = rb_define_class_under(mFox, "FXMenuCheck", ((swig_class *) SWIGTYPE_p_FXMenuCommand->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMenuCheck, (void *) &SwigClassFXMenuCheck);
+  rb_define_alloc_func(SwigClassFXMenuCheck.klass, _wrap_FXMenuCheck_allocate);
+  rb_define_method(SwigClassFXMenuCheck.klass, "initialize", VALUEFUNC(_wrap_new_FXMenuCheck), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "onPaint", VALUEFUNC(_wrap_FXMenuCheck_onPaint), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "onButtonPress", VALUEFUNC(_wrap_FXMenuCheck_onButtonPress), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "onButtonRelease", VALUEFUNC(_wrap_FXMenuCheck_onButtonRelease), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "onKeyPress", VALUEFUNC(_wrap_FXMenuCheck_onKeyPress), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "onKeyRelease", VALUEFUNC(_wrap_FXMenuCheck_onKeyRelease), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "onHotKeyPress", VALUEFUNC(_wrap_FXMenuCheck_onHotKeyPress), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "onHotKeyRelease", VALUEFUNC(_wrap_FXMenuCheck_onHotKeyRelease), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "onCheck", VALUEFUNC(_wrap_FXMenuCheck_onCheck), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "onUncheck", VALUEFUNC(_wrap_FXMenuCheck_onUncheck), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "onUnknown", VALUEFUNC(_wrap_FXMenuCheck_onUnknown), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXMenuCheck_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXMenuCheck_onCmdSetIntValue), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXMenuCheck_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "onCmdAccel", VALUEFUNC(_wrap_FXMenuCheck_onCmdAccel), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "setCheck", VALUEFUNC(_wrap_FXMenuCheck_setCheck), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "getCheck", VALUEFUNC(_wrap_FXMenuCheck_getCheck), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "getCheckState", VALUEFUNC(_wrap_FXMenuCheck_getCheckState), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "getBoxColor", VALUEFUNC(_wrap_FXMenuCheck_getBoxColor), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "setBoxColor", VALUEFUNC(_wrap_FXMenuCheck_setBoxColor), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "save", VALUEFUNC(_wrap_FXMenuCheck_save), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "load", VALUEFUNC(_wrap_FXMenuCheck_load), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "create", VALUEFUNC(_wrap_FXMenuCheck_create), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "detach", VALUEFUNC(_wrap_FXMenuCheck_detach), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "destroy", VALUEFUNC(_wrap_FXMenuCheck_destroy), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "resize", VALUEFUNC(_wrap_FXMenuCheck_resize), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXMenuCheck_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXMenuCheck_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXMenuCheck_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXMenuCheck_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "canFocus", VALUEFUNC(_wrap_FXMenuCheck_canFocus), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "setFocus", VALUEFUNC(_wrap_FXMenuCheck_setFocus), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "killFocus", VALUEFUNC(_wrap_FXMenuCheck_killFocus), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "changeFocus", VALUEFUNC(_wrap_FXMenuCheck_changeFocus), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "setDefault", VALUEFUNC(_wrap_FXMenuCheck_setDefault), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "enable", VALUEFUNC(_wrap_FXMenuCheck_enable), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "disable", VALUEFUNC(_wrap_FXMenuCheck_disable), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "raiseWindow", VALUEFUNC(_wrap_FXMenuCheck_raiseWindow), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "lower", VALUEFUNC(_wrap_FXMenuCheck_lower), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "move", VALUEFUNC(_wrap_FXMenuCheck_move), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "position", VALUEFUNC(_wrap_FXMenuCheck_position), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "layout", VALUEFUNC(_wrap_FXMenuCheck_layout), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "recalc", VALUEFUNC(_wrap_FXMenuCheck_recalc), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "reparent", VALUEFUNC(_wrap_FXMenuCheck_reparent), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "show", VALUEFUNC(_wrap_FXMenuCheck_show), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "hide", VALUEFUNC(_wrap_FXMenuCheck_hide), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "isComposite", VALUEFUNC(_wrap_FXMenuCheck_isComposite), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "contains", VALUEFUNC(_wrap_FXMenuCheck_contains), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXMenuCheck_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "setBackColor", VALUEFUNC(_wrap_FXMenuCheck_setBackColor), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "tr", VALUEFUNC(_wrap_FXMenuCheck_tr), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "dropEnable", VALUEFUNC(_wrap_FXMenuCheck_dropEnable), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "dropDisable", VALUEFUNC(_wrap_FXMenuCheck_dropDisable), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "setShape", VALUEFUNC(_wrap_FXMenuCheck_setShape), -1);
+  rb_define_method(SwigClassFXMenuCheck.klass, "clearShape", VALUEFUNC(_wrap_FXMenuCheck_clearShape), -1);
+  SwigClassFXMenuCheck.mark = 0;
+  SwigClassFXMenuCheck.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXMenuCheck.trackObjects = 0;
+  
+  SwigClassFXMenuRadio.klass = rb_define_class_under(mFox, "FXMenuRadio", ((swig_class *) SWIGTYPE_p_FXMenuCommand->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXMenuRadio, (void *) &SwigClassFXMenuRadio);
+  rb_define_alloc_func(SwigClassFXMenuRadio.klass, _wrap_FXMenuRadio_allocate);
+  rb_define_method(SwigClassFXMenuRadio.klass, "initialize", VALUEFUNC(_wrap_new_FXMenuRadio), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "onPaint", VALUEFUNC(_wrap_FXMenuRadio_onPaint), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "onButtonPress", VALUEFUNC(_wrap_FXMenuRadio_onButtonPress), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "onButtonRelease", VALUEFUNC(_wrap_FXMenuRadio_onButtonRelease), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "onKeyPress", VALUEFUNC(_wrap_FXMenuRadio_onKeyPress), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "onKeyRelease", VALUEFUNC(_wrap_FXMenuRadio_onKeyRelease), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "onHotKeyPress", VALUEFUNC(_wrap_FXMenuRadio_onHotKeyPress), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "onHotKeyRelease", VALUEFUNC(_wrap_FXMenuRadio_onHotKeyRelease), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "onCheck", VALUEFUNC(_wrap_FXMenuRadio_onCheck), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "onUncheck", VALUEFUNC(_wrap_FXMenuRadio_onUncheck), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "onUnknown", VALUEFUNC(_wrap_FXMenuRadio_onUnknown), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXMenuRadio_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXMenuRadio_onCmdSetIntValue), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXMenuRadio_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "onCmdAccel", VALUEFUNC(_wrap_FXMenuRadio_onCmdAccel), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "setCheck", VALUEFUNC(_wrap_FXMenuRadio_setCheck), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "getCheck", VALUEFUNC(_wrap_FXMenuRadio_getCheck), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "getCheckState", VALUEFUNC(_wrap_FXMenuRadio_getCheckState), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "getRadioColor", VALUEFUNC(_wrap_FXMenuRadio_getRadioColor), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "setRadioColor", VALUEFUNC(_wrap_FXMenuRadio_setRadioColor), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "save", VALUEFUNC(_wrap_FXMenuRadio_save), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "load", VALUEFUNC(_wrap_FXMenuRadio_load), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "create", VALUEFUNC(_wrap_FXMenuRadio_create), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "detach", VALUEFUNC(_wrap_FXMenuRadio_detach), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "destroy", VALUEFUNC(_wrap_FXMenuRadio_destroy), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "resize", VALUEFUNC(_wrap_FXMenuRadio_resize), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXMenuRadio_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXMenuRadio_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXMenuRadio_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXMenuRadio_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "canFocus", VALUEFUNC(_wrap_FXMenuRadio_canFocus), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "setFocus", VALUEFUNC(_wrap_FXMenuRadio_setFocus), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "killFocus", VALUEFUNC(_wrap_FXMenuRadio_killFocus), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "changeFocus", VALUEFUNC(_wrap_FXMenuRadio_changeFocus), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "setDefault", VALUEFUNC(_wrap_FXMenuRadio_setDefault), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "enable", VALUEFUNC(_wrap_FXMenuRadio_enable), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "disable", VALUEFUNC(_wrap_FXMenuRadio_disable), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "raiseWindow", VALUEFUNC(_wrap_FXMenuRadio_raiseWindow), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "lower", VALUEFUNC(_wrap_FXMenuRadio_lower), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "move", VALUEFUNC(_wrap_FXMenuRadio_move), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "position", VALUEFUNC(_wrap_FXMenuRadio_position), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "layout", VALUEFUNC(_wrap_FXMenuRadio_layout), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "recalc", VALUEFUNC(_wrap_FXMenuRadio_recalc), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "reparent", VALUEFUNC(_wrap_FXMenuRadio_reparent), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "show", VALUEFUNC(_wrap_FXMenuRadio_show), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "hide", VALUEFUNC(_wrap_FXMenuRadio_hide), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "isComposite", VALUEFUNC(_wrap_FXMenuRadio_isComposite), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "contains", VALUEFUNC(_wrap_FXMenuRadio_contains), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXMenuRadio_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "setBackColor", VALUEFUNC(_wrap_FXMenuRadio_setBackColor), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "tr", VALUEFUNC(_wrap_FXMenuRadio_tr), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "dropEnable", VALUEFUNC(_wrap_FXMenuRadio_dropEnable), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "dropDisable", VALUEFUNC(_wrap_FXMenuRadio_dropDisable), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "setShape", VALUEFUNC(_wrap_FXMenuRadio_setShape), -1);
+  rb_define_method(SwigClassFXMenuRadio.klass, "clearShape", VALUEFUNC(_wrap_FXMenuRadio_clearShape), -1);
+  SwigClassFXMenuRadio.mark = 0;
+  SwigClassFXMenuRadio.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXMenuRadio.trackObjects = 0;
+}
+
diff --git a/ext/fox16_c/scintilla_wrap.cpp b/ext/fox16_c/scintilla_wrap.cpp
new file mode 100644
index 00000000..8933baef
--- /dev/null
+++ b/ext/fox16_c/scintilla_wrap.cpp
@@ -0,0 +1,7072 @@
+#ifdef WITH_FXSCINTILLA
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 3.0.12
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+
+#ifndef SWIGRUBY
+#define SWIGRUBY
+#endif
+
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
+};
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic C API SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "4"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/*  Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN           0x1
+
+
+/*
+   Flags/methods for returning states.
+
+   The SWIG conversion methods, as ConvertPtr, return an integer
+   that tells if the conversion was successful or not. And if not,
+   an error code can be returned (see swigerrors.swg for the codes).
+
+   Use the following macros/flags to set or process the returning
+   states.
+
+   In old versions of SWIG, code such as the following was usually written:
+
+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+       // success code
+     } else {
+       //fail code
+     }
+
+   Now you can be more explicit:
+
+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+    } else {
+      // fail code
+    }
+
+   which is the same really, but now you can also do
+
+    Type *ptr;
+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+      if (SWIG_IsNewObj(res) {
+        ...
+	delete *ptr;
+      } else {
+        ...
+      }
+    } else {
+      // fail code
+    }
+
+   I.e., now SWIG_ConvertPtr can return new objects and you can
+   identify the case and take care of the deallocation. Of course that
+   also requires SWIG_ConvertPtr to return new result values, such as
+
+      int SWIG_ConvertPtr(obj, ptr,...) {
+        if (<obj is ok>) {
+          if (<need new object>) {
+            *ptr = <ptr to new allocated object>;
+            return SWIG_NEWOBJ;
+          } else {
+            *ptr = <ptr to old object>;
+            return SWIG_OLDOBJ;
+          }
+        } else {
+          return SWIG_BADOBJ;
+        }
+      }
+
+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+   SWIG errors code.
+
+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+   allows to return the 'cast rank', for example, if you have this
+
+       int food(double)
+       int fooi(int);
+
+   and you call
+
+      food(1)   // cast rank '1'  (1 -> 1.0)
+      fooi(1)   // cast rank '0'
+
+   just use the SWIG_AddCast()/SWIG_CheckState()
+*/
+
+#define SWIG_OK                    (0)
+#define SWIG_ERROR                 (-1)
+#define SWIG_IsOK(r)               (r >= 0)
+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT         (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ                (SWIG_ERROR)
+#define SWIG_OLDOBJ                (SWIG_OK)
+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+#  ifndef SWIG_TypeRank
+#    define SWIG_TypeRank             unsigned long
+#  endif
+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
+#    define SWIG_MAXCASTRANK          (2)
+#  endif
+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+#  define SWIG_AddCast(r) (r)
+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *, int *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store information on one type */
+typedef struct swig_type_info {
+  const char             *name;			/* mangled name of this type */
+  const char             *str;			/* human readable name of this type */
+  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
+  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
+  void                   *clientdata;		/* language specific type data */
+  int                    owndata;		/* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
+  swig_converter_func     converter;		/* function to cast the void pointers */
+  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
+  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
+  size_t                 size;		        /* Number of types in this module */
+  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
+  swig_type_info         **type_initial;	/* Array of initially generated type structures */
+  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
+  void                    *clientdata;		/* Language specific module data */
+} swig_module_info;
+
+/*
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+  }
+  return (int)((l1 - f1) - (l2 - f2));
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCmp(const char *nb, const char *tb) {
+  int equiv = 1;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (equiv != 0 && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
+}
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
+}
+
+/*
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+  swig_type_info *lastty = ty;
+  if (!ty || !ty->dcast) return ty;
+  while (ty && (ty->dcast)) {
+    ty = (*ty->dcast)(ptr);
+    if (ty) lastty = ty;
+  }
+  return lastty;
+}
+
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+  return ty->name;
+}
+
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (!type) return NULL;
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
+  }
+  else
+    return type->name;
+}
+
+/*
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+  swig_cast_info *cast = ti->cast;
+  /* if (ti->clientdata == clientdata) return; */
+  ti->clientdata = clientdata;
+
+  while (cast) {
+    if (!cast->converter) {
+      swig_type_info *tc = cast->type;
+      if (!tc->clientdata) {
+	SWIG_TypeClientData(tc, clientdata);
+      }
+    }
+    cast = cast->next;
+  }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientData(ti, clientdata);
+  ti->owndata = 1;
+}
+
+/*
+  Search for a swig_type_info structure only by mangled name
+  Search is a O(log #types)
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+                            swig_module_info *end,
+		            const char *name) {
+  swig_module_info *iter = start;
+  do {
+    if (iter->size) {
+      size_t l = 0;
+      size_t r = iter->size - 1;
+      do {
+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
+	size_t i = (l + r) >> 1;
+	const char *iname = iter->types[i]->name;
+	if (iname) {
+	  int compare = strcmp(name, iname);
+	  if (compare == 0) {
+	    return iter->types[i];
+	  } else if (compare < 0) {
+	    if (i) {
+	      r = i - 1;
+	    } else {
+	      break;
+	    }
+	  } else if (compare > 0) {
+	    l = i + 1;
+	  }
+	} else {
+	  break; /* should never happen */
+	}
+      } while (l <= r);
+    }
+    iter = iter->next;
+  } while (iter != end);
+  return 0;
+}
+
+/*
+  Search for a swig_type_info structure for either a mangled name or a human readable name.
+  It first searches the mangled names of the types, which is a O(log #types)
+  If a type is not found it then searches the human readable names, which is O(#types).
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+                     swig_module_info *end,
+		     const char *name) {
+  /* STEP 1: Search the name field using binary search */
+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+  if (ret) {
+    return ret;
+  } else {
+    /* STEP 2: If the type hasn't been found, do a complete search
+       of the str field (the human readable name) */
+    swig_module_info *iter = start;
+    do {
+      size_t i = 0;
+      for (; i < iter->size; ++i) {
+	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+	  return iter->types[i];
+      }
+      iter = iter->next;
+    } while (iter != end);
+  }
+
+  /* neither found a match */
+  return 0;
+}
+
+/*
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+
+/*
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = (unsigned char)((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = (unsigned char)((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (unsigned char)(d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (unsigned char)(d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/*
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/*  Errors in SWIG */
+#define  SWIG_UnknownError    	   -1
+#define  SWIG_IOError        	   -2
+#define  SWIG_RuntimeError   	   -3
+#define  SWIG_IndexError     	   -4
+#define  SWIG_TypeError      	   -5
+#define  SWIG_DivisionByZero 	   -6
+#define  SWIG_OverflowError  	   -7
+#define  SWIG_SyntaxError    	   -8
+#define  SWIG_ValueError     	   -9
+#define  SWIG_SystemError    	   -10
+#define  SWIG_AttributeError 	   -11
+#define  SWIG_MemoryError    	   -12
+#define  SWIG_NullReferenceError   -13
+
+
+
+      #include <ruby.h>
+
+      #if defined(RB_METHOD_DEFINITION_DECL)
+      # define RUBY_VALUE_METHOD_FUNC(func) (func)
+      # define RUBY_INT_METHOD_FUNC(func) (func)
+      # define RUBY_VOID_METHOD_FUNC(func) (func)
+      # define RUBY_VOIDP_METHOD_FUNC(func) (func)
+      #else
+      # define RUBY_VALUE_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
+      # define RUBY_INT_METHOD_FUNC(func) ((int (*)(ANYARGS))(func))
+      # define RUBY_VOID_METHOD_FUNC(func) ((void (*)(ANYARGS))(func))
+      # define RUBY_VOIDP_METHOD_FUNC(func) ((void *(*)(ANYARGS))(func))
+      #endif
+
+
+/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
+ * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
+ * issue for now by disabling this.
+ * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
+ */
+#ifdef rb_intern
+# undef rb_intern
+#endif
+
+/* Remove global macros defined in Ruby's win32.h */
+#ifdef write
+# undef write
+#endif
+#ifdef read
+# undef read
+#endif
+#ifdef bind
+# undef bind
+#endif
+#ifdef close
+# undef close
+#endif
+#ifdef connect
+# undef connect
+#endif
+
+
+/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
+#ifndef NUM2LL
+#define NUM2LL(x) NUM2LONG((x))
+#endif
+#ifndef LL2NUM
+#define LL2NUM(x) INT2NUM((long) (x))
+#endif
+#ifndef ULL2NUM
+#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
+#endif
+
+/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
+#ifndef NUM2ULL
+#ifdef HAVE_LONG_LONG
+#define NUM2ULL(x) rb_num2ull((x))
+#else
+#define NUM2ULL(x) NUM2ULONG(x)
+#endif
+#endif
+
+/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
+/* Define these for older versions so we can just write code the new way */
+#ifndef RSTRING_LEN
+# define RSTRING_LEN(x) RSTRING(x)->len
+#endif
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(x) RSTRING(x)->ptr
+#endif
+#ifndef RSTRING_END
+# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
+#endif
+#ifndef RARRAY_LEN
+# define RARRAY_LEN(x) RARRAY(x)->len
+#endif
+#ifndef RARRAY_PTR
+# define RARRAY_PTR(x) RARRAY(x)->ptr
+#endif
+#ifndef RFLOAT_VALUE
+# define RFLOAT_VALUE(x) RFLOAT(x)->value
+#endif
+#ifndef DOUBLE2NUM
+# define DOUBLE2NUM(x) rb_float_new(x)
+#endif
+#ifndef RHASH_TBL
+# define RHASH_TBL(x) (RHASH(x)->tbl)
+#endif
+#ifndef RHASH_ITER_LEV
+# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
+#endif
+#ifndef RHASH_IFNONE
+# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
+#endif
+#ifndef RHASH_SIZE
+# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
+#endif
+#ifndef RHASH_EMPTY_P
+# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
+#endif
+#ifndef RSTRUCT_LEN
+# define RSTRUCT_LEN(x) RSTRUCT(x)->len
+#endif
+#ifndef RSTRUCT_PTR
+# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
+#endif
+
+
+
+/*
+ * Need to be very careful about how these macros are defined, especially
+ * when compiling C++ code or C code with an ANSI C compiler.
+ *
+ * VALUEFUNC(f) is a macro used to typecast a C function that implements
+ * a Ruby method so that it can be passed as an argument to API functions
+ * like rb_define_method() and rb_define_singleton_method().
+ *
+ * VOIDFUNC(f) is a macro used to typecast a C function that implements
+ * either the "mark" or "free" stuff for a Ruby Data object, so that it
+ * can be passed as an argument to API functions like Data_Wrap_Struct()
+ * and Data_Make_Struct().
+ */
+ 
+#ifdef __cplusplus
+#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
+#    define PROTECTFUNC(f) ((VALUE (*)()) f)
+#    define VALUEFUNC(f) ((VALUE (*)()) f)
+#    define VOIDFUNC(f)  ((void (*)()) f)
+#  else
+#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
+#      define PROTECTFUNC(f) ((VALUE (*)()) f)
+#      define VALUEFUNC(f) ((VALUE (*)()) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    else /* These definitions should work for Ruby 1.7+ */
+#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
+#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    endif
+#  endif
+#else
+#  define VALUEFUNC(f) (f)
+#  define VOIDFUNC(f) (f)
+#endif
+
+/* Don't use for expressions have side effect */
+#ifndef RB_STRING_VALUE
+#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
+#endif
+#ifndef StringValue
+#define StringValue(s) RB_STRING_VALUE(s)
+#endif
+#ifndef StringValuePtr
+#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
+#endif
+#ifndef StringValueLen
+#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
+#endif
+#ifndef SafeStringValue
+#define SafeStringValue(v) do {\
+    StringValue(v);\
+    rb_check_safe_str(v);\
+} while (0)
+#endif
+
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
+#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
+#endif
+
+static VALUE _mSWIG = Qnil;
+
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+
+/* Define some additional error types */
+#define SWIG_ObjectPreviouslyDeletedError  -100
+
+
+/* Define custom exceptions for errors that do not map to existing Ruby
+   exceptions.  Note this only works for C++ since a global cannot be
+   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/
+
+SWIGINTERN VALUE 
+getNullReferenceError(void) {
+  static int init = 0;
+  static VALUE rb_eNullReferenceError ;
+  if (!init) {
+    init = 1;
+    rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
+  }
+  return rb_eNullReferenceError;
+} 
+
+SWIGINTERN VALUE 
+getObjectPreviouslyDeletedError(void) {
+  static int init = 0;
+  static VALUE rb_eObjectPreviouslyDeleted ;
+  if (!init) {
+    init = 1;
+    rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
+  }
+  return rb_eObjectPreviouslyDeleted;
+} 
+
+
+SWIGINTERN VALUE
+SWIG_Ruby_ErrorType(int SWIG_code) {
+  VALUE type;
+  switch (SWIG_code) {
+  case SWIG_MemoryError:
+    type = rb_eNoMemError;
+    break;
+  case SWIG_IOError:
+    type = rb_eIOError;
+    break;
+  case SWIG_RuntimeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_IndexError:
+    type = rb_eIndexError;
+    break;
+  case SWIG_TypeError:
+    type = rb_eTypeError;
+    break;
+  case SWIG_DivisionByZero:
+    type = rb_eZeroDivError;
+    break;
+  case SWIG_OverflowError:
+    type = rb_eRangeError;
+    break;
+  case SWIG_SyntaxError:
+    type = rb_eSyntaxError;
+    break;
+  case SWIG_ValueError:
+    type = rb_eArgError;
+    break;
+  case SWIG_SystemError:
+    type = rb_eFatal;
+    break;
+  case SWIG_AttributeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_NullReferenceError:
+    type = getNullReferenceError();
+    break;
+  case SWIG_ObjectPreviouslyDeletedError:
+    type = getObjectPreviouslyDeletedError();
+    break;
+  case SWIG_UnknownError:
+    type = rb_eRuntimeError;
+    break;
+  default:
+    type = rb_eRuntimeError;
+  }
+  return type;
+}
+
+
+/* This function is called when a user inputs a wrong argument to
+   a method.
+ */
+SWIGINTERN 
+const char* Ruby_Format_TypeError( const char* msg,
+				   const char* type, 
+				   const char* name, 
+				   const int argn,
+				   VALUE input )
+{
+  char buf[128];
+  VALUE str;
+  VALUE asStr;
+  if ( msg && *msg )
+    {
+      str = rb_str_new2(msg);
+    }
+  else
+    {
+      str = rb_str_new(NULL, 0);
+    }
+
+  str = rb_str_cat2( str, "Expected argument " );
+  sprintf( buf, "%d of type ", argn-1 );
+  str = rb_str_cat2( str, buf );
+  str = rb_str_cat2( str, type );
+  str = rb_str_cat2( str, ", but got " );
+  str = rb_str_cat2( str, rb_obj_classname(input) );
+  str = rb_str_cat2( str, " " );
+  asStr = rb_inspect(input);
+  if ( RSTRING_LEN(asStr) > 30 )
+    {
+      str = rb_str_cat( str, StringValuePtr(asStr), 30 );
+      str = rb_str_cat2( str, "..." );
+    }
+  else
+    {
+      str = rb_str_append( str, asStr );
+    }
+
+  if ( name )
+    {
+      str = rb_str_cat2( str, "\n\tin SWIG method '" );
+      str = rb_str_cat2( str, name );
+      str = rb_str_cat2( str, "'" );
+    }
+
+  return StringValuePtr( str );
+}
+
+/* This function is called when an overloaded method fails */
+SWIGINTERN 
+void Ruby_Format_OverloadedError(
+				 const int argc,
+				 const int maxargs,
+				 const char* method, 
+				 const char* prototypes 
+				 )
+{
+  const char* msg = "Wrong # of arguments";
+  if ( argc <= maxargs ) msg = "Wrong arguments";
+  rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
+	   "Possible C/C++ prototypes are:\n%s",
+	   msg, method, prototypes);
+}
+
+/* -----------------------------------------------------------------------------
+ * rubytracking.swg
+ *
+ * This file contains support for tracking mappings from 
+ * Ruby objects to C++ objects.  This functionality is needed
+ * to implement mark functions for Ruby's mark and sweep
+ * garbage collector.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(ST_DATA_T_DEFINED)
+/* Needs to be explicitly included for Ruby 1.8 and earlier */
+#include <st.h>
+#endif
+
+/* Ruby 1.8 actually assumes the first case. */
+#if SIZEOF_VOIDP == SIZEOF_LONG
+#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
+#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
+#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
+#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
+#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
+#else
+#  error sizeof(void*) is not the same as long or long long
+#endif
+
+/* Global hash table to store Trackings from C/C++
+   structs to Ruby Objects. 
+*/
+static st_table* swig_ruby_trackings = NULL;
+
+static VALUE swig_ruby_trackings_count(ID id, VALUE *var) {
+  return SWIG2NUM(swig_ruby_trackings->num_entries);
+}
+
+
+/* Setup a hash table to store Trackings */
+SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
+  /* Create a hash table to store Trackings from C++
+     objects to Ruby objects. */
+
+  /* Try to see if some other .so has already created a 
+     tracking hash table, which we keep hidden in an instance var
+     in the SWIG module.
+     This is done to allow multiple DSOs to share the same
+     tracking table.
+  */
+  VALUE trackings_value = Qnil;
+  /* change the variable name so that we can mix modules
+     compiled with older SWIG's - this used to be called "@__trackings__" */
+  ID trackings_id = rb_intern( "@__safetrackings__" );
+  VALUE verbose = rb_gv_get("VERBOSE");
+  rb_gv_set("VERBOSE", Qfalse);
+  trackings_value = rb_ivar_get( _mSWIG, trackings_id );
+  rb_gv_set("VERBOSE", verbose);
+
+  /* The trick here is that we have to store the hash table
+  pointer in a Ruby variable. We do not want Ruby's GC to
+  treat this pointer as a Ruby object, so we convert it to
+  a Ruby numeric value. */
+  if (trackings_value == Qnil) {
+    /* No, it hasn't.  Create one ourselves */
+    swig_ruby_trackings = st_init_numtable();
+    rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
+  } else {
+    swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
+  }
+
+        rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", RUBY_VALUE_METHOD_FUNC(swig_ruby_trackings_count), RUBY_VOID_METHOD_FUNC((rb_gvar_setter_t*)NULL))
+;
+}
+
+/* Add a Tracking from a C/C++ struct to a Ruby object */
+SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
+  /* Store the mapping to the global hash table. */
+  st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
+}
+
+/* Get the Ruby object that owns the specified C/C++ struct */
+SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
+  /* Now lookup the value stored in the global hash table */
+  VALUE value;
+
+  if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
+    return value;
+  } else {
+    return Qnil;
+  }
+}
+
+/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
+   is very important to remove objects once they are destroyed
+   since the same memory address may be reused later to create
+   a new object. */
+SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
+  /* Delete the object from the hash table */
+  st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
+}
+
+/* This is a helper method that unlinks a Ruby object from its
+   underlying C++ object.  This is needed if the lifetime of the
+   Ruby object is longer than the C++ object */
+SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
+  VALUE object = SWIG_RubyInstanceFor(ptr);
+
+  if (object != Qnil) {
+    if (TYPE(object) != T_DATA)
+      abort();
+    DATA_PTR(object) = 0;
+  }
+}
+
+/* This is a helper method that iterates over all the trackings
+   passing the C++ object pointer and its related Ruby object
+   to the passed callback function. */
+
+/* Proxy method to abstract the internal trackings datatype */
+      static int swig_ruby_internal_iterate_callback(st_data_t ptr, st_data_t obj, st_data_t meth) {
+        ((void(*)(void*, VALUE))meth)((void*)ptr, (VALUE)obj);
+
+  return ST_CONTINUE;
+}
+
+SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
+  st_foreach(swig_ruby_trackings, RUBY_INT_METHOD_FUNC(swig_ruby_internal_iterate_callback), (st_data_t)meth);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Ruby API portion that goes into the runtime
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGINTERN VALUE
+SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
+  if (NIL_P(target)) {
+    target = o;
+  } else {
+    if (TYPE(target) != T_ARRAY) {
+      VALUE o2 = target;
+      target = rb_ary_new();
+      rb_ary_push(target, o2);
+    }
+    rb_ary_push(target, o);
+  }
+  return target;
+}
+
+/* For ruby1.8.4 and earlier. */
+#ifndef RUBY_INIT_STACK
+   RUBY_EXTERN void Init_stack(VALUE* addr);
+#  define RUBY_INIT_STACK \
+   VALUE variable_in_this_stack_frame; \
+   Init_stack(&variable_in_this_stack_frame);
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* -----------------------------------------------------------------------------
+ * rubyrun.swg
+ *
+ * This file contains the runtime support for Ruby modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
+#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
+#define swig_owntype                                    swig_ruby_owntype
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) 		SWIG_Ruby_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
+#define SWIG_Error(code, msg)            		rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
+#define SWIG_fail                        		goto fail				 
+
+
+/* Ruby-specific SWIG API */
+
+#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
+#define SWIG_define_class(ty)                        	SWIG_Ruby_define_class(ty)
+#define SWIG_NewClassInstance(value, ty)             	SWIG_Ruby_NewClassInstance(value, ty)
+#define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
+#define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  
+
+#include "assert.h"
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  VALUE klass;
+  VALUE mImpl;
+  void  (*mark)(void *);
+  void  (*destroy)(void *);
+  int trackObjects;
+} swig_class;
+
+
+/* Global pointer used to keep some internal SWIG stuff */
+static VALUE _cSWIG_Pointer = Qnil;
+static VALUE swig_runtime_data_type_pointer = Qnil;
+
+/* Global IDs used to keep some internal SWIG stuff */
+static ID swig_arity_id = 0;
+static ID swig_call_id  = 0;
+
+/*
+  If your swig extension is to be run within an embedded ruby and has
+  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
+  This will reset ruby's stack frame on each entry point from the main 
+  program the first time a virtual director function is invoked (in a 
+  non-recursive way).
+  If this is not done, you run the risk of Ruby trashing the stack.
+*/
+
+#ifdef RUBY_EMBEDDED
+
+#  define SWIG_INIT_STACK                            \
+      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
+      ++swig_virtual_calls;
+#  define SWIG_RELEASE_STACK --swig_virtual_calls;
+#  define Ruby_DirectorTypeMismatchException(x) \
+          rb_raise( rb_eTypeError, "%s", x ); return c_result;
+
+      static unsigned int swig_virtual_calls = 0;
+
+#else  /* normal non-embedded extension */
+
+#  define SWIG_INIT_STACK
+#  define SWIG_RELEASE_STACK
+#  define Ruby_DirectorTypeMismatchException(x) \
+          throw Swig::DirectorTypeMismatchException( x );
+
+#endif  /* RUBY_EMBEDDED */
+
+
+SWIGRUNTIME VALUE 
+getExceptionClass(void) {
+  static int init = 0;
+  static VALUE rubyExceptionClass ;
+  if (!init) {
+    init = 1;
+    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
+  }
+  return rubyExceptionClass;
+} 
+
+/* This code checks to see if the Ruby object being raised as part
+   of an exception inherits from the Ruby class Exception.  If so,
+   the object is simply returned.  If not, then a new Ruby exception
+   object is created and that will be returned to Ruby.*/
+SWIGRUNTIME VALUE
+SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
+  VALUE exceptionClass = getExceptionClass();
+  if (rb_obj_is_kind_of(obj, exceptionClass)) {
+    return obj;
+  }  else {
+    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
+  }
+}
+
+/* Initialize Ruby runtime support */
+SWIGRUNTIME void
+SWIG_Ruby_InitRuntime(void)
+{
+  if (_mSWIG == Qnil) {
+    _mSWIG = rb_define_module("SWIG");
+    swig_call_id  = rb_intern("call");
+    swig_arity_id = rb_intern("arity");
+  }
+}
+
+/* Define Ruby class for C type */
+SWIGRUNTIME void
+SWIG_Ruby_define_class(swig_type_info *type)
+{
+  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+  sprintf(klass_name, "TYPE%s", type->name);
+  if (NIL_P(_cSWIG_Pointer)) {
+    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
+    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
+  }
+  rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
+  free((void *) klass_name);
+}
+
+/* Create a new pointer object */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
+{
+  int own =  flags & SWIG_POINTER_OWN; 
+  int track;
+  char *klass_name;
+  swig_class *sklass;
+  VALUE klass;
+  VALUE obj;
+  
+  if (!ptr)
+    return Qnil;
+  
+  if (type->clientdata) {
+    sklass = (swig_class *) type->clientdata;
+		
+    /* Are we tracking this class and have we already returned this Ruby object? */
+    track = sklass->trackObjects;
+    if (track) {
+      obj = SWIG_RubyInstanceFor(ptr);
+      
+      /* Check the object's type and make sure it has the correct type.
+        It might not in cases where methods do things like 
+        downcast methods. */
+      if (obj != Qnil) {
+        VALUE value = rb_iv_get(obj, "@__swigtype__");
+        const char* type_name = RSTRING_PTR(value);
+				
+        if (strcmp(type->name, type_name) == 0) {
+          return obj;
+        }
+      }
+    }
+
+    /* Create a new Ruby object */
+    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
+			   ( own ? VOIDFUNC(sklass->destroy) : 
+			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
+			     ), ptr);
+
+    /* If tracking is on for this class then track this object. */
+    if (track) {
+      SWIG_RubyAddTracking(ptr, obj);
+    }
+  } else {
+    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+    sprintf(klass_name, "TYPE%s", type->name);
+    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
+    free((void *) klass_name);
+    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
+  }
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  
+  return obj;
+}
+
+/* Create a new class instance (always owned) */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
+{
+  VALUE obj;
+  swig_class *sklass = (swig_class *) type->clientdata;
+  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  return obj;
+}
+
+/* Get type mangle from class name */
+SWIGRUNTIMEINLINE char *
+SWIG_Ruby_MangleStr(VALUE obj)
+{
+  VALUE stype = rb_iv_get(obj, "@__swigtype__");
+  return StringValuePtr(stype);
+}
+
+/* Acquire a pointer value */
+typedef struct {
+  void (*datafree)(void *);
+  int own;
+} swig_ruby_owntype;
+
+SWIGRUNTIME swig_ruby_owntype
+SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
+  swig_ruby_owntype oldown = {0, 0};
+  if (obj) {
+    oldown.datafree = RDATA(obj)->dfree;
+    RDATA(obj)->dfree = own.datafree;
+  }
+  return oldown;
+}
+
+/* Convert a pointer value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
+{
+  char *c;
+  swig_cast_info *tc;
+  void *vptr = 0;
+
+  /* Grab the pointer */
+  if (NIL_P(obj)) {
+    if (ptr)
+      *ptr = 0;
+    return SWIG_OK;
+  } else {
+    if (TYPE(obj) != T_DATA) {
+      return SWIG_ERROR;
+    }
+    Data_Get_Struct(obj, void, vptr);
+  }
+  
+  if (own) {
+    own->datafree = RDATA(obj)->dfree;
+    own->own = 0;
+  }
+    
+  /* Check to see if the input object is giving up ownership
+     of the underlying C struct or C++ object.  If so then we
+     need to reset the destructor since the Ruby object no 
+     longer owns the underlying C++ object.*/ 
+  if (flags & SWIG_POINTER_DISOWN) {
+    /* Is tracking on for this class? */
+    int track = 0;
+    if (ty && ty->clientdata) {
+      swig_class *sklass = (swig_class *) ty->clientdata;
+      track = sklass->trackObjects;
+    }
+		
+    if (track) {
+      /* We are tracking objects for this class.  Thus we change the destructor
+       * to SWIG_RubyRemoveTracking.  This allows us to
+       * remove the mapping from the C++ to Ruby object
+       * when the Ruby object is garbage collected.  If we don't
+       * do this, then it is possible we will return a reference 
+       * to a Ruby object that no longer exists thereby crashing Ruby. */
+      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
+    } else {    
+      RDATA(obj)->dfree = 0;
+    }
+  }
+
+  /* Do type-checking if type info was provided */
+  if (ty) {
+    if (ty->clientdata) {
+      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
+        if (vptr == 0) {
+          /* The object has already been deleted */
+          return SWIG_ObjectPreviouslyDeletedError;
+        }
+      }
+    }
+    if ((c = SWIG_MangleStr(obj)) == NULL) {
+      return SWIG_ERROR;
+    }
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) {
+      return SWIG_ERROR;
+    } else {
+      if (ptr) {
+        if (tc->type == ty) {
+          *ptr = vptr;
+        } else {
+          int newmemory = 0;
+          *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
+          if (newmemory == SWIG_CAST_NEW_MEMORY) {
+            assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+            if (own)
+              own->own = own->own | SWIG_CAST_NEW_MEMORY;
+          }
+        }
+      }
+    }
+  } else {
+    if (ptr)
+      *ptr = vptr;
+  }
+  
+  return SWIG_OK;
+}
+
+/* Check convert */
+SWIGRUNTIMEINLINE int
+SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
+{
+  char *c = SWIG_MangleStr(obj);
+  if (!c) return 0;
+  return SWIG_TypeCheck(c,ty) != 0;
+}
+
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r, ptr, sz);
+  strcpy(r, type->name);
+  return rb_str_new2(result);
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c;
+
+  if (TYPE(obj) != T_STRING) goto type_error;
+  c = StringValuePtr(obj);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') goto type_error;
+  c++;
+  c = SWIG_UnpackData(c, ptr, sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) goto type_error;
+  }
+  return SWIG_OK;
+
+ type_error:
+  return SWIG_ERROR;
+}
+
+SWIGRUNTIME swig_module_info *
+SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
+{
+  VALUE pointer;
+  swig_module_info *ret = 0;
+  VALUE verbose = rb_gv_get("VERBOSE");
+
+ /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
+  rb_gv_set("VERBOSE", Qfalse);
+  
+  /* first check if pointer already created */
+  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  if (pointer != Qnil) {
+    Data_Get_Struct(pointer, swig_module_info, ret);
+  }
+
+  /* reinstate warnings */
+  rb_gv_set("VERBOSE", verbose);
+  return ret;
+}
+
+SWIGRUNTIME void 
+SWIG_Ruby_SetModule(swig_module_info *pointer)
+{
+  /* register a new class */
+  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
+  /* create and store the structure pointer to a global variable */
+  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
+  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
+}
+
+/* This function can be used to check whether a proc or method or similarly
+   callable function has been passed.  Usually used in a %typecheck, like:
+
+   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
+        $result = SWIG_Ruby_isCallable( $input );
+   }
+ */
+SWIGINTERN
+int SWIG_Ruby_isCallable( VALUE proc )
+{
+  if ( rb_respond_to( proc, swig_call_id ) )
+    return 1;
+  return 0;
+}
+
+/* This function can be used to check the arity (number of arguments)
+   a proc or method can take.  Usually used in a %typecheck.
+   Valid arities will be that equal to minimal or those < 0
+   which indicate a variable number of parameters at the end.
+ */
+SWIGINTERN
+int SWIG_Ruby_arity( VALUE proc, int minimal )
+{
+  if ( rb_respond_to( proc, swig_arity_id ) )
+    {
+      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
+      int arity = NUM2INT(num);
+      if ( arity < 0 && (arity+1) < -minimal ) return 1;
+      if ( arity == minimal ) return 1;
+      return 1;
+    }
+  return 0;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
+
+
+
+  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) 
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_p_FX4Splitter swig_types[0]
+#define SWIGTYPE_p_FX7Segment swig_types[1]
+#define SWIGTYPE_p_FXAccelTable swig_types[2]
+#define SWIGTYPE_p_FXApp swig_types[3]
+#define SWIGTYPE_p_FXArrowButton swig_types[4]
+#define SWIGTYPE_p_FXBitmap swig_types[5]
+#define SWIGTYPE_p_FXBitmapFrame swig_types[6]
+#define SWIGTYPE_p_FXCURCursor swig_types[7]
+#define SWIGTYPE_p_FXCanvas swig_types[8]
+#define SWIGTYPE_p_FXColorBar swig_types[9]
+#define SWIGTYPE_p_FXColorRing swig_types[10]
+#define SWIGTYPE_p_FXColorSelector swig_types[11]
+#define SWIGTYPE_p_FXColorWell swig_types[12]
+#define SWIGTYPE_p_FXColorWheel swig_types[13]
+#define SWIGTYPE_p_FXComboBox swig_types[14]
+#define SWIGTYPE_p_FXComposite swig_types[15]
+#define SWIGTYPE_p_FXCursor swig_types[16]
+#define SWIGTYPE_p_FXDataTarget swig_types[17]
+#define SWIGTYPE_p_FXDebugTarget swig_types[18]
+#define SWIGTYPE_p_FXDelegator swig_types[19]
+#define SWIGTYPE_p_FXDial swig_types[20]
+#define SWIGTYPE_p_FXDict swig_types[21]
+#define SWIGTYPE_p_FXDirBox swig_types[22]
+#define SWIGTYPE_p_FXDirSelector swig_types[23]
+#define SWIGTYPE_p_FXDockBar swig_types[24]
+#define SWIGTYPE_p_FXDockHandler swig_types[25]
+#define SWIGTYPE_p_FXDockSite swig_types[26]
+#define SWIGTYPE_p_FXDockTitle swig_types[27]
+#define SWIGTYPE_p_FXDocument swig_types[28]
+#define SWIGTYPE_p_FXDragCorner swig_types[29]
+#define SWIGTYPE_p_FXDrawable swig_types[30]
+#define SWIGTYPE_p_FXDriveBox swig_types[31]
+#define SWIGTYPE_p_FXFileDict swig_types[32]
+#define SWIGTYPE_p_FXFileSelector swig_types[33]
+#define SWIGTYPE_p_FXFileStream swig_types[34]
+#define SWIGTYPE_p_FXFont swig_types[35]
+#define SWIGTYPE_p_FXFontSelector swig_types[36]
+#define SWIGTYPE_p_FXFrame swig_types[37]
+#define SWIGTYPE_p_FXGIFCursor swig_types[38]
+#define SWIGTYPE_p_FXGradientBar swig_types[39]
+#define SWIGTYPE_p_FXGroupBox swig_types[40]
+#define SWIGTYPE_p_FXHeader swig_types[41]
+#define SWIGTYPE_p_FXHeaderItem swig_types[42]
+#define SWIGTYPE_p_FXHorizontalFrame swig_types[43]
+#define SWIGTYPE_p_FXHorizontalSeparator swig_types[44]
+#define SWIGTYPE_p_FXIcon swig_types[45]
+#define SWIGTYPE_p_FXIconDict swig_types[46]
+#define SWIGTYPE_p_FXId swig_types[47]
+#define SWIGTYPE_p_FXImageFrame swig_types[48]
+#define SWIGTYPE_p_FXImageView swig_types[49]
+#define SWIGTYPE_p_FXKnob swig_types[50]
+#define SWIGTYPE_p_FXListBox swig_types[51]
+#define SWIGTYPE_p_FXMainWindow swig_types[52]
+#define SWIGTYPE_p_FXMatrix swig_types[53]
+#define SWIGTYPE_p_FXMemoryStream swig_types[54]
+#define SWIGTYPE_p_FXObject swig_types[55]
+#define SWIGTYPE_p_FXPacker swig_types[56]
+#define SWIGTYPE_p_FXPopup swig_types[57]
+#define SWIGTYPE_p_FXProgressBar swig_types[58]
+#define SWIGTYPE_p_FXRealSlider swig_types[59]
+#define SWIGTYPE_p_FXRealSpinner swig_types[60]
+#define SWIGTYPE_p_FXRecentFiles swig_types[61]
+#define SWIGTYPE_p_FXRegion swig_types[62]
+#define SWIGTYPE_p_FXRegistry swig_types[63]
+#define SWIGTYPE_p_FXRootWindow swig_types[64]
+#define SWIGTYPE_p_FXRuler swig_types[65]
+#define SWIGTYPE_p_FXRulerView swig_types[66]
+#define SWIGTYPE_p_FXScintilla swig_types[67]
+#define SWIGTYPE_p_FXScrollArea swig_types[68]
+#define SWIGTYPE_p_FXScrollBar swig_types[69]
+#define SWIGTYPE_p_FXScrollCorner swig_types[70]
+#define SWIGTYPE_p_FXScrollWindow swig_types[71]
+#define SWIGTYPE_p_FXSeparator swig_types[72]
+#define SWIGTYPE_p_FXSettings swig_types[73]
+#define SWIGTYPE_p_FXShell swig_types[74]
+#define SWIGTYPE_p_FXShutter swig_types[75]
+#define SWIGTYPE_p_FXShutterItem swig_types[76]
+#define SWIGTYPE_p_FXSlider swig_types[77]
+#define SWIGTYPE_p_FXSpinner swig_types[78]
+#define SWIGTYPE_p_FXSplashWindow swig_types[79]
+#define SWIGTYPE_p_FXSplitter swig_types[80]
+#define SWIGTYPE_p_FXSpring swig_types[81]
+#define SWIGTYPE_p_FXStatusBar swig_types[82]
+#define SWIGTYPE_p_FXStatusLine swig_types[83]
+#define SWIGTYPE_p_FXStream swig_types[84]
+#define SWIGTYPE_p_FXStringDict swig_types[85]
+#define SWIGTYPE_p_FXSwitcher swig_types[86]
+#define SWIGTYPE_p_FXTabBar swig_types[87]
+#define SWIGTYPE_p_FXTabBook swig_types[88]
+#define SWIGTYPE_p_FXTextField swig_types[89]
+#define SWIGTYPE_p_FXToolBar swig_types[90]
+#define SWIGTYPE_p_FXToolBarGrip swig_types[91]
+#define SWIGTYPE_p_FXToolBarShell swig_types[92]
+#define SWIGTYPE_p_FXToolBarTab swig_types[93]
+#define SWIGTYPE_p_FXToolTip swig_types[94]
+#define SWIGTYPE_p_FXTopWindow swig_types[95]
+#define SWIGTYPE_p_FXTranslator swig_types[96]
+#define SWIGTYPE_p_FXTreeListBox swig_types[97]
+#define SWIGTYPE_p_FXVerticalFrame swig_types[98]
+#define SWIGTYPE_p_FXVerticalSeparator swig_types[99]
+#define SWIGTYPE_p_FXVisual swig_types[100]
+#define SWIGTYPE_p_FXWindow swig_types[101]
+#define SWIGTYPE_p_NotifyHeader swig_types[102]
+#define SWIGTYPE_p_SCNotification swig_types[103]
+#define SWIGTYPE_p_TextRange swig_types[104]
+#define SWIGTYPE_p_char swig_types[105]
+#define SWIGTYPE_p_double swig_types[106]
+#define SWIGTYPE_p_float swig_types[107]
+#define SWIGTYPE_p_int swig_types[108]
+#define SWIGTYPE_p_long swig_types[109]
+#define SWIGTYPE_p_short swig_types[110]
+#define SWIGTYPE_p_unsigned_char swig_types[111]
+#define SWIGTYPE_p_unsigned_int swig_types[112]
+#define SWIGTYPE_p_unsigned_long swig_types[113]
+#define SWIGTYPE_p_unsigned_short swig_types[114]
+static swig_type_info *swig_types[116];
+static swig_module_info swig_module = {swig_types, 115, 0, 0, 0, 0};
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
+
+/* -------- TYPES TABLE (END) -------- */
+
+#define SWIG_init    Init_scintilla
+#define SWIG_name    "Scintilla"
+
+
+
+#define SWIG_RUBY_THREAD_BEGIN_BLOCK
+#define SWIG_RUBY_THREAD_END_BLOCK
+
+
+#define SWIGVERSION 0x030012 
+#define SWIG_VERSION SWIGVERSION
+
+
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
+
+
+#include <stdexcept>
+
+
+#include "FXRbCommon.h"
+
+
+inline FXColor to_FXColor(VALUE obj){
+  if(TYPE(obj)==T_STRING){
+    return fxcolorfromname(StringValuePtr(obj));
+    }
+  else if(TYPE(obj)==T_SYMBOL){
+    return fxcolorfromname(rb_id2name(SYM2ID(obj)));
+    }
+  else{
+    return NUM2ULONG(obj);
+    }
+  }
+
+
+inline FXString to_FXString(VALUE obj){
+  if(!NIL_P(obj)){
+    Check_Type(obj,T_STRING);
+    return FXString(StringValuePtr(obj));
+    }
+  else{
+    return FXString::null;
+    }
+  }
+
+
+inline FXbool to_FXbool(VALUE obj){
+  if (obj == Qtrue || obj == Qfalse){
+    return (obj == Qtrue) ? TRUE : FALSE;
+    }
+  else{
+    return static_cast<FXbool>(NUM2UINT(obj));
+    }
+  }
+
+
+static swig_type_info* FXEventTypeInfo=0;
+
+inline void* to_FXEvent(VALUE obj){
+  void* ptr;
+  if(!FXEventTypeInfo){
+    FXEventTypeInfo=SWIG_TypeQuery("FXEvent *");
+    FXASSERT(FXEventTypeInfo!=0);
+    }
+  SWIG_ConvertPtr(obj,&ptr,FXEventTypeInfo,1);
+  return ptr;
+  }
+
+
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
+
+
+  #define SWIG_From_long   LONG2NUM 
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_long  (unsigned long value)
+{
+  return ULONG2NUM(value); 
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_int  (unsigned int value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_int  (int value)
+{    
+  return SWIG_From_long  (value);
+}
+
+SWIGINTERN VALUE SCNotification_text(SCNotification const *self){
+      if (self->nmhdr.code==SCN_MODIFIED){
+        return (self->text) ? to_ruby(self->text,self->length) : Qnil;
+        }
+      else if (self->nmhdr.code==SCN_USERLISTSELECTION || self->nmhdr.code==SCN_URIDROPPED){
+        return (self->text) ? to_ruby(self->text) : Qnil;
+      } else {
+        return Qnil;
+      }
+    }
+SWIGINTERN VALUE SCNotification_wParam(SCNotification const *self){
+      return INT2NUM(self->wParam);
+    }
+SWIGINTERN VALUE SCNotification_lParam(SCNotification const *self){
+      return INT2NUM(self->lParam);
+    }
+
+SWIGINTERN swig_type_info*
+SWIG_pchar_descriptor(void)
+{
+  static int init = 0;
+  static swig_type_info* info = 0;
+  if (!init) {
+    info = SWIG_TypeQuery("_p_char");
+    init = 1;
+  }
+  return info;
+}
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+  if (carray) {
+    if (size > LONG_MAX) {
+      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+      return pchar_descriptor ? 
+	SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : Qnil;
+    } else {
+      return rb_str_new(carray, static_cast< long >(size));
+    }
+  } else {
+    return Qnil;
+  }
+}
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtr(const char *cptr)
+{ 
+  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
+}
+
+
+SWIGINTERN VALUE
+SWIG_ruby_failed(VALUE, VALUE)
+{
+  return Qnil;
+} 
+
+
+/*@SWIG:/usr/share/swig3.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE pargs){VALUE *args=(VALUE *)pargs;
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  long *res = (long *)(args[1]);
+  *res = type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj);
+  return obj;
+}
+/*@SWIG@*/
+
+SWIGINTERN int
+SWIG_AsVal_long (VALUE obj, long* val)
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
+    long v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_VALUE_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_VALUE_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_int (VALUE obj, int *val)
+{
+  long v;
+  int res = SWIG_AsVal_long (obj, &v);
+  if (SWIG_IsOK(res)) {
+    if ((v < INT_MIN || v > INT_MAX)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = static_cast< int >(v);
+    }
+  }  
+  return res;
+}
+
+
+/*@SWIG:/usr/share/swig3.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE pargs){VALUE *args=(VALUE *)pargs;
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  unsigned long *res = (unsigned long *)(args[1]);
+  *res = type == T_FIXNUM ? NUM2ULONG(obj) : rb_big2ulong(obj);
+  return obj;
+}
+/*@SWIG@*/
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_long (VALUE obj, unsigned long *val) 
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
+    unsigned long v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_VALUE_METHOD_FUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, RUBY_VALUE_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+#if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
+#  define SWIG_LONG_LONG_AVAILABLE
+#endif
+
+
+#ifdef SWIG_LONG_LONG_AVAILABLE
+/*@SWIG:/usr/share/swig3.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2ULL(VALUE pargs){VALUE *args=(VALUE *)pargs;
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  long long *res = (long long *)(args[1]);
+  *res = type == T_FIXNUM ? NUM2ULL(obj) : rb_big2ull(obj);
+  return obj;
+}
+/*@SWIG@*/
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_long_SS_long (VALUE obj, unsigned long long *val)
+{ 
+  VALUE type = TYPE(obj);
+  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
+    unsigned long long v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_VALUE_METHOD_FUNC(SWIG_AUX_NUM2ULL), (VALUE)a, RUBY_VALUE_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+#endif
+
+
+SWIGINTERNINLINE int
+SWIG_AsVal_size_t (VALUE obj, size_t *val)
+{
+  int res = SWIG_TypeError;
+#ifdef SWIG_LONG_LONG_AVAILABLE
+  if (sizeof(size_t) <= sizeof(unsigned long)) {
+#endif
+    unsigned long v;
+    res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
+    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
+#ifdef SWIG_LONG_LONG_AVAILABLE
+  } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
+    unsigned long long v;
+    res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
+    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
+  }
+#endif
+  return res;
+}
+
+SWIGINTERN TextRange *new_TextRange(int start,int last,size_t size){
+      TextRange *tr=new TextRange;
+      tr->chrg.cpMin=start;
+      tr->chrg.cpMax=last;
+      FXMALLOC(&tr->lpstrText,char,size);
+      return tr;
+      }
+SWIGINTERN FXScintilla *new_FXScintilla(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbScintilla(p,tgt,sel,opts,x,y,w,h);
+      }
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_int (VALUE obj, unsigned int *val)
+{
+  unsigned long v;
+  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
+  if (SWIG_IsOK(res)) {
+    if ((v > UINT_MAX)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = static_cast< unsigned int >(v);
+    }
+  }  
+  return res;
+}
+
+SWIGINTERN VALUE FXScintilla_sendMessage(FXScintilla *self,unsigned int iMsg,VALUE wParam=Qnil,VALUE lParam=Qnil){
+      // Convert wParam argument
+      uptr_t wp;
+      switch(TYPE(wParam)){
+        case T_BIGNUM:
+        case T_FIXNUM:
+          wp=static_cast<uptr_t>(NUM2SIZET(wParam));
+          break;
+        case T_STRING:
+          wp=static_cast<uptr_t>(reinterpret_cast<FXuval>(RSTRING_PTR(wParam)));
+          break;
+        case T_TRUE:
+        case T_FALSE:
+          wp=(wParam==Qtrue) ? 1 : 0;
+          break;
+        default:
+          wp=0;
+          break;
+        }
+
+      // Convert lParam argument
+      sptr_t lp;
+      switch(TYPE(lParam)){
+        case T_BIGNUM:
+        case T_FIXNUM:
+          lp=static_cast<sptr_t>(NUM2SIZET(lParam));
+          break;
+        case T_STRING:
+          lp=static_cast<sptr_t>(reinterpret_cast<FXival>(RSTRING_PTR(lParam)));
+          break;
+        case T_TRUE:
+        case T_FALSE:
+          lp=(lParam==Qtrue) ? 1 : 0;
+          break;
+        case T_DATA:
+          lp=reinterpret_cast<sptr_t>(DATA_PTR(lParam));
+          break;
+        default:
+          lp=0;
+          break;
+        }
+      sptr_t result=self->sendMessage(iMsg,wp,lp);
+      return INT2NUM(result);
+      }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_bool  (bool value)
+{
+  return value ? Qtrue : Qfalse;
+}
+
+
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
+{
+  if (TYPE(obj) == T_STRING) {
+    char *cstr = StringValuePtr(obj); 
+    size_t size = RSTRING_LEN(obj) + 1;
+    if (cptr)  {
+      if (alloc) {
+	if (*alloc == SWIG_NEWOBJ) {
+	  *cptr = reinterpret_cast< char* >(memcpy(new char[size], cstr, sizeof(char)*(size)));
+	} else {
+	  *cptr = cstr;
+	  *alloc = SWIG_OLDOBJ;
+	}
+      }
+    }
+    if (psize) *psize = size;
+    return SWIG_OK;
+  } else {
+    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+    if (pchar_descriptor) {
+      void* vptr = 0;
+      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
+	if (cptr) *cptr = (char *)vptr;
+	if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
+	if (alloc) *alloc = SWIG_OLDOBJ;
+	return SWIG_OK;
+      }
+    }
+  }  
+  return SWIG_TypeError;
+}
+
+
+
+
+SWIGINTERN VALUE FXScintilla_position__SWIG_1(FXScintilla const *self){
+    FXint x, y;
+    self->getPosition(x, y);
+    VALUE pos = rb_ary_new();
+    rb_ary_push(pos, INT2NUM(x));
+    rb_ary_push(pos, INT2NUM(y));
+    return pos;
+  }
+static swig_class SwigClassNotifyHeader;
+
+SWIGINTERN VALUE
+_wrap_NotifyHeader_idFrom_get(int argc, VALUE *argv, VALUE self) {
+  NotifyHeader *arg1 = (NotifyHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NotifyHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "NotifyHeader *","idFrom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< NotifyHeader * >(argp1);
+  result = (unsigned int) ((arg1)->idFrom);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_NotifyHeader_code_get(int argc, VALUE *argv, VALUE self) {
+  NotifyHeader *arg1 = (NotifyHeader *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_NotifyHeader, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "NotifyHeader *","code", 1, self )); 
+  }
+  arg1 = reinterpret_cast< NotifyHeader * >(argp1);
+  result = (unsigned int) ((arg1)->code);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassSCNotification;
+
+SWIGINTERN VALUE
+_wrap_SCNotification_nmhdr_get(int argc, VALUE *argv, VALUE self) {
+  SCNotification *arg1 = (SCNotification *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  NotifyHeader *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SCNotification, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SCNotification *","nmhdr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< SCNotification * >(argp1);
+  result = (NotifyHeader *)& ((arg1)->nmhdr);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NotifyHeader, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_SCNotification_position_get(int argc, VALUE *argv, VALUE self) {
+  SCNotification *arg1 = (SCNotification *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SCNotification, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SCNotification *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< SCNotification * >(argp1);
+  result = (int) ((arg1)->position);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_SCNotification_ch_get(int argc, VALUE *argv, VALUE self) {
+  SCNotification *arg1 = (SCNotification *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SCNotification, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SCNotification *","ch", 1, self )); 
+  }
+  arg1 = reinterpret_cast< SCNotification * >(argp1);
+  result = (int) ((arg1)->ch);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_SCNotification_modifiers_get(int argc, VALUE *argv, VALUE self) {
+  SCNotification *arg1 = (SCNotification *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SCNotification, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SCNotification *","modifiers", 1, self )); 
+  }
+  arg1 = reinterpret_cast< SCNotification * >(argp1);
+  result = (int) ((arg1)->modifiers);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_SCNotification_modificationType_get(int argc, VALUE *argv, VALUE self) {
+  SCNotification *arg1 = (SCNotification *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SCNotification, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SCNotification *","modificationType", 1, self )); 
+  }
+  arg1 = reinterpret_cast< SCNotification * >(argp1);
+  result = (int) ((arg1)->modificationType);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_SCNotification_text(int argc, VALUE *argv, VALUE self) {
+  SCNotification *arg1 = (SCNotification *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SCNotification, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SCNotification const *","text", 1, self )); 
+  }
+  arg1 = reinterpret_cast< SCNotification * >(argp1);
+  result = (VALUE)SCNotification_text((SCNotification const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_SCNotification_length_get(int argc, VALUE *argv, VALUE self) {
+  SCNotification *arg1 = (SCNotification *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SCNotification, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SCNotification *","length", 1, self )); 
+  }
+  arg1 = reinterpret_cast< SCNotification * >(argp1);
+  result = (int) ((arg1)->length);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_SCNotification_linesAdded_get(int argc, VALUE *argv, VALUE self) {
+  SCNotification *arg1 = (SCNotification *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SCNotification, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SCNotification *","linesAdded", 1, self )); 
+  }
+  arg1 = reinterpret_cast< SCNotification * >(argp1);
+  result = (int) ((arg1)->linesAdded);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_SCNotification_message_get(int argc, VALUE *argv, VALUE self) {
+  SCNotification *arg1 = (SCNotification *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SCNotification, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SCNotification *","message", 1, self )); 
+  }
+  arg1 = reinterpret_cast< SCNotification * >(argp1);
+  result = (int) ((arg1)->message);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_SCNotification_line_get(int argc, VALUE *argv, VALUE self) {
+  SCNotification *arg1 = (SCNotification *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SCNotification, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SCNotification *","line", 1, self )); 
+  }
+  arg1 = reinterpret_cast< SCNotification * >(argp1);
+  result = (int) ((arg1)->line);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_SCNotification_foldLevelNow_get(int argc, VALUE *argv, VALUE self) {
+  SCNotification *arg1 = (SCNotification *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SCNotification, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SCNotification *","foldLevelNow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< SCNotification * >(argp1);
+  result = (int) ((arg1)->foldLevelNow);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_SCNotification_foldLevelPrev_get(int argc, VALUE *argv, VALUE self) {
+  SCNotification *arg1 = (SCNotification *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SCNotification, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SCNotification *","foldLevelPrev", 1, self )); 
+  }
+  arg1 = reinterpret_cast< SCNotification * >(argp1);
+  result = (int) ((arg1)->foldLevelPrev);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_SCNotification_margin_get(int argc, VALUE *argv, VALUE self) {
+  SCNotification *arg1 = (SCNotification *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SCNotification, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SCNotification *","margin", 1, self )); 
+  }
+  arg1 = reinterpret_cast< SCNotification * >(argp1);
+  result = (int) ((arg1)->margin);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_SCNotification_listType_get(int argc, VALUE *argv, VALUE self) {
+  SCNotification *arg1 = (SCNotification *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SCNotification, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SCNotification *","listType", 1, self )); 
+  }
+  arg1 = reinterpret_cast< SCNotification * >(argp1);
+  result = (int) ((arg1)->listType);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_SCNotification_x_get(int argc, VALUE *argv, VALUE self) {
+  SCNotification *arg1 = (SCNotification *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SCNotification, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SCNotification *","x", 1, self )); 
+  }
+  arg1 = reinterpret_cast< SCNotification * >(argp1);
+  result = (int) ((arg1)->x);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_SCNotification_y_get(int argc, VALUE *argv, VALUE self) {
+  SCNotification *arg1 = (SCNotification *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SCNotification, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SCNotification *","y", 1, self )); 
+  }
+  arg1 = reinterpret_cast< SCNotification * >(argp1);
+  result = (int) ((arg1)->y);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_SCNotification_wParam(int argc, VALUE *argv, VALUE self) {
+  SCNotification *arg1 = (SCNotification *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SCNotification, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SCNotification const *","wParam", 1, self )); 
+  }
+  arg1 = reinterpret_cast< SCNotification * >(argp1);
+  result = (VALUE)SCNotification_wParam((SCNotification const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_SCNotification_lParam(int argc, VALUE *argv, VALUE self) {
+  SCNotification *arg1 = (SCNotification *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_SCNotification, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "SCNotification const *","lParam", 1, self )); 
+  }
+  arg1 = reinterpret_cast< SCNotification * >(argp1);
+  result = (VALUE)SCNotification_lParam((SCNotification const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassTextRange;
+
+SWIGINTERN VALUE
+_wrap_TextRange_lpstrText_get(int argc, VALUE *argv, VALUE self) {
+  TextRange *arg1 = (TextRange *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  char *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_TextRange, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "TextRange *","lpstrText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< TextRange * >(argp1);
+  result = (char *) ((arg1)->lpstrText);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_TextRange_allocate(VALUE self)
+#else
+_wrap_TextRange_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_TextRange);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_TextRange(int argc, VALUE *argv, VALUE self) {
+  int arg1 ;
+  int arg2 ;
+  size_t arg3 ;
+  int val1 ;
+  int ecode1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  size_t val3 ;
+  int ecode3 = 0 ;
+  TextRange *result = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  ecode1 = SWIG_AsVal_int(argv[0], &val1);
+  if (!SWIG_IsOK(ecode1)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","TextRange", 1, argv[0] ));
+  } 
+  arg1 = static_cast< int >(val1);
+  ecode2 = SWIG_AsVal_int(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","TextRange", 2, argv[1] ));
+  } 
+  arg2 = static_cast< int >(val2);
+  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","TextRange", 3, argv[2] ));
+  } 
+  arg3 = static_cast< size_t >(val3);
+  result = (TextRange *)new_TextRange(arg1,arg2,arg3);
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN void delete_TextRange(TextRange *self){
+      FXFREE(&self->lpstrText);
+      delete self;
+      }
+SWIGINTERN void
+free_TextRange(void *self) {
+    TextRange *arg1 = (TextRange *)self;
+    delete_TextRange(arg1);
+}
+
+static swig_class SwigClassFXScintilla;
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onScintillaCommand(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onScintillaCommand", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onScintillaCommand", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onScintillaCommand(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onConfigure(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onConfigure", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onConfigure", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onConfigure(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onTimeoutTicking(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onTimeoutTicking", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTimeoutTicking", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onTimeoutTicking(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onFocusIn(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onFocusIn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusIn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusIn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onFocusOut(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onFocusOut", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusOut", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusOut(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onRightBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onRightBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onRightBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onMiddleBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onMiddleBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMiddleBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMiddleBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onBeginDrag(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onBeginDrag", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onBeginDrag", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onBeginDrag(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onDragged(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onDragged", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDragged", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDragged(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onEndDrag(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onEndDrag", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEndDrag", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEndDrag(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onDNDEnter(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onDNDEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onDNDLeave(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onDNDLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onDNDMotion(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onDNDMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onDNDDrop(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onDNDDrop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDDrop", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDDrop(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onDNDRequest(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onDNDRequest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDRequest", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDRequest(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onSelectionLost(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onSelectionLost", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSelectionLost", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onSelectionLost(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onSelectionRequest(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onSelectionRequest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSelectionRequest", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onSelectionRequest(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onClipboardLost(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onClipboardLost", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClipboardLost", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onClipboardLost(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onClipboardRequest(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onClipboardRequest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClipboardRequest", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onClipboardRequest(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXScintilla_allocate(VALUE self)
+#else
+_wrap_FXScintilla_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXScintilla);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXScintilla(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXScintilla *result = 0 ;
+  
+  if ((argc < 1) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXScintilla", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXScintilla", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXScintilla *)new_FXScintilla(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_setScintillaID(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","setScintillaID", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setScintillaID", 2, argv[0] ));
+  } 
+  arg2 = static_cast< int >(val2);
+  (arg1)->setScintillaID(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_sendMessage(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  unsigned int arg2 ;
+  VALUE arg3 = (VALUE) Qnil ;
+  VALUE arg4 = (VALUE) Qnil ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  unsigned int val2 ;
+  int ecode2 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","sendMessage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","sendMessage", 2, argv[0] ));
+  } 
+  arg2 = static_cast< unsigned int >(val2);
+  if (argc > 1) {
+    arg3 = argv[1];
+  }
+  if (argc > 2) {
+    arg4 = argv[2];
+  }
+  result = (VALUE)FXScintilla_sendMessage(arg1,arg2,arg3,arg4);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_save(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXScintilla_save((FXScintilla const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_load(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXScintilla_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_create(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  FXScintilla_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_detach(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  FXScintilla_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_destroy(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  FXScintilla_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_resize(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXScintilla_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  result = (FXint)FXScintilla_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  result = (FXint)FXScintilla_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXScintilla_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXScintilla_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  result = (bool)FXScintilla_canFocus((FXScintilla const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  FXScintilla_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  FXScintilla_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXScintilla_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXScintilla_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_enable(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  FXScintilla_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_disable(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  FXScintilla_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  FXScintilla_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_lower(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  FXScintilla_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_move(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXScintilla_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXScintilla_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_layout(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  FXScintilla_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_recalc(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  FXScintilla_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_reparent(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXScintilla_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_show(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  FXScintilla_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_hide(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  FXScintilla_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  result = (bool)FXScintilla_isComposite((FXScintilla const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_contains(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXScintilla_contains((FXScintilla const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  result = (bool)FXScintilla_doesSaveUnder((FXScintilla const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXScintilla_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_tr(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXScintilla_tr((FXScintilla const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  FXScintilla_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  FXScintilla_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXScintilla_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXScintilla_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXScintilla_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXScintilla_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScintilla, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXScintilla_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScintilla, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXScintilla_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScintilla, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXScintilla_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  FXScintilla_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_getViewportHeight(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","getViewportHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  result = (FXint)FXScintilla_getViewportHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_getViewportWidth(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","getViewportWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  result = (FXint)FXScintilla_getViewportWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_getContentHeight(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","getContentHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  result = (FXint)FXScintilla_getContentHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_getContentWidth(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla *","getContentWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  result = (FXint)FXScintilla_getContentWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScintilla_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXScintilla *arg1 = (FXScintilla *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScintilla, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScintilla const *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScintilla * >(argp1);
+  result = (VALUE)FXScintilla_position__SWIG_1((FXScintilla const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXScintilla_position(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScintilla, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXScintilla_position__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScintilla, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXScintilla_position__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "position", 
+    "    void position(FXint x, FXint y, FXint w, FXint h)\n"
+    "    VALUE position()\n");
+  
+  return Qnil;
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_FXGradientBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShutterItemTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXMatrixTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXDrawableTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXDrawable *) x));
+}
+static void *_p_FXHeaderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXSplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSpringTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXProgressBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXToolTipTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXScintillaTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScintilla *) x));
+}
+static void *_p_FXDockSiteTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXCanvasTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXColorWheelTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXVisualTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXVisual *) x));
+}
+static void *_p_FXScrollBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXFontTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXFont *) x));
+}
+static void *_p_FXComboBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStatusBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXCursor *) x));
+}
+static void *_p_FXKnobTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRulerViewTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXStatusLineTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXMainWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXDockBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXToolBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDirBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXDocumentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDocument *) x));
+}
+static void *_p_FXGradientBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXRegistryTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *)(FXSettings *) ((FXRegistry *) x));
+}
+static void *_p_FXHeaderItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXHeaderItem *) x));
+}
+static void *_p_FXShutterItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXIconDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXIconDict *) x));
+}
+static void *_p_FXMatrixTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXFileDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXFileDict *) x));
+}
+static void *_p_FXRecentFilesTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXRecentFiles *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXDrawableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXDrawable *) x));
+}
+static void *_p_FXAppTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXApp *) x));
+}
+static void *_p_FXHeaderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXTranslatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXTranslator *) x));
+}
+static void *_p_FX4SplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FXSpringTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXIdTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXId *) x));
+}
+static void *_p_FXProgressBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXToolTipTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXSettingsTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXSettings *) x));
+}
+static void *_p_FXScintillaTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScintilla *) x));
+}
+static void *_p_FXDockSiteTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDebugTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDebugTarget *) x));
+}
+static void *_p_FXDataTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDataTarget *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXCanvasTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXListBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXColorWheelTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXVisualTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXVisual *) x));
+}
+static void *_p_FXScrollBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXFontTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXFont *) x));
+}
+static void *_p_FXComboBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStringDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXStringDict *) x));
+}
+static void *_p_FXStatusBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXDelegatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDelegator *) x));
+}
+static void *_p_FXAccelTableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXAccelTable *) x));
+}
+static void *_p_FXCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXKnobTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRulerViewTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXStatusLineTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXDockBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDict *) x));
+}
+static void *_p_FXShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXToolBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDirBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXScrollWindow *) x));
+}
+static void *_p_FXImageViewTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXImageView *) x));
+}
+static void *_p_FXRulerViewTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXRulerView *) x));
+}
+static void *_p_FXScintillaTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXScintilla *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXToolBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXCompositeTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXComposite *) x));
+}
+static void *_p_FXToolTipTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXTextFieldTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXTabBookTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXStatusBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXPopupTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXRulerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXCanvasTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXCanvas *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXScrollCorner *) x));
+}
+static void *_p_FXSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXStatusLineTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXComboBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXScintillaTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXScintilla *) x));
+}
+static void *_p_FXKnobTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FX4SplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FXPackerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXSpinnerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXScrollBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXScrollBar *) x));
+}
+static void *_p_FXColorWheelTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXGradientBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXDirBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXImageFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXDragCornerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXDragCorner *) x));
+}
+static void *_p_FXSwitcherTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXShutterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXProgressBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXDockSiteTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXDockTitleTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXRulerViewTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXListBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXHeaderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXMatrixTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXColorWellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXShutterItemTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXDialTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDockBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXFrame *) x));
+}
+static void *_p_FXTabBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FX7SegmentTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXImageViewTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXSliderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXRealSliderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSpringTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXColorRingTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXColorBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXToolBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolTipTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXTabBookTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXShell *) x));
+}
+static void *_p_FXStatusBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXScrollArea *) x));
+}
+static void *_p_FXPopupTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXComboBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXScintillaTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXScintilla *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FX4SplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXSplitter *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXPackerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXPacker *) x));
+}
+static void *_p_FXDirBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXSwitcherTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXShutterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXDockSiteTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXRulerViewTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXMatrixTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXShutterItemTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXDockBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXImageViewTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXSpringTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXToolBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXCompositeTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXToolTipTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXTextFieldTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXTabBookTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXStatusBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXPopupTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *)  ((FXWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXRulerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXCanvasTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXStatusLineTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXComboBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXScintillaTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScintilla *) x));
+}
+static void *_p_FXKnobTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FX4SplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FXPackerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXSpinnerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXScrollBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXColorWheelTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXGradientBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXDirBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXImageFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXDragCornerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXSwitcherTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXShutterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXProgressBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXDockSiteTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXDockTitleTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXRulerViewTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXListBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXHeaderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXMatrixTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXColorWellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXShutterItemTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXDialTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDockBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FXTabBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FX7SegmentTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXImageViewTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXRealSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSpringTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXColorRingTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXColorBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXFileStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXFileStream *) x));
+}
+static void *_p_FXMemoryStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXMemoryStream *) x));
+}
+static swig_type_info _swigt__p_FXBitmap = {"_p_FXBitmap", "FXBitmap *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXComposite = {"_p_FXComposite", "FXComposite *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDriveBox = {"_p_FXDriveBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBar = {"_p_FXToolBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolTip = {"_p_FXToolTip", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTabBook = {"_p_FXTabBook", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGroupBox = {"_p_FXGroupBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShell = {"_p_FXShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusBar = {"_p_FXStatusBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPopup = {"_p_FXPopup", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMainWindow = {"_p_FXMainWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTopWindow = {"_p_FXTopWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRootWindow = {"_p_FXRootWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplashWindow = {"_p_FXSplashWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollWindow = {"_p_FXScrollWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXComboBox = {"_p_FXComboBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalFrame = {"_p_FXHorizontalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalFrame = {"_p_FXVerticalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FX4Splitter = {"_p_FX4Splitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplitter = {"_p_FXSplitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRealSpinner = {"_p_FXRealSpinner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSpinner = {"_p_FXSpinner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPacker = {"_p_FXPacker", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDirBox = {"_p_FXDirBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSwitcher = {"_p_FXSwitcher", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDirSelector = {"_p_FXDirSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileSelector = {"_p_FXFileSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorSelector = {"_p_FXColorSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFontSelector = {"_p_FXFontSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutter = {"_p_FXShutter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockSite = {"_p_FXDockSite", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRulerView = {"_p_FXRulerView", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTreeListBox = {"_p_FXTreeListBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXListBox = {"_p_FXListBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMatrix = {"_p_FXMatrix", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutterItem = {"_p_FXShutterItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockBar = {"_p_FXDockBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTabBar = {"_p_FXTabBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImageView = {"_p_FXImageView", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSpring = {"_p_FXSpring", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarShell = {"_p_FXToolBarShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDrawable = {"_p_FXDrawable", "FXDrawable *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGradientBar = {"_p_FXGradientBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorBar = {"_p_FXColorBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTextField = {"_p_FXTextField", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarTab = {"_p_FXToolBarTab", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollCorner = {"_p_FXScrollCorner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXArrowButton = {"_p_FXArrowButton", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHeader = {"_p_FXHeader", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImageFrame = {"_p_FXImageFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSeparator = {"_p_FXSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalSeparator = {"_p_FXHorizontalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalSeparator = {"_p_FXVerticalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXKnob = {"_p_FXKnob", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXProgressBar = {"_p_FXProgressBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXBitmapFrame = {"_p_FXBitmapFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSlider = {"_p_FXSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRealSlider = {"_p_FXRealSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorRing = {"_p_FXColorRing", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockHandler = {"_p_FXDockHandler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCanvas = {"_p_FXCanvas", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWheel = {"_p_FXColorWheel", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDial = {"_p_FXDial", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarGrip = {"_p_FXToolBarGrip", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollBar = {"_p_FXScrollBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFrame = {"_p_FXFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FX7Segment = {"_p_FX7Segment", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockTitle = {"_p_FXDockTitle", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusLine = {"_p_FXStatusLine", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWell = {"_p_FXColorWell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDragCorner = {"_p_FXDragCorner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRuler = {"_p_FXRuler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXIcon = {"_p_FXIcon", "FXIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXId = {"_p_FXId", "FXId *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFont = {"_p_FXFont", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVisual = {"_p_FXVisual", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCursor = {"_p_FXCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCURCursor = {"_p_FXCURCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGIFCursor = {"_p_FXGIFCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXObject = {"_p_FXObject", "FXObject *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDocument = {"_p_FXDocument", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRegistry = {"_p_FXRegistry", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHeaderItem = {"_p_FXHeaderItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXIconDict = {"_p_FXIconDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileDict = {"_p_FXFileDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRecentFiles = {"_p_FXRecentFiles", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTranslator = {"_p_FXTranslator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXApp = {"_p_FXApp", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDict = {"_p_FXDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSettings = {"_p_FXSettings", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDataTarget = {"_p_FXDataTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDebugTarget = {"_p_FXDebugTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStringDict = {"_p_FXStringDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDelegator = {"_p_FXDelegator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXAccelTable = {"_p_FXAccelTable", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRegion = {"_p_FXRegion", "FXRegion *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXScintilla = {"_p_FXScintilla", "FXScintilla *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXScrollArea = {"_p_FXScrollArea", "FXScrollArea *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXStream = {"_p_FXStream", "FXStream *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFileStream = {"_p_FXFileStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMemoryStream = {"_p_FXMemoryStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXWindow = {"_p_FXWindow", "FXWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_NotifyHeader = {"_p_NotifyHeader", "NotifyHeader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_SCNotification = {"_p_SCNotification", "SCNotification *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_TextRange = {"_p_TextRange", "TextRange *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_char = {"_p_char", "char *|FXchar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "double *|FXdouble *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_float = {"_p_float", "float *|FXfloat *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "FXint *|int *|FXInputHandle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_long = {"_p_long", "long *|FXTime *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_short = {"_p_short", "short *|FXshort *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "FXuchar *|unsigned char *|FXbool *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "FXwchar *|FXDragType *|unsigned int *|FXuint *|FXColor *|FXSelector *|FXHotKey *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|FXuval *|FXPixel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|FXushort *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_FX4Splitter,
+  &_swigt__p_FX7Segment,
+  &_swigt__p_FXAccelTable,
+  &_swigt__p_FXApp,
+  &_swigt__p_FXArrowButton,
+  &_swigt__p_FXBitmap,
+  &_swigt__p_FXBitmapFrame,
+  &_swigt__p_FXCURCursor,
+  &_swigt__p_FXCanvas,
+  &_swigt__p_FXColorBar,
+  &_swigt__p_FXColorRing,
+  &_swigt__p_FXColorSelector,
+  &_swigt__p_FXColorWell,
+  &_swigt__p_FXColorWheel,
+  &_swigt__p_FXComboBox,
+  &_swigt__p_FXComposite,
+  &_swigt__p_FXCursor,
+  &_swigt__p_FXDataTarget,
+  &_swigt__p_FXDebugTarget,
+  &_swigt__p_FXDelegator,
+  &_swigt__p_FXDial,
+  &_swigt__p_FXDict,
+  &_swigt__p_FXDirBox,
+  &_swigt__p_FXDirSelector,
+  &_swigt__p_FXDockBar,
+  &_swigt__p_FXDockHandler,
+  &_swigt__p_FXDockSite,
+  &_swigt__p_FXDockTitle,
+  &_swigt__p_FXDocument,
+  &_swigt__p_FXDragCorner,
+  &_swigt__p_FXDrawable,
+  &_swigt__p_FXDriveBox,
+  &_swigt__p_FXFileDict,
+  &_swigt__p_FXFileSelector,
+  &_swigt__p_FXFileStream,
+  &_swigt__p_FXFont,
+  &_swigt__p_FXFontSelector,
+  &_swigt__p_FXFrame,
+  &_swigt__p_FXGIFCursor,
+  &_swigt__p_FXGradientBar,
+  &_swigt__p_FXGroupBox,
+  &_swigt__p_FXHeader,
+  &_swigt__p_FXHeaderItem,
+  &_swigt__p_FXHorizontalFrame,
+  &_swigt__p_FXHorizontalSeparator,
+  &_swigt__p_FXIcon,
+  &_swigt__p_FXIconDict,
+  &_swigt__p_FXId,
+  &_swigt__p_FXImageFrame,
+  &_swigt__p_FXImageView,
+  &_swigt__p_FXKnob,
+  &_swigt__p_FXListBox,
+  &_swigt__p_FXMainWindow,
+  &_swigt__p_FXMatrix,
+  &_swigt__p_FXMemoryStream,
+  &_swigt__p_FXObject,
+  &_swigt__p_FXPacker,
+  &_swigt__p_FXPopup,
+  &_swigt__p_FXProgressBar,
+  &_swigt__p_FXRealSlider,
+  &_swigt__p_FXRealSpinner,
+  &_swigt__p_FXRecentFiles,
+  &_swigt__p_FXRegion,
+  &_swigt__p_FXRegistry,
+  &_swigt__p_FXRootWindow,
+  &_swigt__p_FXRuler,
+  &_swigt__p_FXRulerView,
+  &_swigt__p_FXScintilla,
+  &_swigt__p_FXScrollArea,
+  &_swigt__p_FXScrollBar,
+  &_swigt__p_FXScrollCorner,
+  &_swigt__p_FXScrollWindow,
+  &_swigt__p_FXSeparator,
+  &_swigt__p_FXSettings,
+  &_swigt__p_FXShell,
+  &_swigt__p_FXShutter,
+  &_swigt__p_FXShutterItem,
+  &_swigt__p_FXSlider,
+  &_swigt__p_FXSpinner,
+  &_swigt__p_FXSplashWindow,
+  &_swigt__p_FXSplitter,
+  &_swigt__p_FXSpring,
+  &_swigt__p_FXStatusBar,
+  &_swigt__p_FXStatusLine,
+  &_swigt__p_FXStream,
+  &_swigt__p_FXStringDict,
+  &_swigt__p_FXSwitcher,
+  &_swigt__p_FXTabBar,
+  &_swigt__p_FXTabBook,
+  &_swigt__p_FXTextField,
+  &_swigt__p_FXToolBar,
+  &_swigt__p_FXToolBarGrip,
+  &_swigt__p_FXToolBarShell,
+  &_swigt__p_FXToolBarTab,
+  &_swigt__p_FXToolTip,
+  &_swigt__p_FXTopWindow,
+  &_swigt__p_FXTranslator,
+  &_swigt__p_FXTreeListBox,
+  &_swigt__p_FXVerticalFrame,
+  &_swigt__p_FXVerticalSeparator,
+  &_swigt__p_FXVisual,
+  &_swigt__p_FXWindow,
+  &_swigt__p_NotifyHeader,
+  &_swigt__p_SCNotification,
+  &_swigt__p_TextRange,
+  &_swigt__p_char,
+  &_swigt__p_double,
+  &_swigt__p_float,
+  &_swigt__p_int,
+  &_swigt__p_long,
+  &_swigt__p_short,
+  &_swigt__p_unsigned_char,
+  &_swigt__p_unsigned_int,
+  &_swigt__p_unsigned_long,
+  &_swigt__p_unsigned_short,
+};
+
+static swig_cast_info _swigc__p_FXBitmap[] = {  {&_swigt__p_FXBitmap, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDriveBox[] = {{&_swigt__p_FXDriveBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBar[] = {{&_swigt__p_FXToolBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolTip[] = {{&_swigt__p_FXToolTip, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabBook[] = {{&_swigt__p_FXTabBook, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGroupBox[] = {{&_swigt__p_FXGroupBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShell[] = {{&_swigt__p_FXShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusBar[] = {{&_swigt__p_FXStatusBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPopup[] = {{&_swigt__p_FXPopup, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMainWindow[] = {{&_swigt__p_FXMainWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTopWindow[] = {{&_swigt__p_FXTopWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRootWindow[] = {{&_swigt__p_FXRootWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplashWindow[] = {{&_swigt__p_FXSplashWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollWindow[] = {{&_swigt__p_FXScrollWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComboBox[] = {{&_swigt__p_FXComboBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalFrame[] = {{&_swigt__p_FXHorizontalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalFrame[] = {{&_swigt__p_FXVerticalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FX4Splitter[] = {{&_swigt__p_FX4Splitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplitter[] = {{&_swigt__p_FXSplitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSpinner[] = {{&_swigt__p_FXRealSpinner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpinner[] = {{&_swigt__p_FXSpinner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPacker[] = {{&_swigt__p_FXPacker, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirBox[] = {{&_swigt__p_FXDirBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSwitcher[] = {{&_swigt__p_FXSwitcher, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirSelector[] = {{&_swigt__p_FXDirSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileSelector[] = {{&_swigt__p_FXFileSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorSelector[] = {{&_swigt__p_FXColorSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFontSelector[] = {{&_swigt__p_FXFontSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutter[] = {{&_swigt__p_FXShutter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockSite[] = {{&_swigt__p_FXDockSite, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRulerView[] = {{&_swigt__p_FXRulerView, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTreeListBox[] = {{&_swigt__p_FXTreeListBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXListBox[] = {{&_swigt__p_FXListBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMatrix[] = {{&_swigt__p_FXMatrix, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutterItem[] = {{&_swigt__p_FXShutterItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockBar[] = {{&_swigt__p_FXDockBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabBar[] = {{&_swigt__p_FXTabBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageView[] = {{&_swigt__p_FXImageView, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpring[] = {{&_swigt__p_FXSpring, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarShell[] = {{&_swigt__p_FXToolBarShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComposite[] = {  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXComposite, 0, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXComposite, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXComposite, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScintilla, _p_FXScintillaTo_p_FXComposite, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXComposite, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXComposite, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGradientBar[] = {{&_swigt__p_FXGradientBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorBar[] = {{&_swigt__p_FXColorBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTextField[] = {{&_swigt__p_FXTextField, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarTab[] = {{&_swigt__p_FXToolBarTab, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollCorner[] = {{&_swigt__p_FXScrollCorner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXArrowButton[] = {{&_swigt__p_FXArrowButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeader[] = {{&_swigt__p_FXHeader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageFrame[] = {{&_swigt__p_FXImageFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSeparator[] = {{&_swigt__p_FXSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalSeparator[] = {{&_swigt__p_FXHorizontalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalSeparator[] = {{&_swigt__p_FXVerticalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXKnob[] = {{&_swigt__p_FXKnob, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXProgressBar[] = {{&_swigt__p_FXProgressBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBitmapFrame[] = {{&_swigt__p_FXBitmapFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSlider[] = {{&_swigt__p_FXSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSlider[] = {{&_swigt__p_FXRealSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorRing[] = {{&_swigt__p_FXColorRing, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockHandler[] = {{&_swigt__p_FXDockHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCanvas[] = {{&_swigt__p_FXCanvas, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWheel[] = {{&_swigt__p_FXColorWheel, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDial[] = {{&_swigt__p_FXDial, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarGrip[] = {{&_swigt__p_FXToolBarGrip, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollBar[] = {{&_swigt__p_FXScrollBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFrame[] = {{&_swigt__p_FXFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FX7Segment[] = {{&_swigt__p_FX7Segment, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockTitle[] = {{&_swigt__p_FXDockTitle, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusLine[] = {{&_swigt__p_FXStatusLine, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWell[] = {{&_swigt__p_FXColorWell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDragCorner[] = {{&_swigt__p_FXDragCorner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRuler[] = {{&_swigt__p_FXRuler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDrawable[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDrawable, 0, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScintilla, _p_FXScintillaTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXDrawable, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIcon[] = {  {&_swigt__p_FXIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFont[] = {{&_swigt__p_FXFont, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVisual[] = {{&_swigt__p_FXVisual, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCursor[] = {{&_swigt__p_FXCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCURCursor[] = {{&_swigt__p_FXCURCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGIFCursor[] = {{&_swigt__p_FXGIFCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXId[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXId, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXId, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXId, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXId, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXId, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXId, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXId, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXId, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXId, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXId, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXId, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXId, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXId, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXId, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXId, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXId, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXId, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXId, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXId, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXScintilla, _p_FXScintillaTo_p_FXId, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXId, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXId, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXId, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXId, 0, 0},  {&_swigt__p_FXId, 0, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXId, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXId, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXId, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXId, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXId, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXId, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXId, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXId, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXId, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXId, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXId, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXId, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXId, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXId, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDocument[] = {{&_swigt__p_FXDocument, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegistry[] = {{&_swigt__p_FXRegistry, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeaderItem[] = {{&_swigt__p_FXHeaderItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIconDict[] = {{&_swigt__p_FXIconDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileDict[] = {{&_swigt__p_FXFileDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRecentFiles[] = {{&_swigt__p_FXRecentFiles, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTranslator[] = {{&_swigt__p_FXTranslator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXApp[] = {{&_swigt__p_FXApp, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDict[] = {{&_swigt__p_FXDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSettings[] = {{&_swigt__p_FXSettings, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDataTarget[] = {{&_swigt__p_FXDataTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDebugTarget[] = {{&_swigt__p_FXDebugTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStringDict[] = {{&_swigt__p_FXStringDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDelegator[] = {{&_swigt__p_FXDelegator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXAccelTable[] = {{&_swigt__p_FXAccelTable, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXObject[] = {  {&_swigt__p_FXDocument, _p_FXDocumentTo_p_FXObject, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXRegistry, _p_FXRegistryTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeaderItem, _p_FXHeaderItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXObject, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXObject, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXIconDict, _p_FXIconDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileDict, _p_FXFileDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXRecentFiles, _p_FXRecentFilesTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXObject, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXObject, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXObject, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXObject, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FXTranslator, _p_FXTranslatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXObject, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXObject, 0, 0},  {&_swigt__p_FXApp, _p_FXAppTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXObject, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXObject, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXObject, 0, 0},  {&_swigt__p_FXDict, _p_FXDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXScintilla, _p_FXScintillaTo_p_FXObject, 0, 0},  {&_swigt__p_FXSettings, _p_FXSettingsTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXObject, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXObject, 0, 0},  {&_swigt__p_FXDataTarget, _p_FXDataTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDebugTarget, _p_FXDebugTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXObject, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXObject, 0, 0},  {&_swigt__p_FXId, _p_FXIdTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXObject, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXObject, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXStringDict, _p_FXStringDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXDelegator, _p_FXDelegatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXAccelTable, _p_FXAccelTableTo_p_FXObject, 0, 0},  {&_swigt__p_FXObject, 0, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXObject, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXObject, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXObject, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXObject, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXObject, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegion[] = {  {&_swigt__p_FXRegion, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScintilla[] = {  {&_swigt__p_FXScintilla, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollArea[] = {  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXScrollArea, 0, 0},  {&_swigt__p_FXScrollArea, 0, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXScrollArea, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXScrollArea, 0, 0},  {&_swigt__p_FXScintilla, _p_FXScintillaTo_p_FXScrollArea, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileStream[] = {{&_swigt__p_FXFileStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMemoryStream[] = {{&_swigt__p_FXMemoryStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStream[] = {  {&_swigt__p_FXFileStream, _p_FXFileStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXMemoryStream, _p_FXMemoryStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXWindow[] = {  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXWindow, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXWindow, 0, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXWindow, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScintilla, _p_FXScintillaTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXWindow, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXWindow, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXWindow, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXWindow, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXWindow, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_NotifyHeader[] = {  {&_swigt__p_NotifyHeader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_SCNotification[] = {  {&_swigt__p_SCNotification, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_TextRange[] = {  {&_swigt__p_TextRange, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
+
+static swig_cast_info *swig_cast_initial[] = {
+  _swigc__p_FX4Splitter,
+  _swigc__p_FX7Segment,
+  _swigc__p_FXAccelTable,
+  _swigc__p_FXApp,
+  _swigc__p_FXArrowButton,
+  _swigc__p_FXBitmap,
+  _swigc__p_FXBitmapFrame,
+  _swigc__p_FXCURCursor,
+  _swigc__p_FXCanvas,
+  _swigc__p_FXColorBar,
+  _swigc__p_FXColorRing,
+  _swigc__p_FXColorSelector,
+  _swigc__p_FXColorWell,
+  _swigc__p_FXColorWheel,
+  _swigc__p_FXComboBox,
+  _swigc__p_FXComposite,
+  _swigc__p_FXCursor,
+  _swigc__p_FXDataTarget,
+  _swigc__p_FXDebugTarget,
+  _swigc__p_FXDelegator,
+  _swigc__p_FXDial,
+  _swigc__p_FXDict,
+  _swigc__p_FXDirBox,
+  _swigc__p_FXDirSelector,
+  _swigc__p_FXDockBar,
+  _swigc__p_FXDockHandler,
+  _swigc__p_FXDockSite,
+  _swigc__p_FXDockTitle,
+  _swigc__p_FXDocument,
+  _swigc__p_FXDragCorner,
+  _swigc__p_FXDrawable,
+  _swigc__p_FXDriveBox,
+  _swigc__p_FXFileDict,
+  _swigc__p_FXFileSelector,
+  _swigc__p_FXFileStream,
+  _swigc__p_FXFont,
+  _swigc__p_FXFontSelector,
+  _swigc__p_FXFrame,
+  _swigc__p_FXGIFCursor,
+  _swigc__p_FXGradientBar,
+  _swigc__p_FXGroupBox,
+  _swigc__p_FXHeader,
+  _swigc__p_FXHeaderItem,
+  _swigc__p_FXHorizontalFrame,
+  _swigc__p_FXHorizontalSeparator,
+  _swigc__p_FXIcon,
+  _swigc__p_FXIconDict,
+  _swigc__p_FXId,
+  _swigc__p_FXImageFrame,
+  _swigc__p_FXImageView,
+  _swigc__p_FXKnob,
+  _swigc__p_FXListBox,
+  _swigc__p_FXMainWindow,
+  _swigc__p_FXMatrix,
+  _swigc__p_FXMemoryStream,
+  _swigc__p_FXObject,
+  _swigc__p_FXPacker,
+  _swigc__p_FXPopup,
+  _swigc__p_FXProgressBar,
+  _swigc__p_FXRealSlider,
+  _swigc__p_FXRealSpinner,
+  _swigc__p_FXRecentFiles,
+  _swigc__p_FXRegion,
+  _swigc__p_FXRegistry,
+  _swigc__p_FXRootWindow,
+  _swigc__p_FXRuler,
+  _swigc__p_FXRulerView,
+  _swigc__p_FXScintilla,
+  _swigc__p_FXScrollArea,
+  _swigc__p_FXScrollBar,
+  _swigc__p_FXScrollCorner,
+  _swigc__p_FXScrollWindow,
+  _swigc__p_FXSeparator,
+  _swigc__p_FXSettings,
+  _swigc__p_FXShell,
+  _swigc__p_FXShutter,
+  _swigc__p_FXShutterItem,
+  _swigc__p_FXSlider,
+  _swigc__p_FXSpinner,
+  _swigc__p_FXSplashWindow,
+  _swigc__p_FXSplitter,
+  _swigc__p_FXSpring,
+  _swigc__p_FXStatusBar,
+  _swigc__p_FXStatusLine,
+  _swigc__p_FXStream,
+  _swigc__p_FXStringDict,
+  _swigc__p_FXSwitcher,
+  _swigc__p_FXTabBar,
+  _swigc__p_FXTabBook,
+  _swigc__p_FXTextField,
+  _swigc__p_FXToolBar,
+  _swigc__p_FXToolBarGrip,
+  _swigc__p_FXToolBarShell,
+  _swigc__p_FXToolBarTab,
+  _swigc__p_FXToolTip,
+  _swigc__p_FXTopWindow,
+  _swigc__p_FXTranslator,
+  _swigc__p_FXTreeListBox,
+  _swigc__p_FXVerticalFrame,
+  _swigc__p_FXVerticalSeparator,
+  _swigc__p_FXVisual,
+  _swigc__p_FXWindow,
+  _swigc__p_NotifyHeader,
+  _swigc__p_SCNotification,
+  _swigc__p_TextRange,
+  _swigc__p_char,
+  _swigc__p_double,
+  _swigc__p_float,
+  _swigc__p_int,
+  _swigc__p_long,
+  _swigc__p_short,
+  _swigc__p_unsigned_char,
+  _swigc__p_unsigned_int,
+  _swigc__p_unsigned_long,
+  _swigc__p_unsigned_short,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned statically to an initial
+ * array. We just loop through that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded.
+ * There are three cases to handle:
+ *  1) If the cast->type has already been loaded AND the type we are adding
+ *     casting info to has not been loaded (it is in this module), THEN we
+ *     replace the cast->type pointer with the type pointer that has already
+ *     been loaded.
+ *  2) If BOTH types (the one we are adding casting info to, and the
+ *     cast->type) are loaded, THEN the cast info has already been loaded by
+ *     the previous module so we just ignore it.
+ *  3) Finally, if cast->type has not already been loaded, then we add that
+ *     swig_cast_info to the linked list (because the cast->type) pointer will
+ *     be correct.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* c-mode */
+#endif
+#endif
+
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+  size_t i;
+  swig_module_info *module_head, *iter;
+  int init;
+
+  /* check to see if the circular list has been setup, if not, set it up */
+  if (swig_module.next==0) {
+    /* Initialize the swig_module */
+    swig_module.type_initial = swig_type_initial;
+    swig_module.cast_initial = swig_cast_initial;
+    swig_module.next = &swig_module;
+    init = 1;
+  } else {
+    init = 0;
+  }
+
+  /* Try and load any already created modules */
+  module_head = SWIG_GetModule(clientdata);
+  if (!module_head) {
+    /* This is the first module loaded for this interpreter */
+    /* so set the swig module into the interpreter */
+    SWIG_SetModule(clientdata, &swig_module);
+  } else {
+    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+    iter=module_head;
+    do {
+      if (iter==&swig_module) {
+        /* Our module is already in the list, so there's nothing more to do. */
+        return;
+      }
+      iter=iter->next;
+    } while (iter!= module_head);
+
+    /* otherwise we must add our module into the list */
+    swig_module.next = module_head->next;
+    module_head->next = &swig_module;
+  }
+
+  /* When multiple interpreters are used, a module could have already been initialized in
+     a different interpreter, but not yet have a pointer in this interpreter.
+     In this case, we do not want to continue adding types... everything should be
+     set up already */
+  if (init == 0) return;
+
+  /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+  for (i = 0; i < swig_module.size; ++i) {
+    swig_type_info *type = 0;
+    swig_type_info *ret;
+    swig_cast_info *cast;
+
+#ifdef SWIGRUNTIME_DEBUG
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+
+    /* if there is another module already loaded */
+    if (swig_module.next != &swig_module) {
+      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
+    }
+    if (type) {
+      /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+      if (swig_module.type_initial[i]->clientdata) {
+	type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+      }
+    } else {
+      type = swig_module.type_initial[i];
+    }
+
+    /* Insert casting types */
+    cast = swig_module.cast_initial[i];
+    while (cast->type) {
+
+      /* Don't need to add information already in the list */
+      ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+      if (swig_module.next != &swig_module) {
+        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+      }
+      if (ret) {
+	if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+	  cast->type = ret;
+	  ret = 0;
+	} else {
+	  /* Check for casting already in the list */
+	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+	  if (!ocast) ret = 0;
+	}
+      }
+
+      if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+        if (type->cast) {
+          type->cast->prev = cast;
+          cast->next = type->cast;
+        }
+        type->cast = cast;
+      }
+      cast++;
+    }
+    /* Set entry in modules->types array equal to the type */
+    swig_module.types[i] = type;
+  }
+  swig_module.types[i] = 0;
+
+#ifdef SWIGRUNTIME_DEBUG
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+  for (i = 0; i < swig_module.size; ++i) {
+    int j = 0;
+    swig_cast_info *cast = swig_module.cast_initial[i];
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    while (cast->type) {
+      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+      cast++;
+      ++j;
+    }
+  printf("---- Total casts: %d\n",j);
+  }
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types.  It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+  size_t i;
+  swig_cast_info *equiv;
+  static int init_run = 0;
+
+  if (init_run) return;
+  init_run = 1;
+
+  for (i = 0; i < swig_module.size; i++) {
+    if (swig_module.types[i]->clientdata) {
+      equiv = swig_module.types[i]->cast;
+      while (equiv) {
+        if (!equiv->converter) {
+          if (equiv->type && !equiv->type->clientdata)
+            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+        }
+        equiv = equiv->next;
+      }
+    }
+  }
+}
+
+#ifdef __cplusplus
+#if 0
+{ /* c-mode */
+#endif
+}
+#endif
+
+/*
+
+*/
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void Init_scintilla(void) {
+  size_t i;
+  
+  SWIG_InitRuntime();
+  
+  
+  SWIG_InitializeModule(0);
+  for (i = 0; i < swig_module.size; i++) {
+    SWIG_define_class(swig_module.types[i]);
+  }
+  
+  SWIG_RubyInitializeTrackings();
+  
+  
+  
+  
+  
+  SwigClassNotifyHeader.klass = rb_define_class_under(mFox, "NotifyHeader", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_NotifyHeader, (void *) &SwigClassNotifyHeader);
+  rb_undef_alloc_func(SwigClassNotifyHeader.klass);
+  rb_define_method(SwigClassNotifyHeader.klass, "idFrom", VALUEFUNC(_wrap_NotifyHeader_idFrom_get), -1);
+  rb_define_method(SwigClassNotifyHeader.klass, "code", VALUEFUNC(_wrap_NotifyHeader_code_get), -1);
+  SwigClassNotifyHeader.mark = 0;
+  SwigClassNotifyHeader.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassNotifyHeader.trackObjects = 0;
+  
+  SwigClassSCNotification.klass = rb_define_class_under(mFox, "SCNotification", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_SCNotification, (void *) &SwigClassSCNotification);
+  rb_undef_alloc_func(SwigClassSCNotification.klass);
+  rb_define_method(SwigClassSCNotification.klass, "nmhdr", VALUEFUNC(_wrap_SCNotification_nmhdr_get), -1);
+  rb_define_method(SwigClassSCNotification.klass, "position", VALUEFUNC(_wrap_SCNotification_position_get), -1);
+  rb_define_method(SwigClassSCNotification.klass, "ch", VALUEFUNC(_wrap_SCNotification_ch_get), -1);
+  rb_define_method(SwigClassSCNotification.klass, "modifiers", VALUEFUNC(_wrap_SCNotification_modifiers_get), -1);
+  rb_define_method(SwigClassSCNotification.klass, "modificationType", VALUEFUNC(_wrap_SCNotification_modificationType_get), -1);
+  rb_define_method(SwigClassSCNotification.klass, "text", VALUEFUNC(_wrap_SCNotification_text), -1);
+  rb_define_method(SwigClassSCNotification.klass, "length", VALUEFUNC(_wrap_SCNotification_length_get), -1);
+  rb_define_method(SwigClassSCNotification.klass, "linesAdded", VALUEFUNC(_wrap_SCNotification_linesAdded_get), -1);
+  rb_define_method(SwigClassSCNotification.klass, "message", VALUEFUNC(_wrap_SCNotification_message_get), -1);
+  rb_define_method(SwigClassSCNotification.klass, "line", VALUEFUNC(_wrap_SCNotification_line_get), -1);
+  rb_define_method(SwigClassSCNotification.klass, "foldLevelNow", VALUEFUNC(_wrap_SCNotification_foldLevelNow_get), -1);
+  rb_define_method(SwigClassSCNotification.klass, "foldLevelPrev", VALUEFUNC(_wrap_SCNotification_foldLevelPrev_get), -1);
+  rb_define_method(SwigClassSCNotification.klass, "margin", VALUEFUNC(_wrap_SCNotification_margin_get), -1);
+  rb_define_method(SwigClassSCNotification.klass, "listType", VALUEFUNC(_wrap_SCNotification_listType_get), -1);
+  rb_define_method(SwigClassSCNotification.klass, "x", VALUEFUNC(_wrap_SCNotification_x_get), -1);
+  rb_define_method(SwigClassSCNotification.klass, "y", VALUEFUNC(_wrap_SCNotification_y_get), -1);
+  rb_define_method(SwigClassSCNotification.klass, "wParam", VALUEFUNC(_wrap_SCNotification_wParam), -1);
+  rb_define_method(SwigClassSCNotification.klass, "lParam", VALUEFUNC(_wrap_SCNotification_lParam), -1);
+  SwigClassSCNotification.mark = 0;
+  SwigClassSCNotification.destroy = (void (*)(void *)) FXRbUnregisterRubyObj;
+  SwigClassSCNotification.trackObjects = 0;
+  
+  SwigClassTextRange.klass = rb_define_class_under(mFox, "TextRange", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_TextRange, (void *) &SwigClassTextRange);
+  rb_define_alloc_func(SwigClassTextRange.klass, _wrap_TextRange_allocate);
+  rb_define_method(SwigClassTextRange.klass, "initialize", VALUEFUNC(_wrap_new_TextRange), -1);
+  rb_define_method(SwigClassTextRange.klass, "lpstrText", VALUEFUNC(_wrap_TextRange_lpstrText_get), -1);
+  SwigClassTextRange.mark = 0;
+  SwigClassTextRange.destroy = (void (*)(void *)) free_TextRange;
+  SwigClassTextRange.trackObjects = 0;
+  
+  SwigClassFXScintilla.klass = rb_define_class_under(mFox, "FXScintilla", ((swig_class *) SWIGTYPE_p_FXScrollArea->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXScintilla, (void *) &SwigClassFXScintilla);
+  rb_define_alloc_func(SwigClassFXScintilla.klass, _wrap_FXScintilla_allocate);
+  rb_define_method(SwigClassFXScintilla.klass, "initialize", VALUEFUNC(_wrap_new_FXScintilla), -1);
+  rb_define_const(SwigClassFXScintilla.klass, "ID_TICK", SWIG_From_int(static_cast< int >(FXScintilla::ID_TICK)));
+  rb_define_method(SwigClassFXScintilla.klass, "onScintillaCommand", VALUEFUNC(_wrap_FXScintilla_onScintillaCommand), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "onPaint", VALUEFUNC(_wrap_FXScintilla_onPaint), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "onConfigure", VALUEFUNC(_wrap_FXScintilla_onConfigure), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "onTimeoutTicking", VALUEFUNC(_wrap_FXScintilla_onTimeoutTicking), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "onFocusIn", VALUEFUNC(_wrap_FXScintilla_onFocusIn), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "onFocusOut", VALUEFUNC(_wrap_FXScintilla_onFocusOut), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "onMotion", VALUEFUNC(_wrap_FXScintilla_onMotion), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXScintilla_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXScintilla_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "onRightBtnPress", VALUEFUNC(_wrap_FXScintilla_onRightBtnPress), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "onMiddleBtnPress", VALUEFUNC(_wrap_FXScintilla_onMiddleBtnPress), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "onBeginDrag", VALUEFUNC(_wrap_FXScintilla_onBeginDrag), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "onDragged", VALUEFUNC(_wrap_FXScintilla_onDragged), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "onEndDrag", VALUEFUNC(_wrap_FXScintilla_onEndDrag), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "onDNDEnter", VALUEFUNC(_wrap_FXScintilla_onDNDEnter), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "onDNDLeave", VALUEFUNC(_wrap_FXScintilla_onDNDLeave), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "onDNDMotion", VALUEFUNC(_wrap_FXScintilla_onDNDMotion), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "onDNDDrop", VALUEFUNC(_wrap_FXScintilla_onDNDDrop), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "onDNDRequest", VALUEFUNC(_wrap_FXScintilla_onDNDRequest), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "onSelectionLost", VALUEFUNC(_wrap_FXScintilla_onSelectionLost), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "onSelectionRequest", VALUEFUNC(_wrap_FXScintilla_onSelectionRequest), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "onClipboardLost", VALUEFUNC(_wrap_FXScintilla_onClipboardLost), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "onClipboardRequest", VALUEFUNC(_wrap_FXScintilla_onClipboardRequest), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "onKeyPress", VALUEFUNC(_wrap_FXScintilla_onKeyPress), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "setScintillaID", VALUEFUNC(_wrap_FXScintilla_setScintillaID), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "sendMessage", VALUEFUNC(_wrap_FXScintilla_sendMessage), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "save", VALUEFUNC(_wrap_FXScintilla_save), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "load", VALUEFUNC(_wrap_FXScintilla_load), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "create", VALUEFUNC(_wrap_FXScintilla_create), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "detach", VALUEFUNC(_wrap_FXScintilla_detach), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "destroy", VALUEFUNC(_wrap_FXScintilla_destroy), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "resize", VALUEFUNC(_wrap_FXScintilla_resize), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXScintilla_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXScintilla_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXScintilla_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXScintilla_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "canFocus", VALUEFUNC(_wrap_FXScintilla_canFocus), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "setFocus", VALUEFUNC(_wrap_FXScintilla_setFocus), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "killFocus", VALUEFUNC(_wrap_FXScintilla_killFocus), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "changeFocus", VALUEFUNC(_wrap_FXScintilla_changeFocus), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "setDefault", VALUEFUNC(_wrap_FXScintilla_setDefault), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "enable", VALUEFUNC(_wrap_FXScintilla_enable), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "disable", VALUEFUNC(_wrap_FXScintilla_disable), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "raiseWindow", VALUEFUNC(_wrap_FXScintilla_raiseWindow), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "lower", VALUEFUNC(_wrap_FXScintilla_lower), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "move", VALUEFUNC(_wrap_FXScintilla_move), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "layout", VALUEFUNC(_wrap_FXScintilla_layout), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "recalc", VALUEFUNC(_wrap_FXScintilla_recalc), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "reparent", VALUEFUNC(_wrap_FXScintilla_reparent), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "show", VALUEFUNC(_wrap_FXScintilla_show), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "hide", VALUEFUNC(_wrap_FXScintilla_hide), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "isComposite", VALUEFUNC(_wrap_FXScintilla_isComposite), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "contains", VALUEFUNC(_wrap_FXScintilla_contains), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXScintilla_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "setBackColor", VALUEFUNC(_wrap_FXScintilla_setBackColor), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "tr", VALUEFUNC(_wrap_FXScintilla_tr), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "dropEnable", VALUEFUNC(_wrap_FXScintilla_dropEnable), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "dropDisable", VALUEFUNC(_wrap_FXScintilla_dropDisable), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "setShape", VALUEFUNC(_wrap_FXScintilla_setShape), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "clearShape", VALUEFUNC(_wrap_FXScintilla_clearShape), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "getViewportHeight", VALUEFUNC(_wrap_FXScintilla_getViewportHeight), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "getViewportWidth", VALUEFUNC(_wrap_FXScintilla_getViewportWidth), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "getContentHeight", VALUEFUNC(_wrap_FXScintilla_getContentHeight), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "getContentWidth", VALUEFUNC(_wrap_FXScintilla_getContentWidth), -1);
+  rb_define_method(SwigClassFXScintilla.klass, "position", VALUEFUNC(_wrap_FXScintilla_position), -1);
+  SwigClassFXScintilla.mark = (void (*)(void *)) FXRbScintilla::markfunc;
+  SwigClassFXScintilla.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXScintilla.trackObjects = 0;
+}
+
+#endif /* WITH_FXSCINTILLA */
diff --git a/ext/fox16_c/swigruby.h b/ext/fox16_c/swigruby.h
new file mode 100644
index 00000000..57d5b463
--- /dev/null
+++ b/ext/fox16_c/swigruby.h
@@ -0,0 +1,1707 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 3.0.12
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+/*  Errors in SWIG */
+#define  SWIG_UnknownError    	   -1
+#define  SWIG_IOError        	   -2
+#define  SWIG_RuntimeError   	   -3
+#define  SWIG_IndexError     	   -4
+#define  SWIG_TypeError      	   -5
+#define  SWIG_DivisionByZero 	   -6
+#define  SWIG_OverflowError  	   -7
+#define  SWIG_SyntaxError    	   -8
+#define  SWIG_ValueError     	   -9
+#define  SWIG_SystemError    	   -10
+#define  SWIG_AttributeError 	   -11
+#define  SWIG_MemoryError    	   -12
+#define  SWIG_NullReferenceError   -13
+
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic C API SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "4"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/*  Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN           0x1
+
+
+/*
+   Flags/methods for returning states.
+
+   The SWIG conversion methods, as ConvertPtr, return an integer
+   that tells if the conversion was successful or not. And if not,
+   an error code can be returned (see swigerrors.swg for the codes).
+
+   Use the following macros/flags to set or process the returning
+   states.
+
+   In old versions of SWIG, code such as the following was usually written:
+
+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+       // success code
+     } else {
+       //fail code
+     }
+
+   Now you can be more explicit:
+
+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+    } else {
+      // fail code
+    }
+
+   which is the same really, but now you can also do
+
+    Type *ptr;
+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+      if (SWIG_IsNewObj(res) {
+        ...
+	delete *ptr;
+      } else {
+        ...
+      }
+    } else {
+      // fail code
+    }
+
+   I.e., now SWIG_ConvertPtr can return new objects and you can
+   identify the case and take care of the deallocation. Of course that
+   also requires SWIG_ConvertPtr to return new result values, such as
+
+      int SWIG_ConvertPtr(obj, ptr,...) {
+        if (<obj is ok>) {
+          if (<need new object>) {
+            *ptr = <ptr to new allocated object>;
+            return SWIG_NEWOBJ;
+          } else {
+            *ptr = <ptr to old object>;
+            return SWIG_OLDOBJ;
+          }
+        } else {
+          return SWIG_BADOBJ;
+        }
+      }
+
+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+   SWIG errors code.
+
+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+   allows to return the 'cast rank', for example, if you have this
+
+       int food(double)
+       int fooi(int);
+
+   and you call
+
+      food(1)   // cast rank '1'  (1 -> 1.0)
+      fooi(1)   // cast rank '0'
+
+   just use the SWIG_AddCast()/SWIG_CheckState()
+*/
+
+#define SWIG_OK                    (0)
+#define SWIG_ERROR                 (-1)
+#define SWIG_IsOK(r)               (r >= 0)
+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT         (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ                (SWIG_ERROR)
+#define SWIG_OLDOBJ                (SWIG_OK)
+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+#  ifndef SWIG_TypeRank
+#    define SWIG_TypeRank             unsigned long
+#  endif
+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
+#    define SWIG_MAXCASTRANK          (2)
+#  endif
+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+#  define SWIG_AddCast(r) (r)
+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *, int *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store information on one type */
+typedef struct swig_type_info {
+  const char             *name;			/* mangled name of this type */
+  const char             *str;			/* human readable name of this type */
+  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
+  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
+  void                   *clientdata;		/* language specific type data */
+  int                    owndata;		/* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
+  swig_converter_func     converter;		/* function to cast the void pointers */
+  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
+  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
+  size_t                 size;		        /* Number of types in this module */
+  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
+  swig_type_info         **type_initial;	/* Array of initially generated type structures */
+  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
+  void                    *clientdata;		/* Language specific module data */
+} swig_module_info;
+
+/*
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+  }
+  return (int)((l1 - f1) - (l2 - f2));
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCmp(const char *nb, const char *tb) {
+  int equiv = 1;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (equiv != 0 && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
+}
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
+}
+
+/*
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+  swig_type_info *lastty = ty;
+  if (!ty || !ty->dcast) return ty;
+  while (ty && (ty->dcast)) {
+    ty = (*ty->dcast)(ptr);
+    if (ty) lastty = ty;
+  }
+  return lastty;
+}
+
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+  return ty->name;
+}
+
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (!type) return NULL;
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
+  }
+  else
+    return type->name;
+}
+
+/*
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+  swig_cast_info *cast = ti->cast;
+  /* if (ti->clientdata == clientdata) return; */
+  ti->clientdata = clientdata;
+
+  while (cast) {
+    if (!cast->converter) {
+      swig_type_info *tc = cast->type;
+      if (!tc->clientdata) {
+	SWIG_TypeClientData(tc, clientdata);
+      }
+    }
+    cast = cast->next;
+  }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientData(ti, clientdata);
+  ti->owndata = 1;
+}
+
+/*
+  Search for a swig_type_info structure only by mangled name
+  Search is a O(log #types)
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+                            swig_module_info *end,
+		            const char *name) {
+  swig_module_info *iter = start;
+  do {
+    if (iter->size) {
+      size_t l = 0;
+      size_t r = iter->size - 1;
+      do {
+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
+	size_t i = (l + r) >> 1;
+	const char *iname = iter->types[i]->name;
+	if (iname) {
+	  int compare = strcmp(name, iname);
+	  if (compare == 0) {
+	    return iter->types[i];
+	  } else if (compare < 0) {
+	    if (i) {
+	      r = i - 1;
+	    } else {
+	      break;
+	    }
+	  } else if (compare > 0) {
+	    l = i + 1;
+	  }
+	} else {
+	  break; /* should never happen */
+	}
+      } while (l <= r);
+    }
+    iter = iter->next;
+  } while (iter != end);
+  return 0;
+}
+
+/*
+  Search for a swig_type_info structure for either a mangled name or a human readable name.
+  It first searches the mangled names of the types, which is a O(log #types)
+  If a type is not found it then searches the human readable names, which is O(#types).
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+                     swig_module_info *end,
+		     const char *name) {
+  /* STEP 1: Search the name field using binary search */
+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+  if (ret) {
+    return ret;
+  } else {
+    /* STEP 2: If the type hasn't been found, do a complete search
+       of the str field (the human readable name) */
+    swig_module_info *iter = start;
+    do {
+      size_t i = 0;
+      for (; i < iter->size; ++i) {
+	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+	  return iter->types[i];
+      }
+      iter = iter->next;
+    } while (iter != end);
+  }
+
+  /* neither found a match */
+  return 0;
+}
+
+/*
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+
+/*
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = (unsigned char)((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = (unsigned char)((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (unsigned char)(d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (unsigned char)(d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/*
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+      #include <ruby.h>
+
+      #if defined(RB_METHOD_DEFINITION_DECL)
+      # define RUBY_VALUE_METHOD_FUNC(func) (func)
+      # define RUBY_INT_METHOD_FUNC(func) (func)
+      # define RUBY_VOID_METHOD_FUNC(func) (func)
+      # define RUBY_VOIDP_METHOD_FUNC(func) (func)
+      #else
+      # define RUBY_VALUE_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
+      # define RUBY_INT_METHOD_FUNC(func) ((int (*)(ANYARGS))(func))
+      # define RUBY_VOID_METHOD_FUNC(func) ((void (*)(ANYARGS))(func))
+      # define RUBY_VOIDP_METHOD_FUNC(func) ((void *(*)(ANYARGS))(func))
+      #endif
+
+
+/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
+ * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
+ * issue for now by disabling this.
+ * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
+ */
+#ifdef rb_intern
+# undef rb_intern
+#endif
+
+/* Remove global macros defined in Ruby's win32.h */
+#ifdef write
+# undef write
+#endif
+#ifdef read
+# undef read
+#endif
+#ifdef bind
+# undef bind
+#endif
+#ifdef close
+# undef close
+#endif
+#ifdef connect
+# undef connect
+#endif
+
+
+/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
+#ifndef NUM2LL
+#define NUM2LL(x) NUM2LONG((x))
+#endif
+#ifndef LL2NUM
+#define LL2NUM(x) INT2NUM((long) (x))
+#endif
+#ifndef ULL2NUM
+#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
+#endif
+
+/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
+#ifndef NUM2ULL
+#ifdef HAVE_LONG_LONG
+#define NUM2ULL(x) rb_num2ull((x))
+#else
+#define NUM2ULL(x) NUM2ULONG(x)
+#endif
+#endif
+
+/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
+/* Define these for older versions so we can just write code the new way */
+#ifndef RSTRING_LEN
+# define RSTRING_LEN(x) RSTRING(x)->len
+#endif
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(x) RSTRING(x)->ptr
+#endif
+#ifndef RSTRING_END
+# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
+#endif
+#ifndef RARRAY_LEN
+# define RARRAY_LEN(x) RARRAY(x)->len
+#endif
+#ifndef RARRAY_PTR
+# define RARRAY_PTR(x) RARRAY(x)->ptr
+#endif
+#ifndef RFLOAT_VALUE
+# define RFLOAT_VALUE(x) RFLOAT(x)->value
+#endif
+#ifndef DOUBLE2NUM
+# define DOUBLE2NUM(x) rb_float_new(x)
+#endif
+#ifndef RHASH_TBL
+# define RHASH_TBL(x) (RHASH(x)->tbl)
+#endif
+#ifndef RHASH_ITER_LEV
+# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
+#endif
+#ifndef RHASH_IFNONE
+# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
+#endif
+#ifndef RHASH_SIZE
+# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
+#endif
+#ifndef RHASH_EMPTY_P
+# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
+#endif
+#ifndef RSTRUCT_LEN
+# define RSTRUCT_LEN(x) RSTRUCT(x)->len
+#endif
+#ifndef RSTRUCT_PTR
+# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
+#endif
+
+
+
+/*
+ * Need to be very careful about how these macros are defined, especially
+ * when compiling C++ code or C code with an ANSI C compiler.
+ *
+ * VALUEFUNC(f) is a macro used to typecast a C function that implements
+ * a Ruby method so that it can be passed as an argument to API functions
+ * like rb_define_method() and rb_define_singleton_method().
+ *
+ * VOIDFUNC(f) is a macro used to typecast a C function that implements
+ * either the "mark" or "free" stuff for a Ruby Data object, so that it
+ * can be passed as an argument to API functions like Data_Wrap_Struct()
+ * and Data_Make_Struct().
+ */
+ 
+#ifdef __cplusplus
+#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
+#    define PROTECTFUNC(f) ((VALUE (*)()) f)
+#    define VALUEFUNC(f) ((VALUE (*)()) f)
+#    define VOIDFUNC(f)  ((void (*)()) f)
+#  else
+#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
+#      define PROTECTFUNC(f) ((VALUE (*)()) f)
+#      define VALUEFUNC(f) ((VALUE (*)()) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    else /* These definitions should work for Ruby 1.7+ */
+#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
+#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    endif
+#  endif
+#else
+#  define VALUEFUNC(f) (f)
+#  define VOIDFUNC(f) (f)
+#endif
+
+/* Don't use for expressions have side effect */
+#ifndef RB_STRING_VALUE
+#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
+#endif
+#ifndef StringValue
+#define StringValue(s) RB_STRING_VALUE(s)
+#endif
+#ifndef StringValuePtr
+#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
+#endif
+#ifndef StringValueLen
+#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
+#endif
+#ifndef SafeStringValue
+#define SafeStringValue(v) do {\
+    StringValue(v);\
+    rb_check_safe_str(v);\
+} while (0)
+#endif
+
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
+#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
+#endif
+
+static VALUE _mSWIG = Qnil;
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+
+/* Define some additional error types */
+#define SWIG_ObjectPreviouslyDeletedError  -100
+
+
+/* Define custom exceptions for errors that do not map to existing Ruby
+   exceptions.  Note this only works for C++ since a global cannot be
+   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/
+
+SWIGINTERN VALUE 
+getNullReferenceError(void) {
+  static int init = 0;
+  static VALUE rb_eNullReferenceError ;
+  if (!init) {
+    init = 1;
+    rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
+  }
+  return rb_eNullReferenceError;
+} 
+
+SWIGINTERN VALUE 
+getObjectPreviouslyDeletedError(void) {
+  static int init = 0;
+  static VALUE rb_eObjectPreviouslyDeleted ;
+  if (!init) {
+    init = 1;
+    rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
+  }
+  return rb_eObjectPreviouslyDeleted;
+} 
+
+
+SWIGINTERN VALUE
+SWIG_Ruby_ErrorType(int SWIG_code) {
+  VALUE type;
+  switch (SWIG_code) {
+  case SWIG_MemoryError:
+    type = rb_eNoMemError;
+    break;
+  case SWIG_IOError:
+    type = rb_eIOError;
+    break;
+  case SWIG_RuntimeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_IndexError:
+    type = rb_eIndexError;
+    break;
+  case SWIG_TypeError:
+    type = rb_eTypeError;
+    break;
+  case SWIG_DivisionByZero:
+    type = rb_eZeroDivError;
+    break;
+  case SWIG_OverflowError:
+    type = rb_eRangeError;
+    break;
+  case SWIG_SyntaxError:
+    type = rb_eSyntaxError;
+    break;
+  case SWIG_ValueError:
+    type = rb_eArgError;
+    break;
+  case SWIG_SystemError:
+    type = rb_eFatal;
+    break;
+  case SWIG_AttributeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_NullReferenceError:
+    type = getNullReferenceError();
+    break;
+  case SWIG_ObjectPreviouslyDeletedError:
+    type = getObjectPreviouslyDeletedError();
+    break;
+  case SWIG_UnknownError:
+    type = rb_eRuntimeError;
+    break;
+  default:
+    type = rb_eRuntimeError;
+  }
+  return type;
+}
+
+
+/* This function is called when a user inputs a wrong argument to
+   a method.
+ */
+SWIGINTERN 
+const char* Ruby_Format_TypeError( const char* msg,
+				   const char* type, 
+				   const char* name, 
+				   const int argn,
+				   VALUE input )
+{
+  char buf[128];
+  VALUE str;
+  VALUE asStr;
+  if ( msg && *msg )
+    {
+      str = rb_str_new2(msg);
+    }
+  else
+    {
+      str = rb_str_new(NULL, 0);
+    }
+
+  str = rb_str_cat2( str, "Expected argument " );
+  sprintf( buf, "%d of type ", argn-1 );
+  str = rb_str_cat2( str, buf );
+  str = rb_str_cat2( str, type );
+  str = rb_str_cat2( str, ", but got " );
+  str = rb_str_cat2( str, rb_obj_classname(input) );
+  str = rb_str_cat2( str, " " );
+  asStr = rb_inspect(input);
+  if ( RSTRING_LEN(asStr) > 30 )
+    {
+      str = rb_str_cat( str, StringValuePtr(asStr), 30 );
+      str = rb_str_cat2( str, "..." );
+    }
+  else
+    {
+      str = rb_str_append( str, asStr );
+    }
+
+  if ( name )
+    {
+      str = rb_str_cat2( str, "\n\tin SWIG method '" );
+      str = rb_str_cat2( str, name );
+      str = rb_str_cat2( str, "'" );
+    }
+
+  return StringValuePtr( str );
+}
+
+/* This function is called when an overloaded method fails */
+SWIGINTERN 
+void Ruby_Format_OverloadedError(
+				 const int argc,
+				 const int maxargs,
+				 const char* method, 
+				 const char* prototypes 
+				 )
+{
+  const char* msg = "Wrong # of arguments";
+  if ( argc <= maxargs ) msg = "Wrong arguments";
+  rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
+	   "Possible C/C++ prototypes are:\n%s",
+	   msg, method, prototypes);
+}
+/* -----------------------------------------------------------------------------
+ * rubytracking.swg
+ *
+ * This file contains support for tracking mappings from 
+ * Ruby objects to C++ objects.  This functionality is needed
+ * to implement mark functions for Ruby's mark and sweep
+ * garbage collector.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(ST_DATA_T_DEFINED)
+/* Needs to be explicitly included for Ruby 1.8 and earlier */
+#include <st.h>
+#endif
+
+/* Ruby 1.8 actually assumes the first case. */
+#if SIZEOF_VOIDP == SIZEOF_LONG
+#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
+#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
+#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
+#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
+#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
+#else
+#  error sizeof(void*) is not the same as long or long long
+#endif
+
+/* Global hash table to store Trackings from C/C++
+   structs to Ruby Objects. 
+*/
+static st_table* swig_ruby_trackings = NULL;
+
+static VALUE swig_ruby_trackings_count(ID id, VALUE *var) {
+  return SWIG2NUM(swig_ruby_trackings->num_entries);
+}
+
+
+/* Setup a hash table to store Trackings */
+SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
+  /* Create a hash table to store Trackings from C++
+     objects to Ruby objects. */
+
+  /* Try to see if some other .so has already created a 
+     tracking hash table, which we keep hidden in an instance var
+     in the SWIG module.
+     This is done to allow multiple DSOs to share the same
+     tracking table.
+  */
+  VALUE trackings_value = Qnil;
+  /* change the variable name so that we can mix modules
+     compiled with older SWIG's - this used to be called "@__trackings__" */
+  ID trackings_id = rb_intern( "@__safetrackings__" );
+  VALUE verbose = rb_gv_get("VERBOSE");
+  rb_gv_set("VERBOSE", Qfalse);
+  trackings_value = rb_ivar_get( _mSWIG, trackings_id );
+  rb_gv_set("VERBOSE", verbose);
+
+  /* The trick here is that we have to store the hash table
+  pointer in a Ruby variable. We do not want Ruby's GC to
+  treat this pointer as a Ruby object, so we convert it to
+  a Ruby numeric value. */
+  if (trackings_value == Qnil) {
+    /* No, it hasn't.  Create one ourselves */
+    swig_ruby_trackings = st_init_numtable();
+    rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
+  } else {
+    swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
+  }
+
+        rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", RUBY_VALUE_METHOD_FUNC(swig_ruby_trackings_count), RUBY_VOID_METHOD_FUNC((rb_gvar_setter_t*)NULL))
+;
+}
+
+/* Add a Tracking from a C/C++ struct to a Ruby object */
+SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
+  /* Store the mapping to the global hash table. */
+  st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
+}
+
+/* Get the Ruby object that owns the specified C/C++ struct */
+SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
+  /* Now lookup the value stored in the global hash table */
+  VALUE value;
+
+  if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
+    return value;
+  } else {
+    return Qnil;
+  }
+}
+
+/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
+   is very important to remove objects once they are destroyed
+   since the same memory address may be reused later to create
+   a new object. */
+SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
+  /* Delete the object from the hash table */
+  st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
+}
+
+/* This is a helper method that unlinks a Ruby object from its
+   underlying C++ object.  This is needed if the lifetime of the
+   Ruby object is longer than the C++ object */
+SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
+  VALUE object = SWIG_RubyInstanceFor(ptr);
+
+  if (object != Qnil) {
+    if (TYPE(object) != T_DATA)
+      abort();
+    DATA_PTR(object) = 0;
+  }
+}
+
+/* This is a helper method that iterates over all the trackings
+   passing the C++ object pointer and its related Ruby object
+   to the passed callback function. */
+
+/* Proxy method to abstract the internal trackings datatype */
+      static int swig_ruby_internal_iterate_callback(st_data_t ptr, st_data_t obj, st_data_t meth) {
+        ((void(*)(void*, VALUE))meth)((void*)ptr, (VALUE)obj);
+
+  return ST_CONTINUE;
+}
+
+SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
+  st_foreach(swig_ruby_trackings, RUBY_INT_METHOD_FUNC(swig_ruby_internal_iterate_callback), (st_data_t)meth);
+}
+
+#ifdef __cplusplus
+}
+#endif
+/* -----------------------------------------------------------------------------
+ * Ruby API portion that goes into the runtime
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGINTERN VALUE
+SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
+  if (NIL_P(target)) {
+    target = o;
+  } else {
+    if (TYPE(target) != T_ARRAY) {
+      VALUE o2 = target;
+      target = rb_ary_new();
+      rb_ary_push(target, o2);
+    }
+    rb_ary_push(target, o);
+  }
+  return target;
+}
+
+/* For ruby1.8.4 and earlier. */
+#ifndef RUBY_INIT_STACK
+   RUBY_EXTERN void Init_stack(VALUE* addr);
+#  define RUBY_INIT_STACK \
+   VALUE variable_in_this_stack_frame; \
+   Init_stack(&variable_in_this_stack_frame);
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * rubyrun.swg
+ *
+ * This file contains the runtime support for Ruby modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
+#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
+#define swig_owntype                                    swig_ruby_owntype
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) 		SWIG_Ruby_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
+#define SWIG_Error(code, msg)            		rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
+#define SWIG_fail                        		goto fail				 
+
+
+/* Ruby-specific SWIG API */
+
+#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
+#define SWIG_define_class(ty)                        	SWIG_Ruby_define_class(ty)
+#define SWIG_NewClassInstance(value, ty)             	SWIG_Ruby_NewClassInstance(value, ty)
+#define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
+#define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  
+
+#include "assert.h"
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  VALUE klass;
+  VALUE mImpl;
+  void  (*mark)(void *);
+  void  (*destroy)(void *);
+  int trackObjects;
+} swig_class;
+
+
+/* Global pointer used to keep some internal SWIG stuff */
+static VALUE _cSWIG_Pointer = Qnil;
+static VALUE swig_runtime_data_type_pointer = Qnil;
+
+/* Global IDs used to keep some internal SWIG stuff */
+static ID swig_arity_id = 0;
+static ID swig_call_id  = 0;
+
+/*
+  If your swig extension is to be run within an embedded ruby and has
+  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
+  This will reset ruby's stack frame on each entry point from the main 
+  program the first time a virtual director function is invoked (in a 
+  non-recursive way).
+  If this is not done, you run the risk of Ruby trashing the stack.
+*/
+
+#ifdef RUBY_EMBEDDED
+
+#  define SWIG_INIT_STACK                            \
+      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
+      ++swig_virtual_calls;
+#  define SWIG_RELEASE_STACK --swig_virtual_calls;
+#  define Ruby_DirectorTypeMismatchException(x) \
+          rb_raise( rb_eTypeError, "%s", x ); return c_result;
+
+      static unsigned int swig_virtual_calls = 0;
+
+#else  /* normal non-embedded extension */
+
+#  define SWIG_INIT_STACK
+#  define SWIG_RELEASE_STACK
+#  define Ruby_DirectorTypeMismatchException(x) \
+          throw Swig::DirectorTypeMismatchException( x );
+
+#endif  /* RUBY_EMBEDDED */
+
+
+SWIGRUNTIME VALUE 
+getExceptionClass(void) {
+  static int init = 0;
+  static VALUE rubyExceptionClass ;
+  if (!init) {
+    init = 1;
+    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
+  }
+  return rubyExceptionClass;
+} 
+
+/* This code checks to see if the Ruby object being raised as part
+   of an exception inherits from the Ruby class Exception.  If so,
+   the object is simply returned.  If not, then a new Ruby exception
+   object is created and that will be returned to Ruby.*/
+SWIGRUNTIME VALUE
+SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
+  VALUE exceptionClass = getExceptionClass();
+  if (rb_obj_is_kind_of(obj, exceptionClass)) {
+    return obj;
+  }  else {
+    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
+  }
+}
+
+/* Initialize Ruby runtime support */
+SWIGRUNTIME void
+SWIG_Ruby_InitRuntime(void)
+{
+  if (_mSWIG == Qnil) {
+    _mSWIG = rb_define_module("SWIG");
+    swig_call_id  = rb_intern("call");
+    swig_arity_id = rb_intern("arity");
+  }
+}
+
+/* Define Ruby class for C type */
+SWIGRUNTIME void
+SWIG_Ruby_define_class(swig_type_info *type)
+{
+  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+  sprintf(klass_name, "TYPE%s", type->name);
+  if (NIL_P(_cSWIG_Pointer)) {
+    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
+    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
+  }
+  rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
+  free((void *) klass_name);
+}
+
+/* Create a new pointer object */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
+{
+  int own =  flags & SWIG_POINTER_OWN; 
+  int track;
+  char *klass_name;
+  swig_class *sklass;
+  VALUE klass;
+  VALUE obj;
+  
+  if (!ptr)
+    return Qnil;
+  
+  if (type->clientdata) {
+    sklass = (swig_class *) type->clientdata;
+		
+    /* Are we tracking this class and have we already returned this Ruby object? */
+    track = sklass->trackObjects;
+    if (track) {
+      obj = SWIG_RubyInstanceFor(ptr);
+      
+      /* Check the object's type and make sure it has the correct type.
+        It might not in cases where methods do things like 
+        downcast methods. */
+      if (obj != Qnil) {
+        VALUE value = rb_iv_get(obj, "@__swigtype__");
+        const char* type_name = RSTRING_PTR(value);
+				
+        if (strcmp(type->name, type_name) == 0) {
+          return obj;
+        }
+      }
+    }
+
+    /* Create a new Ruby object */
+    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
+			   ( own ? VOIDFUNC(sklass->destroy) : 
+			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
+			     ), ptr);
+
+    /* If tracking is on for this class then track this object. */
+    if (track) {
+      SWIG_RubyAddTracking(ptr, obj);
+    }
+  } else {
+    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+    sprintf(klass_name, "TYPE%s", type->name);
+    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
+    free((void *) klass_name);
+    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
+  }
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  
+  return obj;
+}
+
+/* Create a new class instance (always owned) */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
+{
+  VALUE obj;
+  swig_class *sklass = (swig_class *) type->clientdata;
+  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  return obj;
+}
+
+/* Get type mangle from class name */
+SWIGRUNTIMEINLINE char *
+SWIG_Ruby_MangleStr(VALUE obj)
+{
+  VALUE stype = rb_iv_get(obj, "@__swigtype__");
+  return StringValuePtr(stype);
+}
+
+/* Acquire a pointer value */
+typedef struct {
+  void (*datafree)(void *);
+  int own;
+} swig_ruby_owntype;
+
+SWIGRUNTIME swig_ruby_owntype
+SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
+  swig_ruby_owntype oldown = {0, 0};
+  if (obj) {
+    oldown.datafree = RDATA(obj)->dfree;
+    RDATA(obj)->dfree = own.datafree;
+  }
+  return oldown;
+}
+
+/* Convert a pointer value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
+{
+  char *c;
+  swig_cast_info *tc;
+  void *vptr = 0;
+
+  /* Grab the pointer */
+  if (NIL_P(obj)) {
+    if (ptr)
+      *ptr = 0;
+    return SWIG_OK;
+  } else {
+    if (TYPE(obj) != T_DATA) {
+      return SWIG_ERROR;
+    }
+    Data_Get_Struct(obj, void, vptr);
+  }
+  
+  if (own) {
+    own->datafree = RDATA(obj)->dfree;
+    own->own = 0;
+  }
+    
+  /* Check to see if the input object is giving up ownership
+     of the underlying C struct or C++ object.  If so then we
+     need to reset the destructor since the Ruby object no 
+     longer owns the underlying C++ object.*/ 
+  if (flags & SWIG_POINTER_DISOWN) {
+    /* Is tracking on for this class? */
+    int track = 0;
+    if (ty && ty->clientdata) {
+      swig_class *sklass = (swig_class *) ty->clientdata;
+      track = sklass->trackObjects;
+    }
+		
+    if (track) {
+      /* We are tracking objects for this class.  Thus we change the destructor
+       * to SWIG_RubyRemoveTracking.  This allows us to
+       * remove the mapping from the C++ to Ruby object
+       * when the Ruby object is garbage collected.  If we don't
+       * do this, then it is possible we will return a reference 
+       * to a Ruby object that no longer exists thereby crashing Ruby. */
+      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
+    } else {    
+      RDATA(obj)->dfree = 0;
+    }
+  }
+
+  /* Do type-checking if type info was provided */
+  if (ty) {
+    if (ty->clientdata) {
+      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
+        if (vptr == 0) {
+          /* The object has already been deleted */
+          return SWIG_ObjectPreviouslyDeletedError;
+        }
+      }
+    }
+    if ((c = SWIG_MangleStr(obj)) == NULL) {
+      return SWIG_ERROR;
+    }
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) {
+      return SWIG_ERROR;
+    } else {
+      if (ptr) {
+        if (tc->type == ty) {
+          *ptr = vptr;
+        } else {
+          int newmemory = 0;
+          *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
+          if (newmemory == SWIG_CAST_NEW_MEMORY) {
+            assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+            if (own)
+              own->own = own->own | SWIG_CAST_NEW_MEMORY;
+          }
+        }
+      }
+    }
+  } else {
+    if (ptr)
+      *ptr = vptr;
+  }
+  
+  return SWIG_OK;
+}
+
+/* Check convert */
+SWIGRUNTIMEINLINE int
+SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
+{
+  char *c = SWIG_MangleStr(obj);
+  if (!c) return 0;
+  return SWIG_TypeCheck(c,ty) != 0;
+}
+
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r, ptr, sz);
+  strcpy(r, type->name);
+  return rb_str_new2(result);
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c;
+
+  if (TYPE(obj) != T_STRING) goto type_error;
+  c = StringValuePtr(obj);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') goto type_error;
+  c++;
+  c = SWIG_UnpackData(c, ptr, sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) goto type_error;
+  }
+  return SWIG_OK;
+
+ type_error:
+  return SWIG_ERROR;
+}
+
+SWIGRUNTIME swig_module_info *
+SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
+{
+  VALUE pointer;
+  swig_module_info *ret = 0;
+  VALUE verbose = rb_gv_get("VERBOSE");
+
+ /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
+  rb_gv_set("VERBOSE", Qfalse);
+  
+  /* first check if pointer already created */
+  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  if (pointer != Qnil) {
+    Data_Get_Struct(pointer, swig_module_info, ret);
+  }
+
+  /* reinstate warnings */
+  rb_gv_set("VERBOSE", verbose);
+  return ret;
+}
+
+SWIGRUNTIME void 
+SWIG_Ruby_SetModule(swig_module_info *pointer)
+{
+  /* register a new class */
+  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
+  /* create and store the structure pointer to a global variable */
+  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
+  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
+}
+
+/* This function can be used to check whether a proc or method or similarly
+   callable function has been passed.  Usually used in a %typecheck, like:
+
+   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
+        $result = SWIG_Ruby_isCallable( $input );
+   }
+ */
+SWIGINTERN
+int SWIG_Ruby_isCallable( VALUE proc )
+{
+  if ( rb_respond_to( proc, swig_call_id ) )
+    return 1;
+  return 0;
+}
+
+/* This function can be used to check the arity (number of arguments)
+   a proc or method can take.  Usually used in a %typecheck.
+   Valid arities will be that equal to minimal or those < 0
+   which indicate a variable number of parameters at the end.
+ */
+SWIGINTERN
+int SWIG_Ruby_arity( VALUE proc, int minimal )
+{
+  if ( rb_respond_to( proc, swig_arity_id ) )
+    {
+      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
+      int arity = NUM2INT(num);
+      if ( arity < 0 && (arity+1) < -minimal ) return 1;
+      if ( arity == minimal ) return 1;
+      return 1;
+    }
+  return 0;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+/* -----------------------------------------------------------------------------*
+   Standard SWIG API for use inside user code.
+ 
+   Don't include this file directly, run the command
+   swig -python -external-runtime
+   Also, read the Modules chapter of the SWIG Manual.
+ 
+ * -----------------------------------------------------------------------------*/
+
+#ifdef SWIG_MODULE_CLIENTDATA_TYPE
+
+SWIGRUNTIMEINLINE swig_type_info *
+SWIG_TypeQuery(SWIG_MODULE_CLIENTDATA_TYPE clientdata, const char *name) {
+  swig_module_info *module = SWIG_GetModule(clientdata);
+  return SWIG_TypeQueryModule(module, module, name);
+}
+
+SWIGRUNTIMEINLINE swig_type_info *
+SWIG_MangledTypeQuery(SWIG_MODULE_CLIENTDATA_TYPE clientdata, const char *name) {
+  swig_module_info *module = SWIG_GetModule(clientdata);
+  return SWIG_MangledTypeQueryModule(module, module, name);
+}
+
+#else
+
+SWIGRUNTIMEINLINE swig_type_info *
+SWIG_TypeQuery(const char *name) {
+  swig_module_info *module = SWIG_GetModule(NULL);
+  return SWIG_TypeQueryModule(module, module, name);
+}
+
+SWIGRUNTIMEINLINE swig_type_info *
+SWIG_MangledTypeQuery(const char *name) {
+  swig_module_info *module = SWIG_GetModule(NULL);
+  return SWIG_MangledTypeQueryModule(module, module, name);
+}
+
+#endif
diff --git a/ext/fox16_c/table_wrap.cpp b/ext/fox16_c/table_wrap.cpp
new file mode 100644
index 00000000..a64f8e9f
--- /dev/null
+++ b/ext/fox16_c/table_wrap.cpp
@@ -0,0 +1,14773 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 3.0.12
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+
+#ifndef SWIGRUBY
+#define SWIGRUBY
+#endif
+
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
+};
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic C API SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "4"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/*  Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN           0x1
+
+
+/*
+   Flags/methods for returning states.
+
+   The SWIG conversion methods, as ConvertPtr, return an integer
+   that tells if the conversion was successful or not. And if not,
+   an error code can be returned (see swigerrors.swg for the codes).
+
+   Use the following macros/flags to set or process the returning
+   states.
+
+   In old versions of SWIG, code such as the following was usually written:
+
+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+       // success code
+     } else {
+       //fail code
+     }
+
+   Now you can be more explicit:
+
+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+    } else {
+      // fail code
+    }
+
+   which is the same really, but now you can also do
+
+    Type *ptr;
+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+      if (SWIG_IsNewObj(res) {
+        ...
+	delete *ptr;
+      } else {
+        ...
+      }
+    } else {
+      // fail code
+    }
+
+   I.e., now SWIG_ConvertPtr can return new objects and you can
+   identify the case and take care of the deallocation. Of course that
+   also requires SWIG_ConvertPtr to return new result values, such as
+
+      int SWIG_ConvertPtr(obj, ptr,...) {
+        if (<obj is ok>) {
+          if (<need new object>) {
+            *ptr = <ptr to new allocated object>;
+            return SWIG_NEWOBJ;
+          } else {
+            *ptr = <ptr to old object>;
+            return SWIG_OLDOBJ;
+          }
+        } else {
+          return SWIG_BADOBJ;
+        }
+      }
+
+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+   SWIG errors code.
+
+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+   allows to return the 'cast rank', for example, if you have this
+
+       int food(double)
+       int fooi(int);
+
+   and you call
+
+      food(1)   // cast rank '1'  (1 -> 1.0)
+      fooi(1)   // cast rank '0'
+
+   just use the SWIG_AddCast()/SWIG_CheckState()
+*/
+
+#define SWIG_OK                    (0)
+#define SWIG_ERROR                 (-1)
+#define SWIG_IsOK(r)               (r >= 0)
+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT         (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ                (SWIG_ERROR)
+#define SWIG_OLDOBJ                (SWIG_OK)
+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+#  ifndef SWIG_TypeRank
+#    define SWIG_TypeRank             unsigned long
+#  endif
+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
+#    define SWIG_MAXCASTRANK          (2)
+#  endif
+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+#  define SWIG_AddCast(r) (r)
+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *, int *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store information on one type */
+typedef struct swig_type_info {
+  const char             *name;			/* mangled name of this type */
+  const char             *str;			/* human readable name of this type */
+  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
+  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
+  void                   *clientdata;		/* language specific type data */
+  int                    owndata;		/* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
+  swig_converter_func     converter;		/* function to cast the void pointers */
+  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
+  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
+  size_t                 size;		        /* Number of types in this module */
+  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
+  swig_type_info         **type_initial;	/* Array of initially generated type structures */
+  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
+  void                    *clientdata;		/* Language specific module data */
+} swig_module_info;
+
+/*
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+  }
+  return (int)((l1 - f1) - (l2 - f2));
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCmp(const char *nb, const char *tb) {
+  int equiv = 1;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (equiv != 0 && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
+}
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
+}
+
+/*
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+  swig_type_info *lastty = ty;
+  if (!ty || !ty->dcast) return ty;
+  while (ty && (ty->dcast)) {
+    ty = (*ty->dcast)(ptr);
+    if (ty) lastty = ty;
+  }
+  return lastty;
+}
+
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+  return ty->name;
+}
+
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (!type) return NULL;
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
+  }
+  else
+    return type->name;
+}
+
+/*
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+  swig_cast_info *cast = ti->cast;
+  /* if (ti->clientdata == clientdata) return; */
+  ti->clientdata = clientdata;
+
+  while (cast) {
+    if (!cast->converter) {
+      swig_type_info *tc = cast->type;
+      if (!tc->clientdata) {
+	SWIG_TypeClientData(tc, clientdata);
+      }
+    }
+    cast = cast->next;
+  }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientData(ti, clientdata);
+  ti->owndata = 1;
+}
+
+/*
+  Search for a swig_type_info structure only by mangled name
+  Search is a O(log #types)
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+                            swig_module_info *end,
+		            const char *name) {
+  swig_module_info *iter = start;
+  do {
+    if (iter->size) {
+      size_t l = 0;
+      size_t r = iter->size - 1;
+      do {
+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
+	size_t i = (l + r) >> 1;
+	const char *iname = iter->types[i]->name;
+	if (iname) {
+	  int compare = strcmp(name, iname);
+	  if (compare == 0) {
+	    return iter->types[i];
+	  } else if (compare < 0) {
+	    if (i) {
+	      r = i - 1;
+	    } else {
+	      break;
+	    }
+	  } else if (compare > 0) {
+	    l = i + 1;
+	  }
+	} else {
+	  break; /* should never happen */
+	}
+      } while (l <= r);
+    }
+    iter = iter->next;
+  } while (iter != end);
+  return 0;
+}
+
+/*
+  Search for a swig_type_info structure for either a mangled name or a human readable name.
+  It first searches the mangled names of the types, which is a O(log #types)
+  If a type is not found it then searches the human readable names, which is O(#types).
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+                     swig_module_info *end,
+		     const char *name) {
+  /* STEP 1: Search the name field using binary search */
+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+  if (ret) {
+    return ret;
+  } else {
+    /* STEP 2: If the type hasn't been found, do a complete search
+       of the str field (the human readable name) */
+    swig_module_info *iter = start;
+    do {
+      size_t i = 0;
+      for (; i < iter->size; ++i) {
+	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+	  return iter->types[i];
+      }
+      iter = iter->next;
+    } while (iter != end);
+  }
+
+  /* neither found a match */
+  return 0;
+}
+
+/*
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+
+/*
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = (unsigned char)((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = (unsigned char)((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (unsigned char)(d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (unsigned char)(d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/*
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/*  Errors in SWIG */
+#define  SWIG_UnknownError    	   -1
+#define  SWIG_IOError        	   -2
+#define  SWIG_RuntimeError   	   -3
+#define  SWIG_IndexError     	   -4
+#define  SWIG_TypeError      	   -5
+#define  SWIG_DivisionByZero 	   -6
+#define  SWIG_OverflowError  	   -7
+#define  SWIG_SyntaxError    	   -8
+#define  SWIG_ValueError     	   -9
+#define  SWIG_SystemError    	   -10
+#define  SWIG_AttributeError 	   -11
+#define  SWIG_MemoryError    	   -12
+#define  SWIG_NullReferenceError   -13
+
+
+
+      #include <ruby.h>
+
+      #if defined(RB_METHOD_DEFINITION_DECL)
+      # define RUBY_VALUE_METHOD_FUNC(func) (func)
+      # define RUBY_INT_METHOD_FUNC(func) (func)
+      # define RUBY_VOID_METHOD_FUNC(func) (func)
+      # define RUBY_VOIDP_METHOD_FUNC(func) (func)
+      #else
+      # define RUBY_VALUE_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
+      # define RUBY_INT_METHOD_FUNC(func) ((int (*)(ANYARGS))(func))
+      # define RUBY_VOID_METHOD_FUNC(func) ((void (*)(ANYARGS))(func))
+      # define RUBY_VOIDP_METHOD_FUNC(func) ((void *(*)(ANYARGS))(func))
+      #endif
+
+
+/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
+ * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
+ * issue for now by disabling this.
+ * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
+ */
+#ifdef rb_intern
+# undef rb_intern
+#endif
+
+/* Remove global macros defined in Ruby's win32.h */
+#ifdef write
+# undef write
+#endif
+#ifdef read
+# undef read
+#endif
+#ifdef bind
+# undef bind
+#endif
+#ifdef close
+# undef close
+#endif
+#ifdef connect
+# undef connect
+#endif
+
+
+/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
+#ifndef NUM2LL
+#define NUM2LL(x) NUM2LONG((x))
+#endif
+#ifndef LL2NUM
+#define LL2NUM(x) INT2NUM((long) (x))
+#endif
+#ifndef ULL2NUM
+#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
+#endif
+
+/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
+#ifndef NUM2ULL
+#ifdef HAVE_LONG_LONG
+#define NUM2ULL(x) rb_num2ull((x))
+#else
+#define NUM2ULL(x) NUM2ULONG(x)
+#endif
+#endif
+
+/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
+/* Define these for older versions so we can just write code the new way */
+#ifndef RSTRING_LEN
+# define RSTRING_LEN(x) RSTRING(x)->len
+#endif
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(x) RSTRING(x)->ptr
+#endif
+#ifndef RSTRING_END
+# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
+#endif
+#ifndef RARRAY_LEN
+# define RARRAY_LEN(x) RARRAY(x)->len
+#endif
+#ifndef RARRAY_PTR
+# define RARRAY_PTR(x) RARRAY(x)->ptr
+#endif
+#ifndef RFLOAT_VALUE
+# define RFLOAT_VALUE(x) RFLOAT(x)->value
+#endif
+#ifndef DOUBLE2NUM
+# define DOUBLE2NUM(x) rb_float_new(x)
+#endif
+#ifndef RHASH_TBL
+# define RHASH_TBL(x) (RHASH(x)->tbl)
+#endif
+#ifndef RHASH_ITER_LEV
+# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
+#endif
+#ifndef RHASH_IFNONE
+# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
+#endif
+#ifndef RHASH_SIZE
+# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
+#endif
+#ifndef RHASH_EMPTY_P
+# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
+#endif
+#ifndef RSTRUCT_LEN
+# define RSTRUCT_LEN(x) RSTRUCT(x)->len
+#endif
+#ifndef RSTRUCT_PTR
+# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
+#endif
+
+
+
+/*
+ * Need to be very careful about how these macros are defined, especially
+ * when compiling C++ code or C code with an ANSI C compiler.
+ *
+ * VALUEFUNC(f) is a macro used to typecast a C function that implements
+ * a Ruby method so that it can be passed as an argument to API functions
+ * like rb_define_method() and rb_define_singleton_method().
+ *
+ * VOIDFUNC(f) is a macro used to typecast a C function that implements
+ * either the "mark" or "free" stuff for a Ruby Data object, so that it
+ * can be passed as an argument to API functions like Data_Wrap_Struct()
+ * and Data_Make_Struct().
+ */
+ 
+#ifdef __cplusplus
+#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
+#    define PROTECTFUNC(f) ((VALUE (*)()) f)
+#    define VALUEFUNC(f) ((VALUE (*)()) f)
+#    define VOIDFUNC(f)  ((void (*)()) f)
+#  else
+#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
+#      define PROTECTFUNC(f) ((VALUE (*)()) f)
+#      define VALUEFUNC(f) ((VALUE (*)()) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    else /* These definitions should work for Ruby 1.7+ */
+#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
+#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    endif
+#  endif
+#else
+#  define VALUEFUNC(f) (f)
+#  define VOIDFUNC(f) (f)
+#endif
+
+/* Don't use for expressions have side effect */
+#ifndef RB_STRING_VALUE
+#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
+#endif
+#ifndef StringValue
+#define StringValue(s) RB_STRING_VALUE(s)
+#endif
+#ifndef StringValuePtr
+#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
+#endif
+#ifndef StringValueLen
+#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
+#endif
+#ifndef SafeStringValue
+#define SafeStringValue(v) do {\
+    StringValue(v);\
+    rb_check_safe_str(v);\
+} while (0)
+#endif
+
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
+#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
+#endif
+
+static VALUE _mSWIG = Qnil;
+
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+
+/* Define some additional error types */
+#define SWIG_ObjectPreviouslyDeletedError  -100
+
+
+/* Define custom exceptions for errors that do not map to existing Ruby
+   exceptions.  Note this only works for C++ since a global cannot be
+   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/
+
+SWIGINTERN VALUE 
+getNullReferenceError(void) {
+  static int init = 0;
+  static VALUE rb_eNullReferenceError ;
+  if (!init) {
+    init = 1;
+    rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
+  }
+  return rb_eNullReferenceError;
+} 
+
+SWIGINTERN VALUE 
+getObjectPreviouslyDeletedError(void) {
+  static int init = 0;
+  static VALUE rb_eObjectPreviouslyDeleted ;
+  if (!init) {
+    init = 1;
+    rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
+  }
+  return rb_eObjectPreviouslyDeleted;
+} 
+
+
+SWIGINTERN VALUE
+SWIG_Ruby_ErrorType(int SWIG_code) {
+  VALUE type;
+  switch (SWIG_code) {
+  case SWIG_MemoryError:
+    type = rb_eNoMemError;
+    break;
+  case SWIG_IOError:
+    type = rb_eIOError;
+    break;
+  case SWIG_RuntimeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_IndexError:
+    type = rb_eIndexError;
+    break;
+  case SWIG_TypeError:
+    type = rb_eTypeError;
+    break;
+  case SWIG_DivisionByZero:
+    type = rb_eZeroDivError;
+    break;
+  case SWIG_OverflowError:
+    type = rb_eRangeError;
+    break;
+  case SWIG_SyntaxError:
+    type = rb_eSyntaxError;
+    break;
+  case SWIG_ValueError:
+    type = rb_eArgError;
+    break;
+  case SWIG_SystemError:
+    type = rb_eFatal;
+    break;
+  case SWIG_AttributeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_NullReferenceError:
+    type = getNullReferenceError();
+    break;
+  case SWIG_ObjectPreviouslyDeletedError:
+    type = getObjectPreviouslyDeletedError();
+    break;
+  case SWIG_UnknownError:
+    type = rb_eRuntimeError;
+    break;
+  default:
+    type = rb_eRuntimeError;
+  }
+  return type;
+}
+
+
+/* This function is called when a user inputs a wrong argument to
+   a method.
+ */
+SWIGINTERN 
+const char* Ruby_Format_TypeError( const char* msg,
+				   const char* type, 
+				   const char* name, 
+				   const int argn,
+				   VALUE input )
+{
+  char buf[128];
+  VALUE str;
+  VALUE asStr;
+  if ( msg && *msg )
+    {
+      str = rb_str_new2(msg);
+    }
+  else
+    {
+      str = rb_str_new(NULL, 0);
+    }
+
+  str = rb_str_cat2( str, "Expected argument " );
+  sprintf( buf, "%d of type ", argn-1 );
+  str = rb_str_cat2( str, buf );
+  str = rb_str_cat2( str, type );
+  str = rb_str_cat2( str, ", but got " );
+  str = rb_str_cat2( str, rb_obj_classname(input) );
+  str = rb_str_cat2( str, " " );
+  asStr = rb_inspect(input);
+  if ( RSTRING_LEN(asStr) > 30 )
+    {
+      str = rb_str_cat( str, StringValuePtr(asStr), 30 );
+      str = rb_str_cat2( str, "..." );
+    }
+  else
+    {
+      str = rb_str_append( str, asStr );
+    }
+
+  if ( name )
+    {
+      str = rb_str_cat2( str, "\n\tin SWIG method '" );
+      str = rb_str_cat2( str, name );
+      str = rb_str_cat2( str, "'" );
+    }
+
+  return StringValuePtr( str );
+}
+
+/* This function is called when an overloaded method fails */
+SWIGINTERN 
+void Ruby_Format_OverloadedError(
+				 const int argc,
+				 const int maxargs,
+				 const char* method, 
+				 const char* prototypes 
+				 )
+{
+  const char* msg = "Wrong # of arguments";
+  if ( argc <= maxargs ) msg = "Wrong arguments";
+  rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
+	   "Possible C/C++ prototypes are:\n%s",
+	   msg, method, prototypes);
+}
+
+/* -----------------------------------------------------------------------------
+ * rubytracking.swg
+ *
+ * This file contains support for tracking mappings from 
+ * Ruby objects to C++ objects.  This functionality is needed
+ * to implement mark functions for Ruby's mark and sweep
+ * garbage collector.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(ST_DATA_T_DEFINED)
+/* Needs to be explicitly included for Ruby 1.8 and earlier */
+#include <st.h>
+#endif
+
+/* Ruby 1.8 actually assumes the first case. */
+#if SIZEOF_VOIDP == SIZEOF_LONG
+#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
+#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
+#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
+#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
+#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
+#else
+#  error sizeof(void*) is not the same as long or long long
+#endif
+
+/* Global hash table to store Trackings from C/C++
+   structs to Ruby Objects. 
+*/
+static st_table* swig_ruby_trackings = NULL;
+
+static VALUE swig_ruby_trackings_count(ID id, VALUE *var) {
+  return SWIG2NUM(swig_ruby_trackings->num_entries);
+}
+
+
+/* Setup a hash table to store Trackings */
+SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
+  /* Create a hash table to store Trackings from C++
+     objects to Ruby objects. */
+
+  /* Try to see if some other .so has already created a 
+     tracking hash table, which we keep hidden in an instance var
+     in the SWIG module.
+     This is done to allow multiple DSOs to share the same
+     tracking table.
+  */
+  VALUE trackings_value = Qnil;
+  /* change the variable name so that we can mix modules
+     compiled with older SWIG's - this used to be called "@__trackings__" */
+  ID trackings_id = rb_intern( "@__safetrackings__" );
+  VALUE verbose = rb_gv_get("VERBOSE");
+  rb_gv_set("VERBOSE", Qfalse);
+  trackings_value = rb_ivar_get( _mSWIG, trackings_id );
+  rb_gv_set("VERBOSE", verbose);
+
+  /* The trick here is that we have to store the hash table
+  pointer in a Ruby variable. We do not want Ruby's GC to
+  treat this pointer as a Ruby object, so we convert it to
+  a Ruby numeric value. */
+  if (trackings_value == Qnil) {
+    /* No, it hasn't.  Create one ourselves */
+    swig_ruby_trackings = st_init_numtable();
+    rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
+  } else {
+    swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
+  }
+
+        rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", RUBY_VALUE_METHOD_FUNC(swig_ruby_trackings_count), RUBY_VOID_METHOD_FUNC((rb_gvar_setter_t*)NULL))
+;
+}
+
+/* Add a Tracking from a C/C++ struct to a Ruby object */
+SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
+  /* Store the mapping to the global hash table. */
+  st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
+}
+
+/* Get the Ruby object that owns the specified C/C++ struct */
+SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
+  /* Now lookup the value stored in the global hash table */
+  VALUE value;
+
+  if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
+    return value;
+  } else {
+    return Qnil;
+  }
+}
+
+/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
+   is very important to remove objects once they are destroyed
+   since the same memory address may be reused later to create
+   a new object. */
+SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
+  /* Delete the object from the hash table */
+  st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
+}
+
+/* This is a helper method that unlinks a Ruby object from its
+   underlying C++ object.  This is needed if the lifetime of the
+   Ruby object is longer than the C++ object */
+SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
+  VALUE object = SWIG_RubyInstanceFor(ptr);
+
+  if (object != Qnil) {
+    if (TYPE(object) != T_DATA)
+      abort();
+    DATA_PTR(object) = 0;
+  }
+}
+
+/* This is a helper method that iterates over all the trackings
+   passing the C++ object pointer and its related Ruby object
+   to the passed callback function. */
+
+/* Proxy method to abstract the internal trackings datatype */
+      static int swig_ruby_internal_iterate_callback(st_data_t ptr, st_data_t obj, st_data_t meth) {
+        ((void(*)(void*, VALUE))meth)((void*)ptr, (VALUE)obj);
+
+  return ST_CONTINUE;
+}
+
+SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
+  st_foreach(swig_ruby_trackings, RUBY_INT_METHOD_FUNC(swig_ruby_internal_iterate_callback), (st_data_t)meth);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Ruby API portion that goes into the runtime
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGINTERN VALUE
+SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
+  if (NIL_P(target)) {
+    target = o;
+  } else {
+    if (TYPE(target) != T_ARRAY) {
+      VALUE o2 = target;
+      target = rb_ary_new();
+      rb_ary_push(target, o2);
+    }
+    rb_ary_push(target, o);
+  }
+  return target;
+}
+
+/* For ruby1.8.4 and earlier. */
+#ifndef RUBY_INIT_STACK
+   RUBY_EXTERN void Init_stack(VALUE* addr);
+#  define RUBY_INIT_STACK \
+   VALUE variable_in_this_stack_frame; \
+   Init_stack(&variable_in_this_stack_frame);
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* -----------------------------------------------------------------------------
+ * rubyrun.swg
+ *
+ * This file contains the runtime support for Ruby modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
+#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
+#define swig_owntype                                    swig_ruby_owntype
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) 		SWIG_Ruby_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
+#define SWIG_Error(code, msg)            		rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
+#define SWIG_fail                        		goto fail				 
+
+
+/* Ruby-specific SWIG API */
+
+#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
+#define SWIG_define_class(ty)                        	SWIG_Ruby_define_class(ty)
+#define SWIG_NewClassInstance(value, ty)             	SWIG_Ruby_NewClassInstance(value, ty)
+#define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
+#define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  
+
+#include "assert.h"
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  VALUE klass;
+  VALUE mImpl;
+  void  (*mark)(void *);
+  void  (*destroy)(void *);
+  int trackObjects;
+} swig_class;
+
+
+/* Global pointer used to keep some internal SWIG stuff */
+static VALUE _cSWIG_Pointer = Qnil;
+static VALUE swig_runtime_data_type_pointer = Qnil;
+
+/* Global IDs used to keep some internal SWIG stuff */
+static ID swig_arity_id = 0;
+static ID swig_call_id  = 0;
+
+/*
+  If your swig extension is to be run within an embedded ruby and has
+  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
+  This will reset ruby's stack frame on each entry point from the main 
+  program the first time a virtual director function is invoked (in a 
+  non-recursive way).
+  If this is not done, you run the risk of Ruby trashing the stack.
+*/
+
+#ifdef RUBY_EMBEDDED
+
+#  define SWIG_INIT_STACK                            \
+      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
+      ++swig_virtual_calls;
+#  define SWIG_RELEASE_STACK --swig_virtual_calls;
+#  define Ruby_DirectorTypeMismatchException(x) \
+          rb_raise( rb_eTypeError, "%s", x ); return c_result;
+
+      static unsigned int swig_virtual_calls = 0;
+
+#else  /* normal non-embedded extension */
+
+#  define SWIG_INIT_STACK
+#  define SWIG_RELEASE_STACK
+#  define Ruby_DirectorTypeMismatchException(x) \
+          throw Swig::DirectorTypeMismatchException( x );
+
+#endif  /* RUBY_EMBEDDED */
+
+
+SWIGRUNTIME VALUE 
+getExceptionClass(void) {
+  static int init = 0;
+  static VALUE rubyExceptionClass ;
+  if (!init) {
+    init = 1;
+    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
+  }
+  return rubyExceptionClass;
+} 
+
+/* This code checks to see if the Ruby object being raised as part
+   of an exception inherits from the Ruby class Exception.  If so,
+   the object is simply returned.  If not, then a new Ruby exception
+   object is created and that will be returned to Ruby.*/
+SWIGRUNTIME VALUE
+SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
+  VALUE exceptionClass = getExceptionClass();
+  if (rb_obj_is_kind_of(obj, exceptionClass)) {
+    return obj;
+  }  else {
+    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
+  }
+}
+
+/* Initialize Ruby runtime support */
+SWIGRUNTIME void
+SWIG_Ruby_InitRuntime(void)
+{
+  if (_mSWIG == Qnil) {
+    _mSWIG = rb_define_module("SWIG");
+    swig_call_id  = rb_intern("call");
+    swig_arity_id = rb_intern("arity");
+  }
+}
+
+/* Define Ruby class for C type */
+SWIGRUNTIME void
+SWIG_Ruby_define_class(swig_type_info *type)
+{
+  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+  sprintf(klass_name, "TYPE%s", type->name);
+  if (NIL_P(_cSWIG_Pointer)) {
+    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
+    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
+  }
+  rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
+  free((void *) klass_name);
+}
+
+/* Create a new pointer object */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
+{
+  int own =  flags & SWIG_POINTER_OWN; 
+  int track;
+  char *klass_name;
+  swig_class *sklass;
+  VALUE klass;
+  VALUE obj;
+  
+  if (!ptr)
+    return Qnil;
+  
+  if (type->clientdata) {
+    sklass = (swig_class *) type->clientdata;
+		
+    /* Are we tracking this class and have we already returned this Ruby object? */
+    track = sklass->trackObjects;
+    if (track) {
+      obj = SWIG_RubyInstanceFor(ptr);
+      
+      /* Check the object's type and make sure it has the correct type.
+        It might not in cases where methods do things like 
+        downcast methods. */
+      if (obj != Qnil) {
+        VALUE value = rb_iv_get(obj, "@__swigtype__");
+        const char* type_name = RSTRING_PTR(value);
+				
+        if (strcmp(type->name, type_name) == 0) {
+          return obj;
+        }
+      }
+    }
+
+    /* Create a new Ruby object */
+    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
+			   ( own ? VOIDFUNC(sklass->destroy) : 
+			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
+			     ), ptr);
+
+    /* If tracking is on for this class then track this object. */
+    if (track) {
+      SWIG_RubyAddTracking(ptr, obj);
+    }
+  } else {
+    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+    sprintf(klass_name, "TYPE%s", type->name);
+    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
+    free((void *) klass_name);
+    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
+  }
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  
+  return obj;
+}
+
+/* Create a new class instance (always owned) */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
+{
+  VALUE obj;
+  swig_class *sklass = (swig_class *) type->clientdata;
+  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  return obj;
+}
+
+/* Get type mangle from class name */
+SWIGRUNTIMEINLINE char *
+SWIG_Ruby_MangleStr(VALUE obj)
+{
+  VALUE stype = rb_iv_get(obj, "@__swigtype__");
+  return StringValuePtr(stype);
+}
+
+/* Acquire a pointer value */
+typedef struct {
+  void (*datafree)(void *);
+  int own;
+} swig_ruby_owntype;
+
+SWIGRUNTIME swig_ruby_owntype
+SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
+  swig_ruby_owntype oldown = {0, 0};
+  if (obj) {
+    oldown.datafree = RDATA(obj)->dfree;
+    RDATA(obj)->dfree = own.datafree;
+  }
+  return oldown;
+}
+
+/* Convert a pointer value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
+{
+  char *c;
+  swig_cast_info *tc;
+  void *vptr = 0;
+
+  /* Grab the pointer */
+  if (NIL_P(obj)) {
+    if (ptr)
+      *ptr = 0;
+    return SWIG_OK;
+  } else {
+    if (TYPE(obj) != T_DATA) {
+      return SWIG_ERROR;
+    }
+    Data_Get_Struct(obj, void, vptr);
+  }
+  
+  if (own) {
+    own->datafree = RDATA(obj)->dfree;
+    own->own = 0;
+  }
+    
+  /* Check to see if the input object is giving up ownership
+     of the underlying C struct or C++ object.  If so then we
+     need to reset the destructor since the Ruby object no 
+     longer owns the underlying C++ object.*/ 
+  if (flags & SWIG_POINTER_DISOWN) {
+    /* Is tracking on for this class? */
+    int track = 0;
+    if (ty && ty->clientdata) {
+      swig_class *sklass = (swig_class *) ty->clientdata;
+      track = sklass->trackObjects;
+    }
+		
+    if (track) {
+      /* We are tracking objects for this class.  Thus we change the destructor
+       * to SWIG_RubyRemoveTracking.  This allows us to
+       * remove the mapping from the C++ to Ruby object
+       * when the Ruby object is garbage collected.  If we don't
+       * do this, then it is possible we will return a reference 
+       * to a Ruby object that no longer exists thereby crashing Ruby. */
+      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
+    } else {    
+      RDATA(obj)->dfree = 0;
+    }
+  }
+
+  /* Do type-checking if type info was provided */
+  if (ty) {
+    if (ty->clientdata) {
+      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
+        if (vptr == 0) {
+          /* The object has already been deleted */
+          return SWIG_ObjectPreviouslyDeletedError;
+        }
+      }
+    }
+    if ((c = SWIG_MangleStr(obj)) == NULL) {
+      return SWIG_ERROR;
+    }
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) {
+      return SWIG_ERROR;
+    } else {
+      if (ptr) {
+        if (tc->type == ty) {
+          *ptr = vptr;
+        } else {
+          int newmemory = 0;
+          *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
+          if (newmemory == SWIG_CAST_NEW_MEMORY) {
+            assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+            if (own)
+              own->own = own->own | SWIG_CAST_NEW_MEMORY;
+          }
+        }
+      }
+    }
+  } else {
+    if (ptr)
+      *ptr = vptr;
+  }
+  
+  return SWIG_OK;
+}
+
+/* Check convert */
+SWIGRUNTIMEINLINE int
+SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
+{
+  char *c = SWIG_MangleStr(obj);
+  if (!c) return 0;
+  return SWIG_TypeCheck(c,ty) != 0;
+}
+
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r, ptr, sz);
+  strcpy(r, type->name);
+  return rb_str_new2(result);
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c;
+
+  if (TYPE(obj) != T_STRING) goto type_error;
+  c = StringValuePtr(obj);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') goto type_error;
+  c++;
+  c = SWIG_UnpackData(c, ptr, sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) goto type_error;
+  }
+  return SWIG_OK;
+
+ type_error:
+  return SWIG_ERROR;
+}
+
+SWIGRUNTIME swig_module_info *
+SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
+{
+  VALUE pointer;
+  swig_module_info *ret = 0;
+  VALUE verbose = rb_gv_get("VERBOSE");
+
+ /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
+  rb_gv_set("VERBOSE", Qfalse);
+  
+  /* first check if pointer already created */
+  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  if (pointer != Qnil) {
+    Data_Get_Struct(pointer, swig_module_info, ret);
+  }
+
+  /* reinstate warnings */
+  rb_gv_set("VERBOSE", verbose);
+  return ret;
+}
+
+SWIGRUNTIME void 
+SWIG_Ruby_SetModule(swig_module_info *pointer)
+{
+  /* register a new class */
+  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
+  /* create and store the structure pointer to a global variable */
+  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
+  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
+}
+
+/* This function can be used to check whether a proc or method or similarly
+   callable function has been passed.  Usually used in a %typecheck, like:
+
+   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
+        $result = SWIG_Ruby_isCallable( $input );
+   }
+ */
+SWIGINTERN
+int SWIG_Ruby_isCallable( VALUE proc )
+{
+  if ( rb_respond_to( proc, swig_call_id ) )
+    return 1;
+  return 0;
+}
+
+/* This function can be used to check the arity (number of arguments)
+   a proc or method can take.  Usually used in a %typecheck.
+   Valid arities will be that equal to minimal or those < 0
+   which indicate a variable number of parameters at the end.
+ */
+SWIGINTERN
+int SWIG_Ruby_arity( VALUE proc, int minimal )
+{
+  if ( rb_respond_to( proc, swig_arity_id ) )
+    {
+      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
+      int arity = NUM2INT(num);
+      if ( arity < 0 && (arity+1) < -minimal ) return 1;
+      if ( arity == minimal ) return 1;
+      return 1;
+    }
+  return 0;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
+
+
+
+  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) 
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_p_FX4Splitter swig_types[0]
+#define SWIGTYPE_p_FX7Segment swig_types[1]
+#define SWIGTYPE_p_FXAccelTable swig_types[2]
+#define SWIGTYPE_p_FXApp swig_types[3]
+#define SWIGTYPE_p_FXArrowButton swig_types[4]
+#define SWIGTYPE_p_FXBitmap swig_types[5]
+#define SWIGTYPE_p_FXBitmapFrame swig_types[6]
+#define SWIGTYPE_p_FXButton swig_types[7]
+#define SWIGTYPE_p_FXCURCursor swig_types[8]
+#define SWIGTYPE_p_FXCanvas swig_types[9]
+#define SWIGTYPE_p_FXColorBar swig_types[10]
+#define SWIGTYPE_p_FXColorRing swig_types[11]
+#define SWIGTYPE_p_FXColorSelector swig_types[12]
+#define SWIGTYPE_p_FXColorWell swig_types[13]
+#define SWIGTYPE_p_FXColorWheel swig_types[14]
+#define SWIGTYPE_p_FXComboBox swig_types[15]
+#define SWIGTYPE_p_FXComposite swig_types[16]
+#define SWIGTYPE_p_FXCursor swig_types[17]
+#define SWIGTYPE_p_FXDC swig_types[18]
+#define SWIGTYPE_p_FXDCPrint swig_types[19]
+#define SWIGTYPE_p_FXDCWindow swig_types[20]
+#define SWIGTYPE_p_FXDataTarget swig_types[21]
+#define SWIGTYPE_p_FXDebugTarget swig_types[22]
+#define SWIGTYPE_p_FXDelegator swig_types[23]
+#define SWIGTYPE_p_FXDial swig_types[24]
+#define SWIGTYPE_p_FXDict swig_types[25]
+#define SWIGTYPE_p_FXDirBox swig_types[26]
+#define SWIGTYPE_p_FXDirSelector swig_types[27]
+#define SWIGTYPE_p_FXDockBar swig_types[28]
+#define SWIGTYPE_p_FXDockHandler swig_types[29]
+#define SWIGTYPE_p_FXDockSite swig_types[30]
+#define SWIGTYPE_p_FXDockTitle swig_types[31]
+#define SWIGTYPE_p_FXDocument swig_types[32]
+#define SWIGTYPE_p_FXDragCorner swig_types[33]
+#define SWIGTYPE_p_FXDrawable swig_types[34]
+#define SWIGTYPE_p_FXDriveBox swig_types[35]
+#define SWIGTYPE_p_FXFileDict swig_types[36]
+#define SWIGTYPE_p_FXFileSelector swig_types[37]
+#define SWIGTYPE_p_FXFileStream swig_types[38]
+#define SWIGTYPE_p_FXFont swig_types[39]
+#define SWIGTYPE_p_FXFontSelector swig_types[40]
+#define SWIGTYPE_p_FXFrame swig_types[41]
+#define SWIGTYPE_p_FXGIFCursor swig_types[42]
+#define SWIGTYPE_p_FXGradientBar swig_types[43]
+#define SWIGTYPE_p_FXGroupBox swig_types[44]
+#define SWIGTYPE_p_FXHeader swig_types[45]
+#define SWIGTYPE_p_FXHeaderItem swig_types[46]
+#define SWIGTYPE_p_FXHorizontalFrame swig_types[47]
+#define SWIGTYPE_p_FXHorizontalSeparator swig_types[48]
+#define SWIGTYPE_p_FXIcon swig_types[49]
+#define SWIGTYPE_p_FXIconDict swig_types[50]
+#define SWIGTYPE_p_FXId swig_types[51]
+#define SWIGTYPE_p_FXImageFrame swig_types[52]
+#define SWIGTYPE_p_FXImageView swig_types[53]
+#define SWIGTYPE_p_FXKnob swig_types[54]
+#define SWIGTYPE_p_FXListBox swig_types[55]
+#define SWIGTYPE_p_FXMainWindow swig_types[56]
+#define SWIGTYPE_p_FXMatrix swig_types[57]
+#define SWIGTYPE_p_FXMemoryStream swig_types[58]
+#define SWIGTYPE_p_FXObject swig_types[59]
+#define SWIGTYPE_p_FXPacker swig_types[60]
+#define SWIGTYPE_p_FXPopup swig_types[61]
+#define SWIGTYPE_p_FXProgressBar swig_types[62]
+#define SWIGTYPE_p_FXRealSlider swig_types[63]
+#define SWIGTYPE_p_FXRealSpinner swig_types[64]
+#define SWIGTYPE_p_FXRecentFiles swig_types[65]
+#define SWIGTYPE_p_FXRegion swig_types[66]
+#define SWIGTYPE_p_FXRegistry swig_types[67]
+#define SWIGTYPE_p_FXRootWindow swig_types[68]
+#define SWIGTYPE_p_FXRuler swig_types[69]
+#define SWIGTYPE_p_FXRulerView swig_types[70]
+#define SWIGTYPE_p_FXScrollArea swig_types[71]
+#define SWIGTYPE_p_FXScrollBar swig_types[72]
+#define SWIGTYPE_p_FXScrollCorner swig_types[73]
+#define SWIGTYPE_p_FXScrollWindow swig_types[74]
+#define SWIGTYPE_p_FXSeparator swig_types[75]
+#define SWIGTYPE_p_FXSettings swig_types[76]
+#define SWIGTYPE_p_FXShell swig_types[77]
+#define SWIGTYPE_p_FXShutter swig_types[78]
+#define SWIGTYPE_p_FXShutterItem swig_types[79]
+#define SWIGTYPE_p_FXSlider swig_types[80]
+#define SWIGTYPE_p_FXSpinner swig_types[81]
+#define SWIGTYPE_p_FXSplashWindow swig_types[82]
+#define SWIGTYPE_p_FXSplitter swig_types[83]
+#define SWIGTYPE_p_FXSpring swig_types[84]
+#define SWIGTYPE_p_FXStatusBar swig_types[85]
+#define SWIGTYPE_p_FXStatusLine swig_types[86]
+#define SWIGTYPE_p_FXStream swig_types[87]
+#define SWIGTYPE_p_FXStringDict swig_types[88]
+#define SWIGTYPE_p_FXSwitcher swig_types[89]
+#define SWIGTYPE_p_FXTabBar swig_types[90]
+#define SWIGTYPE_p_FXTabBook swig_types[91]
+#define SWIGTYPE_p_FXTable swig_types[92]
+#define SWIGTYPE_p_FXTableItem swig_types[93]
+#define SWIGTYPE_p_FXTablePos swig_types[94]
+#define SWIGTYPE_p_FXTableRange swig_types[95]
+#define SWIGTYPE_p_FXTextField swig_types[96]
+#define SWIGTYPE_p_FXToolBar swig_types[97]
+#define SWIGTYPE_p_FXToolBarGrip swig_types[98]
+#define SWIGTYPE_p_FXToolBarShell swig_types[99]
+#define SWIGTYPE_p_FXToolBarTab swig_types[100]
+#define SWIGTYPE_p_FXToolTip swig_types[101]
+#define SWIGTYPE_p_FXTopWindow swig_types[102]
+#define SWIGTYPE_p_FXTranslator swig_types[103]
+#define SWIGTYPE_p_FXTreeListBox swig_types[104]
+#define SWIGTYPE_p_FXVerticalFrame swig_types[105]
+#define SWIGTYPE_p_FXVerticalSeparator swig_types[106]
+#define SWIGTYPE_p_FXVisual swig_types[107]
+#define SWIGTYPE_p_FXWindow swig_types[108]
+#define SWIGTYPE_p_char swig_types[109]
+#define SWIGTYPE_p_double swig_types[110]
+#define SWIGTYPE_p_float swig_types[111]
+#define SWIGTYPE_p_int swig_types[112]
+#define SWIGTYPE_p_long swig_types[113]
+#define SWIGTYPE_p_short swig_types[114]
+#define SWIGTYPE_p_unsigned_char swig_types[115]
+#define SWIGTYPE_p_unsigned_int swig_types[116]
+#define SWIGTYPE_p_unsigned_long swig_types[117]
+#define SWIGTYPE_p_unsigned_short swig_types[118]
+static swig_type_info *swig_types[120];
+static swig_module_info swig_module = {swig_types, 119, 0, 0, 0, 0};
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
+
+/* -------- TYPES TABLE (END) -------- */
+
+#define SWIG_init    Init_table
+#define SWIG_name    "Table"
+
+
+
+#define SWIG_RUBY_THREAD_BEGIN_BLOCK
+#define SWIG_RUBY_THREAD_END_BLOCK
+
+
+#define SWIGVERSION 0x030012 
+#define SWIG_VERSION SWIGVERSION
+
+
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
+
+
+#include <stdexcept>
+
+
+#include "FXRbCommon.h"
+
+
+inline FXColor to_FXColor(VALUE obj){
+  if(TYPE(obj)==T_STRING){
+    return fxcolorfromname(StringValuePtr(obj));
+    }
+  else if(TYPE(obj)==T_SYMBOL){
+    return fxcolorfromname(rb_id2name(SYM2ID(obj)));
+    }
+  else{
+    return NUM2ULONG(obj);
+    }
+  }
+
+
+inline FXString to_FXString(VALUE obj){
+  if(!NIL_P(obj)){
+    Check_Type(obj,T_STRING);
+    return FXString(StringValuePtr(obj));
+    }
+  else{
+    return FXString::null;
+    }
+  }
+
+
+inline FXbool to_FXbool(VALUE obj){
+  if (obj == Qtrue || obj == Qfalse){
+    return (obj == Qtrue) ? TRUE : FALSE;
+    }
+  else{
+    return static_cast<FXbool>(NUM2UINT(obj));
+    }
+  }
+
+
+static swig_type_info* FXEventTypeInfo=0;
+
+inline void* to_FXEvent(VALUE obj){
+  void* ptr;
+  if(!FXEventTypeInfo){
+    FXEventTypeInfo=SWIG_TypeQuery("FXEvent *");
+    FXASSERT(FXEventTypeInfo!=0);
+    }
+  SWIG_ConvertPtr(obj,&ptr,FXEventTypeInfo,1);
+  return ptr;
+  }
+
+
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
+
+
+  #define SWIG_From_long   LONG2NUM 
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_int  (int value)
+{    
+  return SWIG_From_long  (value);
+}
+
+SWIGINTERN FXTableItem *new_FXTableItem(FXString const &text,FXIcon *ic=0,void *ITEMDATA=0){
+      return new FXRbTableItem(text,ic,ITEMDATA);
+      }
+SWIGINTERN void FXTableItem_setData(FXTableItem *self,VALUE ptr){
+      self->setData(reinterpret_cast<void*>(ptr));
+      }
+SWIGINTERN VALUE FXTableItem_getData(FXTableItem const *self){
+      return self->getData() ? reinterpret_cast<VALUE>(self->getData()) : Qnil;
+      }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_long  (unsigned long value)
+{
+  return ULONG2NUM(value); 
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_int  (unsigned int value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+
+SWIGINTERN VALUE
+SWIG_ruby_failed(VALUE, VALUE)
+{
+  return Qnil;
+} 
+
+
+/*@SWIG:/usr/share/swig3.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE pargs){VALUE *args=(VALUE *)pargs;
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  long *res = (long *)(args[1]);
+  *res = type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj);
+  return obj;
+}
+/*@SWIG@*/
+
+SWIGINTERN int
+SWIG_AsVal_long (VALUE obj, long* val)
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
+    long v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_VALUE_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_VALUE_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_int (VALUE obj, int *val)
+{
+  long v;
+  int res = SWIG_AsVal_long (obj, &v);
+  if (SWIG_IsOK(res)) {
+    if ((v < INT_MIN || v > INT_MAX)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = static_cast< int >(v);
+    }
+  }  
+  return res;
+}
+
+
+/*@SWIG:/usr/share/swig3.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE pargs){VALUE *args=(VALUE *)pargs;
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  unsigned long *res = (unsigned long *)(args[1]);
+  *res = type == T_FIXNUM ? NUM2ULONG(obj) : rb_big2ulong(obj);
+  return obj;
+}
+/*@SWIG@*/
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_long (VALUE obj, unsigned long *val) 
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
+    unsigned long v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_VALUE_METHOD_FUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, RUBY_VALUE_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_int (VALUE obj, unsigned int *val)
+{
+  unsigned long v;
+  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
+  if (SWIG_IsOK(res)) {
+    if ((v > UINT_MAX)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = static_cast< unsigned int >(v);
+    }
+  }  
+  return res;
+}
+
+
+SWIGINTERN swig_type_info*
+SWIG_pchar_descriptor(void)
+{
+  static int init = 0;
+  static swig_type_info* info = 0;
+  if (!init) {
+    info = SWIG_TypeQuery("_p_char");
+    init = 1;
+  }
+  return info;
+}
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+  if (carray) {
+    if (size > LONG_MAX) {
+      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+      return pchar_descriptor ? 
+	SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : Qnil;
+    } else {
+      return rb_str_new(carray, static_cast< long >(size));
+    }
+  } else {
+    return Qnil;
+  }
+}
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtr(const char *cptr)
+{ 
+  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
+}
+
+SWIGINTERN FXTable *new_FXTable(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_MARGIN,FXint pr=DEFAULT_MARGIN,FXint pt=DEFAULT_MARGIN,FXint pb=DEFAULT_MARGIN){
+      return new FXRbTable(p,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN void FXTable_setItem(FXTable *self,FXint row,FXint col,FXTableItem *item,FXbool notify=0){
+      if(item!=0 && item->isMemberOf(FXMETACLASS(FXRbTableItem))){
+        dynamic_cast<FXRbTableItem*>(item)->owned=1;
+        }
+      self->setItem(row,col,item,notify);
+      }
+SWIGINTERN FXint FXTable_getColumnX(FXTable const *self,FXint colEdge){
+      if(colEdge<0 || self->getColumnHeader()->getNumItems()<=colEdge){
+        rb_raise(rb_eIndexError,"table column out of bounds");
+        }
+      return self->getColumnX(colEdge);
+      }
+SWIGINTERN FXint FXTable_getRowY(FXTable const *self,FXint rowEdge){
+      if(rowEdge<0 || self->getRowHeader()->getNumItems()<=rowEdge){
+        rb_raise(rb_eIndexError,"table row out of bounds");
+        }
+      return self->getRowY(rowEdge);
+      }
+SWIGINTERN void FXTable_setItemText(FXTable *self,FXint r,FXint c,FXString const &text,FXbool notify=0){
+      FXRbTableItem* item;
+      self->setItemText(r,c,text,notify);
+      item=dynamic_cast<FXRbTableItem*>(self->getItem(r,c));
+      if(item!=0){
+        item->owned=1;
+        }
+      }
+SWIGINTERN void FXTable_setItemIcon(FXTable *self,FXint r,FXint c,FXIcon *icon,FXbool notify=0){
+      FXRbTableItem* item;
+      self->setItemIcon(r,c,icon,notify);
+      item=dynamic_cast<FXRbTableItem*>(self->getItem(r,c));
+      if(item!=0){
+        item->owned=1;
+        }
+      }
+SWIGINTERN void FXTable_setItemData(FXTable *self,FXint r,FXint c,VALUE ptr){
+      FXRbTableItem* item;
+      self->setItemData(r,c,reinterpret_cast<void*>(ptr));
+      item=dynamic_cast<FXRbTableItem*>(self->getItem(r,c));
+      if(item!=0){
+        item->owned=1;
+        }
+      }
+SWIGINTERN VALUE FXTable_getItemData(FXTable const *self,FXint r,FXint c){
+      void* ptr=self->getItemData(r,c);
+      return (ptr!=0) ? reinterpret_cast<VALUE>(ptr) : Qnil;
+      }
+
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
+{
+  if (TYPE(obj) == T_STRING) {
+    char *cstr = StringValuePtr(obj); 
+    size_t size = RSTRING_LEN(obj) + 1;
+    if (cptr)  {
+      if (alloc) {
+	if (*alloc == SWIG_NEWOBJ) {
+	  *cptr = reinterpret_cast< char* >(memcpy(new char[size], cstr, sizeof(char)*(size)));
+	} else {
+	  *cptr = cstr;
+	  *alloc = SWIG_OLDOBJ;
+	}
+      }
+    }
+    if (psize) *psize = size;
+    return SWIG_OK;
+  } else {
+    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+    if (pchar_descriptor) {
+      void* vptr = 0;
+      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
+	if (cptr) *cptr = (char *)vptr;
+	if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
+	if (alloc) *alloc = SWIG_OLDOBJ;
+	return SWIG_OK;
+      }
+    }
+  }  
+  return SWIG_TypeError;
+}
+
+
+
+
+SWIGINTERN VALUE FXTable_extractText(FXTable const *self,FXint startrow,FXint endrow,FXint startcol,FXint endcol,FXchar const *cs="\t",FXchar const *rs="\n"){
+      FXString str;
+      VALUE result;
+      if(startrow<0 || startcol<0 || self->getNumRows()<=endrow || self->getNumColumns()<=endcol) rb_raise(rb_eIndexError,"index out of bounds");
+      self->extractText(str,startrow,endrow,startcol,endcol,cs,rs);
+      result=to_ruby(str);
+      return result;
+      }
+SWIGINTERN void FXTable_overlayText(FXTable *self,FXint startrow,FXint endrow,FXint startcol,FXint endcol,VALUE str,FXchar const *cs="\t",FXchar const *rs="\n",FXbool notify=0){
+      if(startrow<0 || startcol<0 || self->getNumRows()<=endrow || self->getNumColumns()<=endcol) rb_raise(rb_eIndexError,"index out of bounds");
+      const FXchar* text=reinterpret_cast<FXchar*>(StringValuePtr(str));
+      FXint size=RSTRING_LEN(str);
+      self->overlayText(startrow,endrow,startcol,endcol,text,size,cs,rs,notify);
+      }
+SWIGINTERN VALUE FXTable_countText(FXTable const *self,FXString const &text,FXchar const *cs="\t,",FXchar const *rs="\n"){
+      FXint nr,nc;
+      self->countText(nr,nc,text,cs,rs);
+      return rb_ary_new3(2,INT2NUM(nr),INT2NUM(nc));
+      }
+SWIGINTERN void FXTable_updateRange(FXTable const *self,FXint sr,FXint er,FXint sc,FXint ec){
+      if(sr<0 || sc<0 || self->getNumRows()<=er || self->getNumColumns()<=ec) rb_raise(rb_eIndexError,"index out of bounds");
+      self->updateRange(sr,er,sc,ec);
+      }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_bool  (bool value)
+{
+  return value ? Qtrue : Qfalse;
+}
+
+SWIGINTERN VALUE FXTable_position__SWIG_1(FXTable const *self){
+    FXint x, y;
+    self->getPosition(x, y);
+    VALUE pos = rb_ary_new();
+    rb_ary_push(pos, INT2NUM(x));
+    rb_ary_push(pos, INT2NUM(y));
+    return pos;
+  }
+static swig_class SwigClassFXTablePos;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXTablePos_allocate(VALUE self)
+#else
+_wrap_FXTablePos_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXTablePos);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXTablePos(int argc, VALUE *argv, VALUE self) {
+  FXTablePos *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (FXTablePos *)new FXTablePos();
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTablePos_row_set(int argc, VALUE *argv, VALUE self) {
+  FXTablePos *arg1 = (FXTablePos *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTablePos, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTablePos *","row", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTablePos * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->row = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTablePos_row_get(int argc, VALUE *argv, VALUE self) {
+  FXTablePos *arg1 = (FXTablePos *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTablePos, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTablePos *","row", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTablePos * >(argp1);
+  result = (FXint) ((arg1)->row);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTablePos_col_set(int argc, VALUE *argv, VALUE self) {
+  FXTablePos *arg1 = (FXTablePos *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTablePos, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTablePos *","col", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTablePos * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->col = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTablePos_col_get(int argc, VALUE *argv, VALUE self) {
+  FXTablePos *arg1 = (FXTablePos *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTablePos, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTablePos *","col", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTablePos * >(argp1);
+  result = (FXint) ((arg1)->col);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN void
+free_FXTablePos(void *self) {
+    FXTablePos *arg1 = (FXTablePos *)self;
+    delete arg1;
+}
+
+static swig_class SwigClassFXTableRange;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXTableRange_allocate(VALUE self)
+#else
+_wrap_FXTableRange_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXTableRange);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXTableRange(int argc, VALUE *argv, VALUE self) {
+  FXTableRange *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (FXTableRange *)new FXTableRange();
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableRange_fm_set(int argc, VALUE *argv, VALUE self) {
+  FXTableRange *arg1 = (FXTableRange *) 0 ;
+  FXTablePos *arg2 = (FXTablePos *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableRange, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableRange *","fm", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableRange * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTablePos, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTablePos *","fm", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTablePos * >(argp2);
+  if (arg1) (arg1)->fm = *arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableRange_fm_get(int argc, VALUE *argv, VALUE self) {
+  FXTableRange *arg1 = (FXTableRange *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTablePos *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableRange, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableRange *","fm", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableRange * >(argp1);
+  result = (FXTablePos *)& ((arg1)->fm);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXTablePos, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableRange_to_set(int argc, VALUE *argv, VALUE self) {
+  FXTableRange *arg1 = (FXTableRange *) 0 ;
+  FXTablePos *arg2 = (FXTablePos *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableRange, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableRange *","to", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableRange * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTablePos, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTablePos *","to", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTablePos * >(argp2);
+  if (arg1) (arg1)->to = *arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableRange_to_get(int argc, VALUE *argv, VALUE self) {
+  FXTableRange *arg1 = (FXTableRange *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTablePos *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableRange, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableRange *","to", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableRange * >(argp1);
+  result = (FXTablePos *)& ((arg1)->to);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXTablePos, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN void
+free_FXTableRange(void *self) {
+    FXTableRange *arg1 = (FXTableRange *)self;
+    delete arg1;
+}
+
+static swig_class SwigClassFXTableItem;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXTableItem_allocate(VALUE self)
+#else
+_wrap_FXTableItem_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXTableItem);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXTableItem(int argc, VALUE *argv, VALUE self) {
+  FXString *arg1 = 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *arg3 = (void *) 0 ;
+  SwigValueWrapper< FXString > p1 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXTableItem *result = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  p1 = to_FXString(argv[0]); arg1 = &p1;
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","FXTableItem", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXIcon * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = (argv[2] == Qnil) ? NULL : (void *) argv[2];
+  }
+  {
+    result = (FXTableItem *)new_FXTableItem((FXString const &)*arg1,arg2,arg3);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_setData(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem *","setData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  arg2 = argv[0];
+  FXTableItem_setData(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_getData(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem const *","getData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  result = (VALUE)FXTableItem_getData((FXTableItem const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_hasFocus(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem const *","hasFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  result = (FXbool)((FXTableItem const *)arg1)->hasFocus();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_isSelected(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem const *","isSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  result = (FXbool)((FXTableItem const *)arg1)->isSelected();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_isEnabled(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem const *","isEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  result = (FXbool)((FXTableItem const *)arg1)->isEnabled();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_isDraggable(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem const *","isDraggable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  result = (FXbool)((FXTableItem const *)arg1)->isDraggable();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_getJustify(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem const *","getJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  result = (FXuint)((FXTableItem const *)arg1)->getJustify();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_getIconPosition(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem const *","getIconPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  result = (FXuint)((FXTableItem const *)arg1)->getIconPosition();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_getBorders(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem const *","getBorders", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  result = (FXuint)((FXTableItem const *)arg1)->getBorders();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_getStipple(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXStipplePattern result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem const *","getStipple", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  result = (FXStipplePattern)((FXTableItem const *)arg1)->getStipple();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_save(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTableItem_save((FXTableItem const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_load(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTableItem_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_draw(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  FXTable *arg2 = (FXTable *) 0 ;
+  FXDC *arg3 = 0 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem const *","draw", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTable const *","draw", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTable * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXDC,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXDC &","draw", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDC &","draw", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXDC * >(argp3);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXTableItem_draw((FXTableItem const *)arg1,(FXTable const *)arg2,*arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_drawBorders(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  FXTable *arg2 = (FXTable *) 0 ;
+  FXDC *arg3 = 0 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem const *","drawBorders", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTable const *","drawBorders", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTable * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXDC,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXDC &","drawBorders", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDC &","drawBorders", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXDC * >(argp3);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXTableItem_drawBorders((FXTableItem const *)arg1,(FXTable const *)arg2,*arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_drawContent(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  FXTable *arg2 = (FXTable *) 0 ;
+  FXDC *arg3 = 0 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem const *","drawContent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTable const *","drawContent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTable * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXDC,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXDC &","drawContent", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDC &","drawContent", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXDC * >(argp3);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXTableItem_drawContent((FXTableItem const *)arg1,(FXTable const *)arg2,*arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_drawPattern(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  FXTable *arg2 = (FXTable *) 0 ;
+  FXDC *arg3 = 0 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem const *","drawPattern", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTable const *","drawPattern", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTable * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXDC,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXDC &","drawPattern", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDC &","drawPattern", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXDC * >(argp3);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXTableItem_drawPattern((FXTableItem const *)arg1,(FXTable const *)arg2,*arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_drawBackground(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  FXTable *arg2 = (FXTable *) 0 ;
+  FXDC *arg3 = 0 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem const *","drawBackground", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTable const *","drawBackground", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTable * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_FXDC,  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXDC &","drawBackground", 3, argv[1] )); 
+  }
+  if (!argp3) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDC &","drawBackground", 3, argv[1])); 
+  }
+  arg3 = reinterpret_cast< FXDC * >(argp3);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  FXTableItem_drawBackground((FXTableItem const *)arg1,(FXTable const *)arg2,*arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_setText(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem *","setText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  FXTableItem_setText(arg1,(FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_getText(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem const *","getText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  result = FXTableItem_getText((FXTableItem const *)arg1);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_setIcon(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem *","setIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXTableItem_setIcon(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_getIcon(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem const *","getIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  result = (FXIcon *)FXTableItem_getIcon((FXTableItem const *)arg1);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXTableItem_setFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_setSelected(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem *","setSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXTableItem_setSelected(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_setEnabled(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem *","setEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXTableItem_setEnabled(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_setDraggable(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem *","setDraggable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXTableItem_setDraggable(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_setJustify(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  FXuint arg2 = (FXuint) FXTableItem::RIGHT|FXTableItem::CENTER_Y ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem *","setJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  FXTableItem_setJustify(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_setIconPosition(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem *","setIconPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  FXTableItem_setIconPosition(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_setBorders(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  FXuint arg2 = (FXuint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem *","setBorders", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  FXTableItem_setBorders(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_setStipple(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  FXStipplePattern arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem *","setStipple", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXStipplePattern","setStipple", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXStipplePattern >(val2);
+  FXTableItem_setStipple(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_getControlFor(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  FXTable *arg2 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXWindow *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem *","getControlFor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTable *","getControlFor", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTable * >(argp2);
+  result = (FXWindow *)FXTableItem_getControlFor(arg1,arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXWindow, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_setFromControl(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem *","setFromControl", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","setFromControl", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXTableItem_setFromControl(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_getWidth(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  FXTable *arg2 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem const *","getWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTable const *","getWidth", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTable * >(argp2);
+  result = (FXint)FXTableItem_getWidth((FXTableItem const *)arg1,(FXTable const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_getHeight(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  FXTable *arg2 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem const *","getHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTable const *","getHeight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTable * >(argp2);
+  result = (FXint)FXTableItem_getHeight((FXTableItem const *)arg1,(FXTable const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_create(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  FXTableItem_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_detach(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  FXTableItem_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTableItem_destroy(int argc, VALUE *argv, VALUE self) {
+  FXTableItem *arg1 = (FXTableItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTableItem *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTableItem * >(argp1);
+  FXTableItem_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXTable;
+
+SWIGINTERN VALUE
+_wrap_FXTable_csvType_get(VALUE self) {
+  VALUE _val;
+  
+  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(FXTable::csvType));
+  return _val;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_csvType_set(VALUE self, VALUE _val) {
+  {
+    unsigned int val;
+    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
+    if (!SWIG_IsOK(res)) {
+      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""FXTable::csvType""' of type '""FXDragType""'");
+    }
+    FXTable::csvType = static_cast< FXDragType >(val);
+  }
+  return _val;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_csvTypeName_get(VALUE self) {
+  VALUE _val;
+  
+  _val = SWIG_FromCharPtr(FXTable::csvTypeName);
+  return _val;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onFocusIn(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onFocusIn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusIn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusIn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onFocusOut(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onFocusOut", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusOut", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusOut(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onRightBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onRightBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onRightBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onRightBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onRightBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onRightBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onSelectionLost(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onSelectionLost", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSelectionLost", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onSelectionLost(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onSelectionGained(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onSelectionGained", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSelectionGained", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onSelectionGained(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onSelectionRequest(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onSelectionRequest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSelectionRequest", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onSelectionRequest(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onClipboardLost(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onClipboardLost", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClipboardLost", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onClipboardLost(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onClipboardGained(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onClipboardGained", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClipboardGained", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onClipboardGained(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onClipboardRequest(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onClipboardRequest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClipboardRequest", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onClipboardRequest(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onAutoScroll(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onAutoScroll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onAutoScroll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onAutoScroll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCommand(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCommand", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCommand", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCommand(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onClicked(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onDoubleClicked(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onDoubleClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDoubleClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDoubleClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onTripleClicked(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onTripleClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTripleClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onTripleClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdToggleEditable(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdToggleEditable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdToggleEditable", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdToggleEditable(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onUpdToggleEditable(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdToggleEditable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdToggleEditable", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdToggleEditable(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdHorzGrid(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdHorzGrid", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdHorzGrid", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdHorzGrid(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onUpdHorzGrid(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdHorzGrid", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdHorzGrid", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdHorzGrid(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdVertGrid(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdVertGrid", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdVertGrid", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdVertGrid(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onUpdVertGrid(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdVertGrid", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdVertGrid", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdVertGrid(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdDeleteColumn(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdDeleteColumn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDeleteColumn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDeleteColumn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onUpdDeleteColumn(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdDeleteColumn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdDeleteColumn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdDeleteColumn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdDeleteRow(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdDeleteRow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDeleteRow", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDeleteRow(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onUpdDeleteRow(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdDeleteRow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdDeleteRow", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdDeleteRow(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdInsertColumn(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdInsertColumn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdInsertColumn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdInsertColumn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onUpdInsertColumn(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdInsertColumn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdInsertColumn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdInsertColumn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdInsertRow(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdInsertRow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdInsertRow", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdInsertRow(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onUpdInsertRow(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdInsertRow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdInsertRow", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdInsertRow(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdMoveRight(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdMoveRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMoveRight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdMoveRight(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdMoveLeft(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdMoveLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMoveLeft", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdMoveLeft(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdMoveUp(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdMoveUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMoveUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdMoveUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdMoveDown(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdMoveDown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMoveDown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdMoveDown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdMoveHome(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdMoveHome", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMoveHome", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdMoveHome(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdMoveEnd(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdMoveEnd", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMoveEnd", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdMoveEnd(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdMoveTop(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdMoveTop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMoveTop", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdMoveTop(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdMoveBottom(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdMoveBottom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMoveBottom", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdMoveBottom(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdMovePageDown(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdMovePageDown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMovePageDown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdMovePageDown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdMovePageUp(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdMovePageUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMovePageUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdMovePageUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdMark(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdMark", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMark", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdMark(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdExtend(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdExtend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdExtend", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdExtend(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onUpdSelectCell(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdSelectCell", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSelectCell", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onUpdSelectCell", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onUpdSelectCell(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdSelectCell(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdSelectCell", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSelectCell", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSelectCell(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onUpdSelectRow(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdSelectRow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSelectRow", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onUpdSelectRow", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onUpdSelectRow(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdSelectRow(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdSelectRow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSelectRow", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSelectRow(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onUpdSelectColumn(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdSelectColumn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSelectColumn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdSelectColumn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdSelectColumn(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdSelectColumn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSelectColumn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSelectColumn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdSelectRowIndex(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdSelectRowIndex", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSelectRowIndex", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSelectRowIndex(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdSelectColumnIndex(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdSelectColumnIndex", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSelectColumnIndex", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSelectColumnIndex(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onUpdSelectAll(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdSelectAll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSelectAll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdSelectAll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdSelectAll(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdSelectAll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSelectAll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSelectAll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onUpdDeselectAll(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdDeselectAll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdDeselectAll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdDeselectAll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdDeselectAll(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdDeselectAll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDeselectAll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDeselectAll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdCutSel(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdCutSel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCutSel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCutSel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdCopySel(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdCopySel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCopySel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCopySel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdDeleteSel(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdDeleteSel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDeleteSel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDeleteSel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdPasteSel(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdPasteSel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdPasteSel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdPasteSel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onUpdHaveSelection(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdHaveSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdHaveSelection", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdHaveSelection(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdStartInput(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdStartInput", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdStartInput", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdStartInput(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onUpdStartInput(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdStartInput", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdStartInput", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdStartInput(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdAcceptInput(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdAcceptInput", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdAcceptInput", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdAcceptInput(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onUpdAcceptInput(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onUpdAcceptInput", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdAcceptInput", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdAcceptInput(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_onCmdCancelInput(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","onCmdCancelInput", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCancelInput", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCancelInput(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXTable_allocate(VALUE self)
+#else
+_wrap_FXTable_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXTable);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXTable(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) DEFAULT_MARGIN ;
+  FXint arg10 = (FXint) DEFAULT_MARGIN ;
+  FXint arg11 = (FXint) DEFAULT_MARGIN ;
+  FXint arg12 = (FXint) DEFAULT_MARGIN ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXTable *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXTable", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXTable", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXTable *)new_FXTable(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_cornerButton(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXButton *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getCornerButton", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXButton *)((FXTable const *)arg1)->getCornerButton();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXButton, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getColumnHeader(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXHeader *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getColumnHeader", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXHeader *)((FXTable const *)arg1)->getColumnHeader();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXHeader, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getRowHeader(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXHeader *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getRowHeader", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXHeader *)((FXTable const *)arg1)->getRowHeader();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXHeader, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setVisibleRows(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setVisibleRows", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setVisibleRows(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getVisibleRows(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getVisibleRows", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)((FXTable const *)arg1)->getVisibleRows();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setVisibleColumns(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setVisibleColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setVisibleColumns(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getVisibleColumns(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getVisibleColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)((FXTable const *)arg1)->getVisibleColumns();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_editableq___(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isEditable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXbool)((FXTable const *)arg1)->isEditable();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_editablee___(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setEditable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->setEditable(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_showHorzGrid(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","showHorzGrid", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->showHorzGrid(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_isHorzGridShown(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isHorzGridShown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXbool)((FXTable const *)arg1)->isHorzGridShown();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_showVertGrid(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","showVertGrid", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->showVertGrid(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_isVertGridShown(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isVertGridShown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXbool)((FXTable const *)arg1)->isVertGridShown();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getNumRows(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getNumRows", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)((FXTable const *)arg1)->getNumRows();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getNumColumns(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getNumColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)((FXTable const *)arg1)->getNumColumns();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setMarginTop(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setMarginTop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setMarginTop(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getMarginTop(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getMarginTop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)((FXTable const *)arg1)->getMarginTop();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setMarginBottom(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setMarginBottom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setMarginBottom(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getMarginBottom(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getMarginBottom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)((FXTable const *)arg1)->getMarginBottom();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setMarginLeft(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setMarginLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setMarginLeft(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getMarginLeft(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getMarginLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)((FXTable const *)arg1)->getMarginLeft();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setMarginRight(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setMarginRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setMarginRight(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getMarginRight(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getMarginRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)((FXTable const *)arg1)->getMarginRight();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_colAtX(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","colAtX", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)((FXTable const *)arg1)->colAtX(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_rowAtY(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","rowAtY", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)((FXTable const *)arg1)->rowAtY(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getItem(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTableItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (FXTableItem *)((FXTable const *)arg1)->getItem(arg2,arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTableItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setItem(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXTableItem *arg4 = (FXTableItem *) 0 ;
+  FXbool arg5 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  
+  if ((argc < 3) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXTableItem, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXTableItem *","setItem", 4, argv[2] )); 
+  }
+  arg4 = reinterpret_cast< FXTableItem * >(argp4);
+  if (argc > 3) {
+    arg5 = to_FXbool(argv[3]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  FXTable_setItem(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_isItemVisible(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isItemVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (FXbool)((FXTable const *)arg1)->isItemVisible(arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setColumnHeaderMode(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXuint arg2 = (FXuint) LAYOUT_FIX_HEIGHT ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setColumnHeaderMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  (arg1)->setColumnHeaderMode(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getColumnHeaderMode(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getColumnHeaderMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXuint)((FXTable const *)arg1)->getColumnHeaderMode();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setRowHeaderMode(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXuint arg2 = (FXuint) LAYOUT_FIX_WIDTH ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setRowHeaderMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  (arg1)->setRowHeaderMode(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getRowHeaderMode(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getRowHeaderMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXuint)((FXTable const *)arg1)->getRowHeaderMode();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setColumnHeaderFont(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setColumnHeaderFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setColumnHeaderFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  (arg1)->setColumnHeaderFont(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getColumnHeaderFont(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getColumnHeaderFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXFont *)((FXTable const *)arg1)->getColumnHeaderFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setRowHeaderFont(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setRowHeaderFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setRowHeaderFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  (arg1)->setRowHeaderFont(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getRowHeaderFont(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getRowHeaderFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXFont *)((FXTable const *)arg1)->getRowHeaderFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setColumnHeaderHeight(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setColumnHeaderHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setColumnHeaderHeight(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getColumnHeaderHeight(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getColumnHeaderHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)((FXTable const *)arg1)->getColumnHeaderHeight();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setRowHeaderWidth(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setRowHeaderWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setRowHeaderWidth(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getRowHeaderWidth(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getRowHeaderWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)((FXTable const *)arg1)->getRowHeaderWidth();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getColumnX(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getColumnX", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXTable_getColumnX((FXTable const *)arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getRowY(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getRowY", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXTable_getRowY((FXTable const *)arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getColumnWidth(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getColumnWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (FXint)((FXTable const *)arg1)->getColumnWidth(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getRowHeight(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getRowHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  result = (FXint)((FXTable const *)arg1)->getRowHeight(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setDefColumnWidth(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setDefColumnWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setDefColumnWidth(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getDefColumnWidth(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getDefColumnWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)((FXTable const *)arg1)->getDefColumnWidth();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setDefRowHeight(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setDefRowHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setDefRowHeight(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getDefRowHeight(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getDefRowHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)((FXTable const *)arg1)->getDefRowHeight();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getMinRowHeight(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getMinRowHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  result = (FXint)((FXTable const *)arg1)->getMinRowHeight(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getMinColumnWidth(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getMinColumnWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (FXint)((FXTable const *)arg1)->getMinColumnWidth(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_fitRowsToContents(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","fitRowsToContents", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 + arg3 > arg1->getNumRows()) {
+      rb_raise(rb_eIndexError,"table row out of bounds");
+    }
+  }
+  (arg1)->fitRowsToContents(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_fitColumnsToContents(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","fitColumnsToContents", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 + arg3 > arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError,"table column out of bounds");
+    }
+  }
+  (arg1)->fitColumnsToContents(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setColumnText(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setColumnText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  (arg1)->setColumnText(arg2,(FXString const &)*arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getColumnText(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getColumnText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = ((FXTable const *)arg1)->getColumnText(arg2);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setRowText(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setRowText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  (arg1)->setRowText(arg2,(FXString const &)*arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getRowText(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getRowText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  result = ((FXTable const *)arg1)->getRowText(arg2);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setColumnIcon(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setColumnIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","setColumnIcon", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXIcon * >(argp3);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  (arg1)->setColumnIcon(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getColumnIcon(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getColumnIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (FXIcon *)((FXTable const *)arg1)->getColumnIcon(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setRowIcon(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setRowIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","setRowIcon", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXIcon * >(argp3);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  (arg1)->setRowIcon(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getRowIcon(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getRowIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  result = (FXIcon *)((FXTable const *)arg1)->getRowIcon(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setColumnIconPosition(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setColumnIconPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  (arg1)->setColumnIconPosition(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getColumnIconPosition(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getColumnIconPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (FXuint)((FXTable const *)arg1)->getColumnIconPosition(arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setRowIconPosition(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setRowIconPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  (arg1)->setRowIconPosition(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getRowIconPosition(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getRowIconPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  result = (FXuint)((FXTable const *)arg1)->getRowIconPosition(arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setColumnJustify(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setColumnJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  (arg1)->setColumnJustify(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getColumnJustify(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getColumnJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (FXuint)((FXTable const *)arg1)->getColumnJustify(arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setRowJustify(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXuint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setRowJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  (arg1)->setRowJustify(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getRowJustify(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getRowJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  result = (FXuint)((FXTable const *)arg1)->getRowJustify(arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setItemText(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXString *arg4 = 0 ;
+  FXbool arg5 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p4 ;
+  
+  if ((argc < 3) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setItemText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  p4 = to_FXString(argv[2]); arg4 = &p4;
+  if (argc > 3) {
+    arg5 = to_FXbool(argv[3]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  FXTable_setItemText(arg1,arg2,arg3,(FXString const &)*arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getItemText(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getItemText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = ((FXTable const *)arg1)->getItemText(arg2,arg3);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setItemIcon(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXbool arg5 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  
+  if ((argc < 3) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setItemIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","setItemIcon", 4, argv[2] )); 
+  }
+  arg4 = reinterpret_cast< FXIcon * >(argp4);
+  if (argc > 3) {
+    arg5 = to_FXbool(argv[3]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  FXTable_setItemIcon(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getItemIcon(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getItemIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (FXIcon *)((FXTable const *)arg1)->getItemIcon(arg2,arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setItemData(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  VALUE arg4 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setItemData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = argv[2];
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  FXTable_setItemData(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getItemData(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getItemData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (VALUE)FXTable_getItemData((FXTable const *)arg1,arg2,arg3);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_extractText(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXchar *arg6 = (FXchar *) "\t" ;
+  FXchar *arg7 = (FXchar *) "\n" ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","extractText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = NIL_P(argv[4]) ? 0 : StringValuePtr(argv[4]);
+  }
+  if (argc > 5) {
+    arg7 = NIL_P(argv[5]) ? 0 : StringValuePtr(argv[5]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg4 < 0 || arg4 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  {
+    if (arg5 < 0 || arg5 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (VALUE)FXTable_extractText((FXTable const *)arg1,arg2,arg3,arg4,arg5,(char const *)arg6,(char const *)arg7);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_overlayText(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  VALUE arg6 = (VALUE) 0 ;
+  FXchar *arg7 = (FXchar *) "\t" ;
+  FXchar *arg8 = (FXchar *) "\n" ;
+  FXbool arg9 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 5) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","overlayText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = argv[4];
+  if (argc > 5) {
+    arg7 = NIL_P(argv[5]) ? 0 : StringValuePtr(argv[5]);
+  }
+  if (argc > 6) {
+    arg8 = NIL_P(argv[6]) ? 0 : StringValuePtr(argv[6]);
+  }
+  if (argc > 7) {
+    arg9 = to_FXbool(argv[7]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg4 < 0 || arg4 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  {
+    if (arg5 < 0 || arg5 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  FXTable_overlayText(arg1,arg2,arg3,arg4,arg5,arg6,(char const *)arg7,(char const *)arg8,arg9);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_countText(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXString *arg2 = 0 ;
+  FXchar *arg3 = (FXchar *) "\t," ;
+  FXchar *arg4 = (FXchar *) "\n" ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","countText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NIL_P(argv[2]) ? 0 : StringValuePtr(argv[2]);
+  }
+  result = (VALUE)FXTable_countText((FXTable const *)arg1,(FXString const &)*arg2,(char const *)arg3,(char const *)arg4);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_isItemSpanning(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isItemSpanning", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (FXbool)((FXTable const *)arg1)->isItemSpanning(arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_updateRange(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","updateRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXTable_updateRange((FXTable const *)arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_updateItem(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","updateItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  ((FXTable const *)arg1)->updateItem(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_isItemEnabled(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isItemEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (FXbool)((FXTable const *)arg1)->isItemEnabled(arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setItemJustify(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXuint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setItemJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2UINT(argv[2]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  (arg1)->setItemJustify(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getItemJustify(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getItemJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (FXuint)((FXTable const *)arg1)->getItemJustify(arg2,arg3);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setItemIconPosition(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXuint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setItemIconPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2UINT(argv[2]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  (arg1)->setItemIconPosition(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getItemIconPosition(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getItemIconPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (FXuint)((FXTable const *)arg1)->getItemIconPosition(arg2,arg3);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setItemBorders(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXuint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setItemBorders", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2UINT(argv[2]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  (arg1)->setItemBorders(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getItemBorders(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getItemBorders", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (FXuint)((FXTable const *)arg1)->getItemBorders(arg2,arg3);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setItemStipple(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXStipplePattern arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val4 ;
+  int ecode4 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setItemStipple", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  ecode4 = SWIG_AsVal_int(argv[2], &val4);
+  if (!SWIG_IsOK(ecode4)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "FXStipplePattern","setItemStipple", 4, argv[2] ));
+  } 
+  arg4 = static_cast< FXStipplePattern >(val4);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  (arg1)->setItemStipple(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getItemStipple(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXStipplePattern result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getItemStipple", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (FXStipplePattern)((FXTable const *)arg1)->getItemStipple(arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getCurrentRow(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getCurrentRow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)((FXTable const *)arg1)->getCurrentRow();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getCurrentColumn(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getCurrentColumn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)((FXTable const *)arg1)->getCurrentColumn();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_isItemCurrent(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isItemCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (FXbool)((FXTable const *)arg1)->isItemCurrent(arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setAnchorItem(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setAnchorItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  (arg1)->setAnchorItem(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getAnchorRow(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getAnchorRow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)((FXTable const *)arg1)->getAnchorRow();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getAnchorColumn(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getAnchorColumn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)((FXTable const *)arg1)->getAnchorColumn();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getSelStartRow(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getSelStartRow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)((FXTable const *)arg1)->getSelStartRow();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getSelStartColumn(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getSelStartColumn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)((FXTable const *)arg1)->getSelStartColumn();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getSelEndRow(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getSelEndRow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)((FXTable const *)arg1)->getSelEndRow();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getSelEndColumn(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getSelEndColumn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)((FXTable const *)arg1)->getSelEndColumn();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_isItemSelected(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isItemSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (FXbool)((FXTable const *)arg1)->isItemSelected(arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_isRowSelected(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isRowSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  result = (FXbool)((FXTable const *)arg1)->isRowSelected(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_isColumnSelected(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isColumnSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (FXbool)((FXTable const *)arg1)->isColumnSelected(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_isAnythingSelected(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isAnythingSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXbool)((FXTable const *)arg1)->isAnythingSelected();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setFont(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  (arg1)->setFont(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getFont(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXFont *)((FXTable const *)arg1)->getFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getTextColor(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXColor)((FXTable const *)arg1)->getTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getBaseColor(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getBaseColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXColor)((FXTable const *)arg1)->getBaseColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getHiliteColor(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getHiliteColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXColor)((FXTable const *)arg1)->getHiliteColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getShadowColor(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getShadowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXColor)((FXTable const *)arg1)->getShadowColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getBorderColor(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getBorderColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXColor)((FXTable const *)arg1)->getBorderColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXColor)((FXTable const *)arg1)->getSelBackColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXColor)((FXTable const *)arg1)->getSelTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getGridColor(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getGridColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXColor)((FXTable const *)arg1)->getGridColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getStippleColor(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getStippleColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXColor)((FXTable const *)arg1)->getStippleColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getCellBorderColor(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getCellBorderColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXColor)((FXTable const *)arg1)->getCellBorderColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setTextColor(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setBaseColor(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setBaseColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setBaseColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setHiliteColor(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setHiliteColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setHiliteColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setShadowColor(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setShadowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setShadowColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setBorderColor(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setBorderColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setBorderColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelBackColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setGridColor(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setGridColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setGridColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setStippleColor(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setStippleColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setStippleColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setCellBorderColor(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setCellBorderColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setCellBorderColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setCellColor(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXColor arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setCellColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = to_FXColor(argv[2]);
+  {
+    if (arg2 != 0 && arg2 != 1) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 != 0 && arg3 != 1) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  (arg1)->setCellColor(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getCellColor(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getCellColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 != 0 && arg2 != 1) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 != 0 && arg3 != 1) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (FXColor)((FXTable const *)arg1)->getCellColor(arg2,arg3);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setCellBorderWidth(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setCellBorderWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setCellBorderWidth(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getCellBorderWidth(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getCellBorderWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)((FXTable const *)arg1)->getCellBorderWidth();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getTableStyle(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getTableStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXuint)((FXTable const *)arg1)->getTableStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setTableStyle(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setTableStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setTableStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_columnRenumberinge___(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setColumnRenumbering", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->setColumnRenumbering(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_columnRenumberingq___(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getColumnRenumbering", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXbool)((FXTable const *)arg1)->getColumnRenumbering();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_rowRenumberinge___(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setRowRenumbering", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->setRowRenumbering(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_rowRenumberingq___(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getRowRenumbering", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXbool)((FXTable const *)arg1)->getRowRenumbering();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXString *) &((FXTable const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_save(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTable_save((FXTable const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_load(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTable_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_create(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  FXTable_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_detach(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  FXTable_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_destroy(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  FXTable_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_resize(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXTable_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)FXTable_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)FXTable_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXTable_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXTable_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (bool)FXTable_canFocus((FXTable const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  FXTable_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  FXTable_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXTable_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXTable_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_enable(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  FXTable_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_disable(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  FXTable_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  FXTable_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_lower(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  FXTable_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_move(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXTable_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXTable_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_layout(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  FXTable_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_recalc(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  FXTable_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_reparent(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXTable_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_show(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  FXTable_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_hide(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  FXTable_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (bool)FXTable_isComposite((FXTable const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_contains(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXTable_contains((FXTable const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (bool)FXTable_doesSaveUnder((FXTable const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXTable_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_tr(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXTable_tr((FXTable const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  FXTable_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  FXTable_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXTable_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXTable_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXTable_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXTable_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTable, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTable_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTable, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTable_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTable, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTable_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  FXTable_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getViewportHeight(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","getViewportHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)FXTable_getViewportHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getViewportWidth(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","getViewportWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)FXTable_getViewportWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getContentHeight(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","getContentHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)FXTable_getContentHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_getContentWidth(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","getContentWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (FXint)FXTable_getContentWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable const *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  result = (VALUE)FXTable_position__SWIG_1((FXTable const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXTable_position(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTable, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXTable_position__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTable, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXTable_position__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "position", 
+    "    void position(FXint x, FXint y, FXint w, FXint h)\n"
+    "    VALUE position()\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_drawCell(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXDC *arg2 = 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 5) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","drawCell", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXDC,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDC &","drawCell", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDC &","drawCell", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXDC * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  FXTable_drawCell(arg1,*arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_drawRange(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXDC *arg2 = 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 5) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","drawRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXDC,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDC &","drawRange", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDC &","drawRange", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXDC * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  FXTable_drawRange(arg1,*arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_drawHGrid(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXDC *arg2 = 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 5) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","drawHGrid", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXDC,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDC &","drawHGrid", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDC &","drawHGrid", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXDC * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  FXTable_drawHGrid(arg1,*arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_drawVGrid(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXDC *arg2 = 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 5) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","drawVGrid", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXDC,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDC &","drawVGrid", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDC &","drawVGrid", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXDC * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  FXTable_drawVGrid(arg1,*arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_drawContents(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXDC *arg2 = 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 5) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","drawContents", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXDC,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDC &","drawContents", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDC &","drawContents", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXDC * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  FXTable_drawContents(arg1,*arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_createItem(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  int res4 ;
+  FXTableItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","createItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","createItem", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXIcon * >(argp3);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","createItem", 4, argv[2] )); 
+  }
+  result = (FXTableItem *)FXTable_createItem(arg1,(FXString const &)*arg2,arg3,arg4);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTableItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setTableSize(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setTableSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  FXTable_setTableSize(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_insertRows(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 = (FXint) 1 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","insertRows", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  {
+    if (arg2 < 0 || arg2 > arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  FXTable_insertRows(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_insertColumns(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 = (FXint) 1 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","insertColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  {
+    if (arg2 < 0 || arg2 > arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  FXTable_insertColumns(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_removeRows(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 = (FXint) 1 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","removeRows", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  {
+    if (arg2 < 0 || arg2 + arg3 > arg1->getNumRows()) {
+      rb_raise(rb_eIndexError,"table row out of bounds");
+    }
+  }
+  FXTable_removeRows(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_removeColumns(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 = (FXint) 1 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","removeColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  {
+    if (arg2 < 0 || arg2 + arg3 > arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError,"table column out of bounds");
+    }
+  }
+  FXTable_removeColumns(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_extractItem(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTableItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","extractItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (FXTableItem *)FXTable_extractItem(arg1,arg2,arg3,arg4);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTableItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_removeItem(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","removeItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  FXTable_removeItem(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_removeRange(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXbool arg6 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","removeRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXbool(argv[4]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg4 < 0 || arg4 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  {
+    if (arg5 < 0 || arg5 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  FXTable_removeRange(arg1,arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_clearItems(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","clearItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXTable_clearItems(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setColumnWidth(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setColumnWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  FXTable_setColumnWidth(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setRowHeight(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setRowHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  FXTable_setRowHeight(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_setCurrentItem(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","setCurrentItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  FXTable_setCurrentItem(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_selectRow(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","selectRow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  result = (FXbool)FXTable_selectRow(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_selectColumn(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","selectColumn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (FXbool)FXTable_selectColumn(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_selectRange(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXbool arg6 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","selectRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  if (argc > 4) {
+    arg6 = to_FXbool(argv[4]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg4 < 0 || arg4 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  {
+    if (arg5 < 0 || arg5 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (FXbool)FXTable_selectRange(arg1,arg2,arg3,arg4,arg5,arg6);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_extendSelection(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","extendSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  result = (FXbool)FXTable_extendSelection(arg1,arg2,arg3,arg4);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_killSelection(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","killSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXTable_killSelection(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_startInput(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","startInput", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXTable_startInput(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_cancelInput(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","cancelInput", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  FXTable_cancelInput(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_acceptInput(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","acceptInput", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXTable_acceptInput(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_makePositionVisible(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","makePositionVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXTable_makePositionVisible(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_enableItem(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","enableItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (FXbool)FXTable_enableItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTable_disableItem(int argc, VALUE *argv, VALUE self) {
+  FXTable *arg1 = (FXTable *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTable, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTable *","disableItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTable * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumRows()) {
+      rb_raise(rb_eIndexError, "table row out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumColumns()) {
+      rb_raise(rb_eIndexError, "table column out of bounds");
+    }
+  }
+  result = (FXbool)FXTable_disableItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_FXGradientBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShutterItemTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXMatrixTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXDrawableTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXDrawable *) x));
+}
+static void *_p_FXHeaderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXSplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSpringTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXProgressBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXTableTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXTable *) x));
+}
+static void *_p_FXToolTipTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXDockSiteTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXCanvasTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXColorWheelTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXVisualTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXVisual *) x));
+}
+static void *_p_FXScrollBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXFontTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXFont *) x));
+}
+static void *_p_FXComboBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStatusBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXCursor *) x));
+}
+static void *_p_FXKnobTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRulerViewTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXStatusLineTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXMainWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXDockBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXToolBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDirBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXDocumentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDocument *) x));
+}
+static void *_p_FXGradientBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXRegistryTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *)(FXSettings *) ((FXRegistry *) x));
+}
+static void *_p_FXHeaderItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXHeaderItem *) x));
+}
+static void *_p_FXShutterItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTableItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXTableItem *) x));
+}
+static void *_p_FXTabBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXIconDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXIconDict *) x));
+}
+static void *_p_FXMatrixTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXFileDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXFileDict *) x));
+}
+static void *_p_FXRecentFilesTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXRecentFiles *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXDrawableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXDrawable *) x));
+}
+static void *_p_FXAppTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXApp *) x));
+}
+static void *_p_FXHeaderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXTranslatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXTranslator *) x));
+}
+static void *_p_FX4SplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FXSpringTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXIdTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXId *) x));
+}
+static void *_p_FXProgressBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXTableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXTable *) x));
+}
+static void *_p_FXToolTipTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXSettingsTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXSettings *) x));
+}
+static void *_p_FXDockSiteTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDebugTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDebugTarget *) x));
+}
+static void *_p_FXDataTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDataTarget *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXCanvasTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXListBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXColorWheelTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXVisualTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXVisual *) x));
+}
+static void *_p_FXScrollBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXFontTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXFont *) x));
+}
+static void *_p_FXComboBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStringDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXStringDict *) x));
+}
+static void *_p_FXStatusBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXDelegatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDelegator *) x));
+}
+static void *_p_FXAccelTableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXAccelTable *) x));
+}
+static void *_p_FXCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXKnobTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRulerViewTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXStatusLineTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXDockBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDict *) x));
+}
+static void *_p_FXShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXToolBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDirBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXScrollWindow *) x));
+}
+static void *_p_FXImageViewTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXImageView *) x));
+}
+static void *_p_FXRulerViewTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXRulerView *) x));
+}
+static void *_p_FXTableTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXTable *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXToolBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXCompositeTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXComposite *) x));
+}
+static void *_p_FXToolTipTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXTextFieldTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXTabBookTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXStatusBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXPopupTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXRulerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXCanvasTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXCanvas *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXScrollCorner *) x));
+}
+static void *_p_FXSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXStatusLineTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXComboBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXKnobTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FX4SplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FXPackerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXSpinnerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXScrollBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXScrollBar *) x));
+}
+static void *_p_FXColorWheelTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXGradientBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXDirBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXImageFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXDragCornerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXDragCorner *) x));
+}
+static void *_p_FXTableTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXTable *) x));
+}
+static void *_p_FXSwitcherTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXShutterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXProgressBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXDockSiteTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXDockTitleTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXRulerViewTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXListBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXHeaderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXMatrixTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXColorWellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXShutterItemTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXDialTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDockBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXFrame *) x));
+}
+static void *_p_FXTabBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FX7SegmentTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXImageViewTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXSliderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXRealSliderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSpringTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXColorRingTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXColorBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXToolBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolTipTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXTabBookTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXShell *) x));
+}
+static void *_p_FXStatusBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXScrollArea *) x));
+}
+static void *_p_FXPopupTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXComboBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FX4SplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXSplitter *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXPackerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXPacker *) x));
+}
+static void *_p_FXDirBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXTableTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXTable *) x));
+}
+static void *_p_FXSwitcherTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXShutterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXDockSiteTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXRulerViewTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXMatrixTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXShutterItemTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXDockBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXImageViewTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXSpringTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXToolBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXCompositeTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXToolTipTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXTextFieldTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXTabBookTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXStatusBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXPopupTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *)  ((FXWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXRulerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXCanvasTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXStatusLineTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXComboBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXKnobTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FX4SplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FXPackerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXSpinnerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXScrollBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXColorWheelTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXGradientBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXDirBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXImageFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXDragCornerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXTableTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXTable *) x));
+}
+static void *_p_FXSwitcherTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXShutterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXProgressBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXDockSiteTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXDockTitleTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXRulerViewTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXListBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXHeaderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXMatrixTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXColorWellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXShutterItemTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXDialTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDockBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FXTabBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FX7SegmentTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXImageViewTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXRealSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSpringTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXColorRingTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXColorBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXFileStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXFileStream *) x));
+}
+static void *_p_FXMemoryStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXMemoryStream *) x));
+}
+static void *_p_FXDCPrintTo_p_FXDC(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDC *)  ((FXDCPrint *) x));
+}
+static void *_p_FXDCWindowTo_p_FXDC(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDC *)  ((FXDCWindow *) x));
+}
+static swig_type_info _swigt__p_FXBitmap = {"_p_FXBitmap", "FXBitmap *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXButton = {"_p_FXButton", "FXButton *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXComposite = {"_p_FXComposite", "FXComposite *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDriveBox = {"_p_FXDriveBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBar = {"_p_FXToolBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolTip = {"_p_FXToolTip", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTabBook = {"_p_FXTabBook", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGroupBox = {"_p_FXGroupBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShell = {"_p_FXShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusBar = {"_p_FXStatusBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPopup = {"_p_FXPopup", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMainWindow = {"_p_FXMainWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTopWindow = {"_p_FXTopWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRootWindow = {"_p_FXRootWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplashWindow = {"_p_FXSplashWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollWindow = {"_p_FXScrollWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXComboBox = {"_p_FXComboBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalFrame = {"_p_FXHorizontalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalFrame = {"_p_FXVerticalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FX4Splitter = {"_p_FX4Splitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplitter = {"_p_FXSplitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRealSpinner = {"_p_FXRealSpinner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSpinner = {"_p_FXSpinner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPacker = {"_p_FXPacker", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDirBox = {"_p_FXDirBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSwitcher = {"_p_FXSwitcher", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDirSelector = {"_p_FXDirSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileSelector = {"_p_FXFileSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorSelector = {"_p_FXColorSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFontSelector = {"_p_FXFontSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutter = {"_p_FXShutter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockSite = {"_p_FXDockSite", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRulerView = {"_p_FXRulerView", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTreeListBox = {"_p_FXTreeListBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXListBox = {"_p_FXListBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMatrix = {"_p_FXMatrix", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutterItem = {"_p_FXShutterItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockBar = {"_p_FXDockBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTabBar = {"_p_FXTabBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImageView = {"_p_FXImageView", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSpring = {"_p_FXSpring", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarShell = {"_p_FXToolBarShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDC = {"_p_FXDC", "FXDC *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDCPrint = {"_p_FXDCPrint", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDCWindow = {"_p_FXDCWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDrawable = {"_p_FXDrawable", "FXDrawable *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGradientBar = {"_p_FXGradientBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorBar = {"_p_FXColorBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTextField = {"_p_FXTextField", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarTab = {"_p_FXToolBarTab", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollCorner = {"_p_FXScrollCorner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXArrowButton = {"_p_FXArrowButton", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImageFrame = {"_p_FXImageFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSeparator = {"_p_FXSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalSeparator = {"_p_FXHorizontalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalSeparator = {"_p_FXVerticalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXKnob = {"_p_FXKnob", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXProgressBar = {"_p_FXProgressBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXBitmapFrame = {"_p_FXBitmapFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSlider = {"_p_FXSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRealSlider = {"_p_FXRealSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorRing = {"_p_FXColorRing", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockHandler = {"_p_FXDockHandler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCanvas = {"_p_FXCanvas", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWheel = {"_p_FXColorWheel", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDial = {"_p_FXDial", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarGrip = {"_p_FXToolBarGrip", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollBar = {"_p_FXScrollBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFrame = {"_p_FXFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FX7Segment = {"_p_FX7Segment", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockTitle = {"_p_FXDockTitle", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusLine = {"_p_FXStatusLine", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWell = {"_p_FXColorWell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDragCorner = {"_p_FXDragCorner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRuler = {"_p_FXRuler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFont = {"_p_FXFont", "FXFont *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXHeader = {"_p_FXHeader", "FXHeader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXIcon = {"_p_FXIcon", "FXIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXId = {"_p_FXId", "FXId *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXVisual = {"_p_FXVisual", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCursor = {"_p_FXCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCURCursor = {"_p_FXCURCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGIFCursor = {"_p_FXGIFCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXObject = {"_p_FXObject", "FXObject *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDocument = {"_p_FXDocument", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRegistry = {"_p_FXRegistry", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHeaderItem = {"_p_FXHeaderItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXIconDict = {"_p_FXIconDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileDict = {"_p_FXFileDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRecentFiles = {"_p_FXRecentFiles", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTranslator = {"_p_FXTranslator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXApp = {"_p_FXApp", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDict = {"_p_FXDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSettings = {"_p_FXSettings", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDataTarget = {"_p_FXDataTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDebugTarget = {"_p_FXDebugTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStringDict = {"_p_FXStringDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDelegator = {"_p_FXDelegator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXAccelTable = {"_p_FXAccelTable", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRegion = {"_p_FXRegion", "FXRegion *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXScrollArea = {"_p_FXScrollArea", "FXScrollArea *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXStream = {"_p_FXStream", "FXStream *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFileStream = {"_p_FXFileStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMemoryStream = {"_p_FXMemoryStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTable = {"_p_FXTable", "FXTable *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXTableItem = {"_p_FXTableItem", "FXTableItem *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXTablePos = {"_p_FXTablePos", "FXTablePos *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXTableRange = {"_p_FXTableRange", "FXTableRange *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXWindow = {"_p_FXWindow", "FXWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_char = {"_p_char", "char *|FXchar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "double *|FXdouble *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_float = {"_p_float", "float *|FXfloat *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "FXint *|int *|FXInputHandle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_long = {"_p_long", "long *|FXTime *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_short = {"_p_short", "short *|FXshort *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "FXuchar *|unsigned char *|FXbool *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "FXwchar *|FXDragType *|unsigned int *|FXuint *|FXColor *|FXSelector *|FXHotKey *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|FXuval *|FXPixel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|FXushort *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_FX4Splitter,
+  &_swigt__p_FX7Segment,
+  &_swigt__p_FXAccelTable,
+  &_swigt__p_FXApp,
+  &_swigt__p_FXArrowButton,
+  &_swigt__p_FXBitmap,
+  &_swigt__p_FXBitmapFrame,
+  &_swigt__p_FXButton,
+  &_swigt__p_FXCURCursor,
+  &_swigt__p_FXCanvas,
+  &_swigt__p_FXColorBar,
+  &_swigt__p_FXColorRing,
+  &_swigt__p_FXColorSelector,
+  &_swigt__p_FXColorWell,
+  &_swigt__p_FXColorWheel,
+  &_swigt__p_FXComboBox,
+  &_swigt__p_FXComposite,
+  &_swigt__p_FXCursor,
+  &_swigt__p_FXDC,
+  &_swigt__p_FXDCPrint,
+  &_swigt__p_FXDCWindow,
+  &_swigt__p_FXDataTarget,
+  &_swigt__p_FXDebugTarget,
+  &_swigt__p_FXDelegator,
+  &_swigt__p_FXDial,
+  &_swigt__p_FXDict,
+  &_swigt__p_FXDirBox,
+  &_swigt__p_FXDirSelector,
+  &_swigt__p_FXDockBar,
+  &_swigt__p_FXDockHandler,
+  &_swigt__p_FXDockSite,
+  &_swigt__p_FXDockTitle,
+  &_swigt__p_FXDocument,
+  &_swigt__p_FXDragCorner,
+  &_swigt__p_FXDrawable,
+  &_swigt__p_FXDriveBox,
+  &_swigt__p_FXFileDict,
+  &_swigt__p_FXFileSelector,
+  &_swigt__p_FXFileStream,
+  &_swigt__p_FXFont,
+  &_swigt__p_FXFontSelector,
+  &_swigt__p_FXFrame,
+  &_swigt__p_FXGIFCursor,
+  &_swigt__p_FXGradientBar,
+  &_swigt__p_FXGroupBox,
+  &_swigt__p_FXHeader,
+  &_swigt__p_FXHeaderItem,
+  &_swigt__p_FXHorizontalFrame,
+  &_swigt__p_FXHorizontalSeparator,
+  &_swigt__p_FXIcon,
+  &_swigt__p_FXIconDict,
+  &_swigt__p_FXId,
+  &_swigt__p_FXImageFrame,
+  &_swigt__p_FXImageView,
+  &_swigt__p_FXKnob,
+  &_swigt__p_FXListBox,
+  &_swigt__p_FXMainWindow,
+  &_swigt__p_FXMatrix,
+  &_swigt__p_FXMemoryStream,
+  &_swigt__p_FXObject,
+  &_swigt__p_FXPacker,
+  &_swigt__p_FXPopup,
+  &_swigt__p_FXProgressBar,
+  &_swigt__p_FXRealSlider,
+  &_swigt__p_FXRealSpinner,
+  &_swigt__p_FXRecentFiles,
+  &_swigt__p_FXRegion,
+  &_swigt__p_FXRegistry,
+  &_swigt__p_FXRootWindow,
+  &_swigt__p_FXRuler,
+  &_swigt__p_FXRulerView,
+  &_swigt__p_FXScrollArea,
+  &_swigt__p_FXScrollBar,
+  &_swigt__p_FXScrollCorner,
+  &_swigt__p_FXScrollWindow,
+  &_swigt__p_FXSeparator,
+  &_swigt__p_FXSettings,
+  &_swigt__p_FXShell,
+  &_swigt__p_FXShutter,
+  &_swigt__p_FXShutterItem,
+  &_swigt__p_FXSlider,
+  &_swigt__p_FXSpinner,
+  &_swigt__p_FXSplashWindow,
+  &_swigt__p_FXSplitter,
+  &_swigt__p_FXSpring,
+  &_swigt__p_FXStatusBar,
+  &_swigt__p_FXStatusLine,
+  &_swigt__p_FXStream,
+  &_swigt__p_FXStringDict,
+  &_swigt__p_FXSwitcher,
+  &_swigt__p_FXTabBar,
+  &_swigt__p_FXTabBook,
+  &_swigt__p_FXTable,
+  &_swigt__p_FXTableItem,
+  &_swigt__p_FXTablePos,
+  &_swigt__p_FXTableRange,
+  &_swigt__p_FXTextField,
+  &_swigt__p_FXToolBar,
+  &_swigt__p_FXToolBarGrip,
+  &_swigt__p_FXToolBarShell,
+  &_swigt__p_FXToolBarTab,
+  &_swigt__p_FXToolTip,
+  &_swigt__p_FXTopWindow,
+  &_swigt__p_FXTranslator,
+  &_swigt__p_FXTreeListBox,
+  &_swigt__p_FXVerticalFrame,
+  &_swigt__p_FXVerticalSeparator,
+  &_swigt__p_FXVisual,
+  &_swigt__p_FXWindow,
+  &_swigt__p_char,
+  &_swigt__p_double,
+  &_swigt__p_float,
+  &_swigt__p_int,
+  &_swigt__p_long,
+  &_swigt__p_short,
+  &_swigt__p_unsigned_char,
+  &_swigt__p_unsigned_int,
+  &_swigt__p_unsigned_long,
+  &_swigt__p_unsigned_short,
+};
+
+static swig_cast_info _swigc__p_FXBitmap[] = {  {&_swigt__p_FXBitmap, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXButton[] = {  {&_swigt__p_FXButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDriveBox[] = {{&_swigt__p_FXDriveBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBar[] = {{&_swigt__p_FXToolBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolTip[] = {{&_swigt__p_FXToolTip, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabBook[] = {{&_swigt__p_FXTabBook, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGroupBox[] = {{&_swigt__p_FXGroupBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShell[] = {{&_swigt__p_FXShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusBar[] = {{&_swigt__p_FXStatusBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPopup[] = {{&_swigt__p_FXPopup, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMainWindow[] = {{&_swigt__p_FXMainWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTopWindow[] = {{&_swigt__p_FXTopWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRootWindow[] = {{&_swigt__p_FXRootWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplashWindow[] = {{&_swigt__p_FXSplashWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollWindow[] = {{&_swigt__p_FXScrollWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComboBox[] = {{&_swigt__p_FXComboBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalFrame[] = {{&_swigt__p_FXHorizontalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalFrame[] = {{&_swigt__p_FXVerticalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FX4Splitter[] = {{&_swigt__p_FX4Splitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplitter[] = {{&_swigt__p_FXSplitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSpinner[] = {{&_swigt__p_FXRealSpinner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpinner[] = {{&_swigt__p_FXSpinner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPacker[] = {{&_swigt__p_FXPacker, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirBox[] = {{&_swigt__p_FXDirBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSwitcher[] = {{&_swigt__p_FXSwitcher, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirSelector[] = {{&_swigt__p_FXDirSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileSelector[] = {{&_swigt__p_FXFileSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorSelector[] = {{&_swigt__p_FXColorSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFontSelector[] = {{&_swigt__p_FXFontSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutter[] = {{&_swigt__p_FXShutter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockSite[] = {{&_swigt__p_FXDockSite, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRulerView[] = {{&_swigt__p_FXRulerView, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTreeListBox[] = {{&_swigt__p_FXTreeListBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXListBox[] = {{&_swigt__p_FXListBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMatrix[] = {{&_swigt__p_FXMatrix, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutterItem[] = {{&_swigt__p_FXShutterItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockBar[] = {{&_swigt__p_FXDockBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabBar[] = {{&_swigt__p_FXTabBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageView[] = {{&_swigt__p_FXImageView, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpring[] = {{&_swigt__p_FXSpring, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarShell[] = {{&_swigt__p_FXToolBarShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComposite[] = {  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXComposite, 0, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXComposite, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXComposite, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTable, _p_FXTableTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXComposite, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXComposite, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDCPrint[] = {{&_swigt__p_FXDCPrint, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDCWindow[] = {{&_swigt__p_FXDCWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDC[] = {  {&_swigt__p_FXDCPrint, _p_FXDCPrintTo_p_FXDC, 0, 0},  {&_swigt__p_FXDC, 0, 0, 0},  {&_swigt__p_FXDCWindow, _p_FXDCWindowTo_p_FXDC, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGradientBar[] = {{&_swigt__p_FXGradientBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorBar[] = {{&_swigt__p_FXColorBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTextField[] = {{&_swigt__p_FXTextField, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarTab[] = {{&_swigt__p_FXToolBarTab, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollCorner[] = {{&_swigt__p_FXScrollCorner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXArrowButton[] = {{&_swigt__p_FXArrowButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageFrame[] = {{&_swigt__p_FXImageFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSeparator[] = {{&_swigt__p_FXSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalSeparator[] = {{&_swigt__p_FXHorizontalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalSeparator[] = {{&_swigt__p_FXVerticalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXKnob[] = {{&_swigt__p_FXKnob, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXProgressBar[] = {{&_swigt__p_FXProgressBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBitmapFrame[] = {{&_swigt__p_FXBitmapFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSlider[] = {{&_swigt__p_FXSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSlider[] = {{&_swigt__p_FXRealSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorRing[] = {{&_swigt__p_FXColorRing, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockHandler[] = {{&_swigt__p_FXDockHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCanvas[] = {{&_swigt__p_FXCanvas, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWheel[] = {{&_swigt__p_FXColorWheel, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDial[] = {{&_swigt__p_FXDial, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarGrip[] = {{&_swigt__p_FXToolBarGrip, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollBar[] = {{&_swigt__p_FXScrollBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFrame[] = {{&_swigt__p_FXFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FX7Segment[] = {{&_swigt__p_FX7Segment, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockTitle[] = {{&_swigt__p_FXDockTitle, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusLine[] = {{&_swigt__p_FXStatusLine, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWell[] = {{&_swigt__p_FXColorWell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDragCorner[] = {{&_swigt__p_FXDragCorner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRuler[] = {{&_swigt__p_FXRuler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDrawable[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDrawable, 0, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTable, _p_FXTableTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXDrawable, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFont[] = {  {&_swigt__p_FXFont, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeader[] = {  {&_swigt__p_FXHeader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIcon[] = {  {&_swigt__p_FXIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVisual[] = {{&_swigt__p_FXVisual, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCursor[] = {{&_swigt__p_FXCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCURCursor[] = {{&_swigt__p_FXCURCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGIFCursor[] = {{&_swigt__p_FXGIFCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXId[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXId, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXId, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXId, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXId, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXId, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXId, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXId, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXId, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXId, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXId, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXId, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXId, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXId, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXId, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXId, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXId, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXId, 0, 0},  {&_swigt__p_FXTable, _p_FXTableTo_p_FXId, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXId, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXId, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXId, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXId, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXId, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXId, 0, 0},  {&_swigt__p_FXId, 0, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXId, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXId, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXId, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXId, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXId, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXId, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXId, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXId, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXId, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXId, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXId, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXId, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXId, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXId, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDocument[] = {{&_swigt__p_FXDocument, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegistry[] = {{&_swigt__p_FXRegistry, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeaderItem[] = {{&_swigt__p_FXHeaderItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIconDict[] = {{&_swigt__p_FXIconDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileDict[] = {{&_swigt__p_FXFileDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRecentFiles[] = {{&_swigt__p_FXRecentFiles, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTranslator[] = {{&_swigt__p_FXTranslator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXApp[] = {{&_swigt__p_FXApp, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDict[] = {{&_swigt__p_FXDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSettings[] = {{&_swigt__p_FXSettings, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDataTarget[] = {{&_swigt__p_FXDataTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDebugTarget[] = {{&_swigt__p_FXDebugTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStringDict[] = {{&_swigt__p_FXStringDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDelegator[] = {{&_swigt__p_FXDelegator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXAccelTable[] = {{&_swigt__p_FXAccelTable, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXObject[] = {  {&_swigt__p_FXDocument, _p_FXDocumentTo_p_FXObject, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXRegistry, _p_FXRegistryTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeaderItem, _p_FXHeaderItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXTableItem, _p_FXTableItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXObject, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXObject, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXIconDict, _p_FXIconDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileDict, _p_FXFileDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXRecentFiles, _p_FXRecentFilesTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXObject, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXObject, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXObject, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXObject, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FXTranslator, _p_FXTranslatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXObject, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXObject, 0, 0},  {&_swigt__p_FXApp, _p_FXAppTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXObject, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXObject, 0, 0},  {&_swigt__p_FXTable, _p_FXTableTo_p_FXObject, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXObject, 0, 0},  {&_swigt__p_FXDict, _p_FXDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXSettings, _p_FXSettingsTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXObject, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXObject, 0, 0},  {&_swigt__p_FXDataTarget, _p_FXDataTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDebugTarget, _p_FXDebugTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXObject, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXObject, 0, 0},  {&_swigt__p_FXId, _p_FXIdTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXObject, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXObject, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXStringDict, _p_FXStringDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXDelegator, _p_FXDelegatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXAccelTable, _p_FXAccelTableTo_p_FXObject, 0, 0},  {&_swigt__p_FXObject, 0, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXObject, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXObject, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXObject, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXObject, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXObject, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegion[] = {  {&_swigt__p_FXRegion, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollArea[] = {  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXScrollArea, 0, 0},  {&_swigt__p_FXScrollArea, 0, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXScrollArea, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXScrollArea, 0, 0},  {&_swigt__p_FXTable, _p_FXTableTo_p_FXScrollArea, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileStream[] = {{&_swigt__p_FXFileStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMemoryStream[] = {{&_swigt__p_FXMemoryStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStream[] = {  {&_swigt__p_FXFileStream, _p_FXFileStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXMemoryStream, _p_FXMemoryStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTable[] = {  {&_swigt__p_FXTable, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTableItem[] = {  {&_swigt__p_FXTableItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTablePos[] = {  {&_swigt__p_FXTablePos, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTableRange[] = {  {&_swigt__p_FXTableRange, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXWindow[] = {  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXWindow, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXWindow, 0, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXWindow, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXWindow, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTable, _p_FXTableTo_p_FXWindow, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXWindow, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXWindow, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXWindow, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
+
+static swig_cast_info *swig_cast_initial[] = {
+  _swigc__p_FX4Splitter,
+  _swigc__p_FX7Segment,
+  _swigc__p_FXAccelTable,
+  _swigc__p_FXApp,
+  _swigc__p_FXArrowButton,
+  _swigc__p_FXBitmap,
+  _swigc__p_FXBitmapFrame,
+  _swigc__p_FXButton,
+  _swigc__p_FXCURCursor,
+  _swigc__p_FXCanvas,
+  _swigc__p_FXColorBar,
+  _swigc__p_FXColorRing,
+  _swigc__p_FXColorSelector,
+  _swigc__p_FXColorWell,
+  _swigc__p_FXColorWheel,
+  _swigc__p_FXComboBox,
+  _swigc__p_FXComposite,
+  _swigc__p_FXCursor,
+  _swigc__p_FXDC,
+  _swigc__p_FXDCPrint,
+  _swigc__p_FXDCWindow,
+  _swigc__p_FXDataTarget,
+  _swigc__p_FXDebugTarget,
+  _swigc__p_FXDelegator,
+  _swigc__p_FXDial,
+  _swigc__p_FXDict,
+  _swigc__p_FXDirBox,
+  _swigc__p_FXDirSelector,
+  _swigc__p_FXDockBar,
+  _swigc__p_FXDockHandler,
+  _swigc__p_FXDockSite,
+  _swigc__p_FXDockTitle,
+  _swigc__p_FXDocument,
+  _swigc__p_FXDragCorner,
+  _swigc__p_FXDrawable,
+  _swigc__p_FXDriveBox,
+  _swigc__p_FXFileDict,
+  _swigc__p_FXFileSelector,
+  _swigc__p_FXFileStream,
+  _swigc__p_FXFont,
+  _swigc__p_FXFontSelector,
+  _swigc__p_FXFrame,
+  _swigc__p_FXGIFCursor,
+  _swigc__p_FXGradientBar,
+  _swigc__p_FXGroupBox,
+  _swigc__p_FXHeader,
+  _swigc__p_FXHeaderItem,
+  _swigc__p_FXHorizontalFrame,
+  _swigc__p_FXHorizontalSeparator,
+  _swigc__p_FXIcon,
+  _swigc__p_FXIconDict,
+  _swigc__p_FXId,
+  _swigc__p_FXImageFrame,
+  _swigc__p_FXImageView,
+  _swigc__p_FXKnob,
+  _swigc__p_FXListBox,
+  _swigc__p_FXMainWindow,
+  _swigc__p_FXMatrix,
+  _swigc__p_FXMemoryStream,
+  _swigc__p_FXObject,
+  _swigc__p_FXPacker,
+  _swigc__p_FXPopup,
+  _swigc__p_FXProgressBar,
+  _swigc__p_FXRealSlider,
+  _swigc__p_FXRealSpinner,
+  _swigc__p_FXRecentFiles,
+  _swigc__p_FXRegion,
+  _swigc__p_FXRegistry,
+  _swigc__p_FXRootWindow,
+  _swigc__p_FXRuler,
+  _swigc__p_FXRulerView,
+  _swigc__p_FXScrollArea,
+  _swigc__p_FXScrollBar,
+  _swigc__p_FXScrollCorner,
+  _swigc__p_FXScrollWindow,
+  _swigc__p_FXSeparator,
+  _swigc__p_FXSettings,
+  _swigc__p_FXShell,
+  _swigc__p_FXShutter,
+  _swigc__p_FXShutterItem,
+  _swigc__p_FXSlider,
+  _swigc__p_FXSpinner,
+  _swigc__p_FXSplashWindow,
+  _swigc__p_FXSplitter,
+  _swigc__p_FXSpring,
+  _swigc__p_FXStatusBar,
+  _swigc__p_FXStatusLine,
+  _swigc__p_FXStream,
+  _swigc__p_FXStringDict,
+  _swigc__p_FXSwitcher,
+  _swigc__p_FXTabBar,
+  _swigc__p_FXTabBook,
+  _swigc__p_FXTable,
+  _swigc__p_FXTableItem,
+  _swigc__p_FXTablePos,
+  _swigc__p_FXTableRange,
+  _swigc__p_FXTextField,
+  _swigc__p_FXToolBar,
+  _swigc__p_FXToolBarGrip,
+  _swigc__p_FXToolBarShell,
+  _swigc__p_FXToolBarTab,
+  _swigc__p_FXToolTip,
+  _swigc__p_FXTopWindow,
+  _swigc__p_FXTranslator,
+  _swigc__p_FXTreeListBox,
+  _swigc__p_FXVerticalFrame,
+  _swigc__p_FXVerticalSeparator,
+  _swigc__p_FXVisual,
+  _swigc__p_FXWindow,
+  _swigc__p_char,
+  _swigc__p_double,
+  _swigc__p_float,
+  _swigc__p_int,
+  _swigc__p_long,
+  _swigc__p_short,
+  _swigc__p_unsigned_char,
+  _swigc__p_unsigned_int,
+  _swigc__p_unsigned_long,
+  _swigc__p_unsigned_short,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned statically to an initial
+ * array. We just loop through that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded.
+ * There are three cases to handle:
+ *  1) If the cast->type has already been loaded AND the type we are adding
+ *     casting info to has not been loaded (it is in this module), THEN we
+ *     replace the cast->type pointer with the type pointer that has already
+ *     been loaded.
+ *  2) If BOTH types (the one we are adding casting info to, and the
+ *     cast->type) are loaded, THEN the cast info has already been loaded by
+ *     the previous module so we just ignore it.
+ *  3) Finally, if cast->type has not already been loaded, then we add that
+ *     swig_cast_info to the linked list (because the cast->type) pointer will
+ *     be correct.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* c-mode */
+#endif
+#endif
+
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+  size_t i;
+  swig_module_info *module_head, *iter;
+  int init;
+
+  /* check to see if the circular list has been setup, if not, set it up */
+  if (swig_module.next==0) {
+    /* Initialize the swig_module */
+    swig_module.type_initial = swig_type_initial;
+    swig_module.cast_initial = swig_cast_initial;
+    swig_module.next = &swig_module;
+    init = 1;
+  } else {
+    init = 0;
+  }
+
+  /* Try and load any already created modules */
+  module_head = SWIG_GetModule(clientdata);
+  if (!module_head) {
+    /* This is the first module loaded for this interpreter */
+    /* so set the swig module into the interpreter */
+    SWIG_SetModule(clientdata, &swig_module);
+  } else {
+    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+    iter=module_head;
+    do {
+      if (iter==&swig_module) {
+        /* Our module is already in the list, so there's nothing more to do. */
+        return;
+      }
+      iter=iter->next;
+    } while (iter!= module_head);
+
+    /* otherwise we must add our module into the list */
+    swig_module.next = module_head->next;
+    module_head->next = &swig_module;
+  }
+
+  /* When multiple interpreters are used, a module could have already been initialized in
+     a different interpreter, but not yet have a pointer in this interpreter.
+     In this case, we do not want to continue adding types... everything should be
+     set up already */
+  if (init == 0) return;
+
+  /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+  for (i = 0; i < swig_module.size; ++i) {
+    swig_type_info *type = 0;
+    swig_type_info *ret;
+    swig_cast_info *cast;
+
+#ifdef SWIGRUNTIME_DEBUG
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+
+    /* if there is another module already loaded */
+    if (swig_module.next != &swig_module) {
+      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
+    }
+    if (type) {
+      /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+      if (swig_module.type_initial[i]->clientdata) {
+	type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+      }
+    } else {
+      type = swig_module.type_initial[i];
+    }
+
+    /* Insert casting types */
+    cast = swig_module.cast_initial[i];
+    while (cast->type) {
+
+      /* Don't need to add information already in the list */
+      ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+      if (swig_module.next != &swig_module) {
+        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+      }
+      if (ret) {
+	if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+	  cast->type = ret;
+	  ret = 0;
+	} else {
+	  /* Check for casting already in the list */
+	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+	  if (!ocast) ret = 0;
+	}
+      }
+
+      if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+        if (type->cast) {
+          type->cast->prev = cast;
+          cast->next = type->cast;
+        }
+        type->cast = cast;
+      }
+      cast++;
+    }
+    /* Set entry in modules->types array equal to the type */
+    swig_module.types[i] = type;
+  }
+  swig_module.types[i] = 0;
+
+#ifdef SWIGRUNTIME_DEBUG
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+  for (i = 0; i < swig_module.size; ++i) {
+    int j = 0;
+    swig_cast_info *cast = swig_module.cast_initial[i];
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    while (cast->type) {
+      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+      cast++;
+      ++j;
+    }
+  printf("---- Total casts: %d\n",j);
+  }
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types.  It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+  size_t i;
+  swig_cast_info *equiv;
+  static int init_run = 0;
+
+  if (init_run) return;
+  init_run = 1;
+
+  for (i = 0; i < swig_module.size; i++) {
+    if (swig_module.types[i]->clientdata) {
+      equiv = swig_module.types[i]->cast;
+      while (equiv) {
+        if (!equiv->converter) {
+          if (equiv->type && !equiv->type->clientdata)
+            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+        }
+        equiv = equiv->next;
+      }
+    }
+  }
+}
+
+#ifdef __cplusplus
+#if 0
+{ /* c-mode */
+#endif
+}
+#endif
+
+/*
+
+*/
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void Init_table(void) {
+  size_t i;
+  
+  SWIG_InitRuntime();
+  
+  
+  SWIG_InitializeModule(0);
+  for (i = 0; i < swig_module.size; i++) {
+    SWIG_define_class(swig_module.types[i]);
+  }
+  
+  SWIG_RubyInitializeTrackings();
+  
+  
+  
+  
+  
+  rb_define_const(mFox, "DEFAULT_MARGIN", SWIG_From_int(static_cast< int >(DEFAULT_MARGIN)));
+  rb_define_const(mFox, "TABLE_COL_SIZABLE", SWIG_From_int(static_cast< int >(TABLE_COL_SIZABLE)));
+  rb_define_const(mFox, "TABLE_ROW_SIZABLE", SWIG_From_int(static_cast< int >(TABLE_ROW_SIZABLE)));
+  rb_define_const(mFox, "TABLE_NO_COLSELECT", SWIG_From_int(static_cast< int >(TABLE_NO_COLSELECT)));
+  rb_define_const(mFox, "TABLE_NO_ROWSELECT", SWIG_From_int(static_cast< int >(TABLE_NO_ROWSELECT)));
+  rb_define_const(mFox, "TABLE_READONLY", SWIG_From_int(static_cast< int >(TABLE_READONLY)));
+  rb_define_const(mFox, "TABLE_COL_RENUMBER", SWIG_From_int(static_cast< int >(TABLE_COL_RENUMBER)));
+  rb_define_const(mFox, "TABLE_ROW_RENUMBER", SWIG_From_int(static_cast< int >(TABLE_ROW_RENUMBER)));
+  
+  SwigClassFXTablePos.klass = rb_define_class_under(mFox, "FXTablePos", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXTablePos, (void *) &SwigClassFXTablePos);
+  rb_define_alloc_func(SwigClassFXTablePos.klass, _wrap_FXTablePos_allocate);
+  rb_define_method(SwigClassFXTablePos.klass, "initialize", VALUEFUNC(_wrap_new_FXTablePos), -1);
+  rb_define_method(SwigClassFXTablePos.klass, "row=", VALUEFUNC(_wrap_FXTablePos_row_set), -1);
+  rb_define_method(SwigClassFXTablePos.klass, "row", VALUEFUNC(_wrap_FXTablePos_row_get), -1);
+  rb_define_method(SwigClassFXTablePos.klass, "col=", VALUEFUNC(_wrap_FXTablePos_col_set), -1);
+  rb_define_method(SwigClassFXTablePos.klass, "col", VALUEFUNC(_wrap_FXTablePos_col_get), -1);
+  SwigClassFXTablePos.mark = 0;
+  SwigClassFXTablePos.destroy = (void (*)(void *)) free_FXTablePos;
+  SwigClassFXTablePos.trackObjects = 0;
+  
+  SwigClassFXTableRange.klass = rb_define_class_under(mFox, "FXTableRange", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXTableRange, (void *) &SwigClassFXTableRange);
+  rb_define_alloc_func(SwigClassFXTableRange.klass, _wrap_FXTableRange_allocate);
+  rb_define_method(SwigClassFXTableRange.klass, "initialize", VALUEFUNC(_wrap_new_FXTableRange), -1);
+  rb_define_method(SwigClassFXTableRange.klass, "fm=", VALUEFUNC(_wrap_FXTableRange_fm_set), -1);
+  rb_define_method(SwigClassFXTableRange.klass, "fm", VALUEFUNC(_wrap_FXTableRange_fm_get), -1);
+  rb_define_method(SwigClassFXTableRange.klass, "to=", VALUEFUNC(_wrap_FXTableRange_to_set), -1);
+  rb_define_method(SwigClassFXTableRange.klass, "to", VALUEFUNC(_wrap_FXTableRange_to_get), -1);
+  SwigClassFXTableRange.mark = 0;
+  SwigClassFXTableRange.destroy = (void (*)(void *)) free_FXTableRange;
+  SwigClassFXTableRange.trackObjects = 0;
+  
+  SwigClassFXTableItem.klass = rb_define_class_under(mFox, "FXTableItem", ((swig_class *) SWIGTYPE_p_FXObject->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXTableItem, (void *) &SwigClassFXTableItem);
+  rb_define_alloc_func(SwigClassFXTableItem.klass, _wrap_FXTableItem_allocate);
+  rb_define_method(SwigClassFXTableItem.klass, "initialize", VALUEFUNC(_wrap_new_FXTableItem), -1);
+  rb_define_const(SwigClassFXTableItem.klass, "SELECTED", SWIG_From_int(static_cast< int >(FXTableItem::SELECTED)));
+  rb_define_const(SwigClassFXTableItem.klass, "FOCUS", SWIG_From_int(static_cast< int >(FXTableItem::FOCUS)));
+  rb_define_const(SwigClassFXTableItem.klass, "DISABLED", SWIG_From_int(static_cast< int >(FXTableItem::DISABLED)));
+  rb_define_const(SwigClassFXTableItem.klass, "DRAGGABLE", SWIG_From_int(static_cast< int >(FXTableItem::DRAGGABLE)));
+  rb_define_const(SwigClassFXTableItem.klass, "RESERVED1", SWIG_From_int(static_cast< int >(FXTableItem::RESERVED1)));
+  rb_define_const(SwigClassFXTableItem.klass, "RESERVED2", SWIG_From_int(static_cast< int >(FXTableItem::RESERVED2)));
+  rb_define_const(SwigClassFXTableItem.klass, "ICONOWNED", SWIG_From_int(static_cast< int >(FXTableItem::ICONOWNED)));
+  rb_define_const(SwigClassFXTableItem.klass, "RIGHT", SWIG_From_int(static_cast< int >(FXTableItem::RIGHT)));
+  rb_define_const(SwigClassFXTableItem.klass, "LEFT", SWIG_From_int(static_cast< int >(FXTableItem::LEFT)));
+  rb_define_const(SwigClassFXTableItem.klass, "CENTER_X", SWIG_From_int(static_cast< int >(FXTableItem::CENTER_X)));
+  rb_define_const(SwigClassFXTableItem.klass, "TOP", SWIG_From_int(static_cast< int >(FXTableItem::TOP)));
+  rb_define_const(SwigClassFXTableItem.klass, "BOTTOM", SWIG_From_int(static_cast< int >(FXTableItem::BOTTOM)));
+  rb_define_const(SwigClassFXTableItem.klass, "CENTER_Y", SWIG_From_int(static_cast< int >(FXTableItem::CENTER_Y)));
+  rb_define_const(SwigClassFXTableItem.klass, "BEFORE", SWIG_From_int(static_cast< int >(FXTableItem::BEFORE)));
+  rb_define_const(SwigClassFXTableItem.klass, "AFTER", SWIG_From_int(static_cast< int >(FXTableItem::AFTER)));
+  rb_define_const(SwigClassFXTableItem.klass, "ABOVE", SWIG_From_int(static_cast< int >(FXTableItem::ABOVE)));
+  rb_define_const(SwigClassFXTableItem.klass, "BELOW", SWIG_From_int(static_cast< int >(FXTableItem::BELOW)));
+  rb_define_const(SwigClassFXTableItem.klass, "LBORDER", SWIG_From_int(static_cast< int >(FXTableItem::LBORDER)));
+  rb_define_const(SwigClassFXTableItem.klass, "RBORDER", SWIG_From_int(static_cast< int >(FXTableItem::RBORDER)));
+  rb_define_const(SwigClassFXTableItem.klass, "TBORDER", SWIG_From_int(static_cast< int >(FXTableItem::TBORDER)));
+  rb_define_const(SwigClassFXTableItem.klass, "BBORDER", SWIG_From_int(static_cast< int >(FXTableItem::BBORDER)));
+  rb_define_method(SwigClassFXTableItem.klass, "setData", VALUEFUNC(_wrap_FXTableItem_setData), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "getData", VALUEFUNC(_wrap_FXTableItem_getData), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "hasFocus", VALUEFUNC(_wrap_FXTableItem_hasFocus), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "isSelected", VALUEFUNC(_wrap_FXTableItem_isSelected), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "isEnabled", VALUEFUNC(_wrap_FXTableItem_isEnabled), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "isDraggable", VALUEFUNC(_wrap_FXTableItem_isDraggable), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "getJustify", VALUEFUNC(_wrap_FXTableItem_getJustify), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "getIconPosition", VALUEFUNC(_wrap_FXTableItem_getIconPosition), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "getBorders", VALUEFUNC(_wrap_FXTableItem_getBorders), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "getStipple", VALUEFUNC(_wrap_FXTableItem_getStipple), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "save", VALUEFUNC(_wrap_FXTableItem_save), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "load", VALUEFUNC(_wrap_FXTableItem_load), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "draw", VALUEFUNC(_wrap_FXTableItem_draw), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "drawBorders", VALUEFUNC(_wrap_FXTableItem_drawBorders), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "drawContent", VALUEFUNC(_wrap_FXTableItem_drawContent), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "drawPattern", VALUEFUNC(_wrap_FXTableItem_drawPattern), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "drawBackground", VALUEFUNC(_wrap_FXTableItem_drawBackground), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "setText", VALUEFUNC(_wrap_FXTableItem_setText), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "getText", VALUEFUNC(_wrap_FXTableItem_getText), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "setIcon", VALUEFUNC(_wrap_FXTableItem_setIcon), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "getIcon", VALUEFUNC(_wrap_FXTableItem_getIcon), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "setFocus", VALUEFUNC(_wrap_FXTableItem_setFocus), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "setSelected", VALUEFUNC(_wrap_FXTableItem_setSelected), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "setEnabled", VALUEFUNC(_wrap_FXTableItem_setEnabled), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "setDraggable", VALUEFUNC(_wrap_FXTableItem_setDraggable), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "setJustify", VALUEFUNC(_wrap_FXTableItem_setJustify), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "setIconPosition", VALUEFUNC(_wrap_FXTableItem_setIconPosition), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "setBorders", VALUEFUNC(_wrap_FXTableItem_setBorders), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "setStipple", VALUEFUNC(_wrap_FXTableItem_setStipple), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "getControlFor", VALUEFUNC(_wrap_FXTableItem_getControlFor), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "setFromControl", VALUEFUNC(_wrap_FXTableItem_setFromControl), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "getWidth", VALUEFUNC(_wrap_FXTableItem_getWidth), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "getHeight", VALUEFUNC(_wrap_FXTableItem_getHeight), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "create", VALUEFUNC(_wrap_FXTableItem_create), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "detach", VALUEFUNC(_wrap_FXTableItem_detach), -1);
+  rb_define_method(SwigClassFXTableItem.klass, "destroy", VALUEFUNC(_wrap_FXTableItem_destroy), -1);
+  SwigClassFXTableItem.mark = (void (*)(void *)) FXRbTableItem::markfunc;
+  SwigClassFXTableItem.destroy = (void (*)(void *)) FXRbTableItem::freefunc;
+  SwigClassFXTableItem.trackObjects = 0;
+  
+  SwigClassFXTable.klass = rb_define_class_under(mFox, "FXTable", ((swig_class *) SWIGTYPE_p_FXScrollArea->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXTable, (void *) &SwigClassFXTable);
+  rb_define_alloc_func(SwigClassFXTable.klass, _wrap_FXTable_allocate);
+  rb_define_method(SwigClassFXTable.klass, "initialize", VALUEFUNC(_wrap_new_FXTable), -1);
+  rb_define_singleton_method(SwigClassFXTable.klass, "csvType", VALUEFUNC(_wrap_FXTable_csvType_get), 0);
+  rb_define_singleton_method(SwigClassFXTable.klass, "csvType=", VALUEFUNC(_wrap_FXTable_csvType_set), 1);
+  rb_define_singleton_method(SwigClassFXTable.klass, "csvTypeName", VALUEFUNC(_wrap_FXTable_csvTypeName_get), 0);
+  rb_define_method(SwigClassFXTable.klass, "onPaint", VALUEFUNC(_wrap_FXTable_onPaint), -1);
+  rb_define_method(SwigClassFXTable.klass, "onFocusIn", VALUEFUNC(_wrap_FXTable_onFocusIn), -1);
+  rb_define_method(SwigClassFXTable.klass, "onFocusOut", VALUEFUNC(_wrap_FXTable_onFocusOut), -1);
+  rb_define_method(SwigClassFXTable.klass, "onMotion", VALUEFUNC(_wrap_FXTable_onMotion), -1);
+  rb_define_method(SwigClassFXTable.klass, "onKeyPress", VALUEFUNC(_wrap_FXTable_onKeyPress), -1);
+  rb_define_method(SwigClassFXTable.klass, "onKeyRelease", VALUEFUNC(_wrap_FXTable_onKeyRelease), -1);
+  rb_define_method(SwigClassFXTable.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXTable_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXTable.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXTable_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXTable.klass, "onRightBtnPress", VALUEFUNC(_wrap_FXTable_onRightBtnPress), -1);
+  rb_define_method(SwigClassFXTable.klass, "onRightBtnRelease", VALUEFUNC(_wrap_FXTable_onRightBtnRelease), -1);
+  rb_define_method(SwigClassFXTable.klass, "onUngrabbed", VALUEFUNC(_wrap_FXTable_onUngrabbed), -1);
+  rb_define_method(SwigClassFXTable.klass, "onSelectionLost", VALUEFUNC(_wrap_FXTable_onSelectionLost), -1);
+  rb_define_method(SwigClassFXTable.klass, "onSelectionGained", VALUEFUNC(_wrap_FXTable_onSelectionGained), -1);
+  rb_define_method(SwigClassFXTable.klass, "onSelectionRequest", VALUEFUNC(_wrap_FXTable_onSelectionRequest), -1);
+  rb_define_method(SwigClassFXTable.klass, "onClipboardLost", VALUEFUNC(_wrap_FXTable_onClipboardLost), -1);
+  rb_define_method(SwigClassFXTable.klass, "onClipboardGained", VALUEFUNC(_wrap_FXTable_onClipboardGained), -1);
+  rb_define_method(SwigClassFXTable.klass, "onClipboardRequest", VALUEFUNC(_wrap_FXTable_onClipboardRequest), -1);
+  rb_define_method(SwigClassFXTable.klass, "onAutoScroll", VALUEFUNC(_wrap_FXTable_onAutoScroll), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCommand", VALUEFUNC(_wrap_FXTable_onCommand), -1);
+  rb_define_method(SwigClassFXTable.klass, "onClicked", VALUEFUNC(_wrap_FXTable_onClicked), -1);
+  rb_define_method(SwigClassFXTable.klass, "onDoubleClicked", VALUEFUNC(_wrap_FXTable_onDoubleClicked), -1);
+  rb_define_method(SwigClassFXTable.klass, "onTripleClicked", VALUEFUNC(_wrap_FXTable_onTripleClicked), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdToggleEditable", VALUEFUNC(_wrap_FXTable_onCmdToggleEditable), -1);
+  rb_define_method(SwigClassFXTable.klass, "onUpdToggleEditable", VALUEFUNC(_wrap_FXTable_onUpdToggleEditable), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdHorzGrid", VALUEFUNC(_wrap_FXTable_onCmdHorzGrid), -1);
+  rb_define_method(SwigClassFXTable.klass, "onUpdHorzGrid", VALUEFUNC(_wrap_FXTable_onUpdHorzGrid), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdVertGrid", VALUEFUNC(_wrap_FXTable_onCmdVertGrid), -1);
+  rb_define_method(SwigClassFXTable.klass, "onUpdVertGrid", VALUEFUNC(_wrap_FXTable_onUpdVertGrid), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdDeleteColumn", VALUEFUNC(_wrap_FXTable_onCmdDeleteColumn), -1);
+  rb_define_method(SwigClassFXTable.klass, "onUpdDeleteColumn", VALUEFUNC(_wrap_FXTable_onUpdDeleteColumn), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdDeleteRow", VALUEFUNC(_wrap_FXTable_onCmdDeleteRow), -1);
+  rb_define_method(SwigClassFXTable.klass, "onUpdDeleteRow", VALUEFUNC(_wrap_FXTable_onUpdDeleteRow), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdInsertColumn", VALUEFUNC(_wrap_FXTable_onCmdInsertColumn), -1);
+  rb_define_method(SwigClassFXTable.klass, "onUpdInsertColumn", VALUEFUNC(_wrap_FXTable_onUpdInsertColumn), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdInsertRow", VALUEFUNC(_wrap_FXTable_onCmdInsertRow), -1);
+  rb_define_method(SwigClassFXTable.klass, "onUpdInsertRow", VALUEFUNC(_wrap_FXTable_onUpdInsertRow), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdMoveRight", VALUEFUNC(_wrap_FXTable_onCmdMoveRight), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdMoveLeft", VALUEFUNC(_wrap_FXTable_onCmdMoveLeft), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdMoveUp", VALUEFUNC(_wrap_FXTable_onCmdMoveUp), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdMoveDown", VALUEFUNC(_wrap_FXTable_onCmdMoveDown), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdMoveHome", VALUEFUNC(_wrap_FXTable_onCmdMoveHome), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdMoveEnd", VALUEFUNC(_wrap_FXTable_onCmdMoveEnd), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdMoveTop", VALUEFUNC(_wrap_FXTable_onCmdMoveTop), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdMoveBottom", VALUEFUNC(_wrap_FXTable_onCmdMoveBottom), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdMovePageDown", VALUEFUNC(_wrap_FXTable_onCmdMovePageDown), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdMovePageUp", VALUEFUNC(_wrap_FXTable_onCmdMovePageUp), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdMark", VALUEFUNC(_wrap_FXTable_onCmdMark), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdExtend", VALUEFUNC(_wrap_FXTable_onCmdExtend), -1);
+  rb_define_method(SwigClassFXTable.klass, "onUpdSelectCell", VALUEFUNC(_wrap_FXTable_onUpdSelectCell), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdSelectCell", VALUEFUNC(_wrap_FXTable_onCmdSelectCell), -1);
+  rb_define_method(SwigClassFXTable.klass, "onUpdSelectRow", VALUEFUNC(_wrap_FXTable_onUpdSelectRow), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdSelectRow", VALUEFUNC(_wrap_FXTable_onCmdSelectRow), -1);
+  rb_define_method(SwigClassFXTable.klass, "onUpdSelectColumn", VALUEFUNC(_wrap_FXTable_onUpdSelectColumn), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdSelectColumn", VALUEFUNC(_wrap_FXTable_onCmdSelectColumn), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdSelectRowIndex", VALUEFUNC(_wrap_FXTable_onCmdSelectRowIndex), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdSelectColumnIndex", VALUEFUNC(_wrap_FXTable_onCmdSelectColumnIndex), -1);
+  rb_define_method(SwigClassFXTable.klass, "onUpdSelectAll", VALUEFUNC(_wrap_FXTable_onUpdSelectAll), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdSelectAll", VALUEFUNC(_wrap_FXTable_onCmdSelectAll), -1);
+  rb_define_method(SwigClassFXTable.klass, "onUpdDeselectAll", VALUEFUNC(_wrap_FXTable_onUpdDeselectAll), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdDeselectAll", VALUEFUNC(_wrap_FXTable_onCmdDeselectAll), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdCutSel", VALUEFUNC(_wrap_FXTable_onCmdCutSel), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdCopySel", VALUEFUNC(_wrap_FXTable_onCmdCopySel), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdDeleteSel", VALUEFUNC(_wrap_FXTable_onCmdDeleteSel), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdPasteSel", VALUEFUNC(_wrap_FXTable_onCmdPasteSel), -1);
+  rb_define_method(SwigClassFXTable.klass, "onUpdHaveSelection", VALUEFUNC(_wrap_FXTable_onUpdHaveSelection), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdStartInput", VALUEFUNC(_wrap_FXTable_onCmdStartInput), -1);
+  rb_define_method(SwigClassFXTable.klass, "onUpdStartInput", VALUEFUNC(_wrap_FXTable_onUpdStartInput), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdAcceptInput", VALUEFUNC(_wrap_FXTable_onCmdAcceptInput), -1);
+  rb_define_method(SwigClassFXTable.klass, "onUpdAcceptInput", VALUEFUNC(_wrap_FXTable_onUpdAcceptInput), -1);
+  rb_define_method(SwigClassFXTable.klass, "onCmdCancelInput", VALUEFUNC(_wrap_FXTable_onCmdCancelInput), -1);
+  rb_define_const(SwigClassFXTable.klass, "ID_HORZ_GRID", SWIG_From_int(static_cast< int >(FXTable::ID_HORZ_GRID)));
+  rb_define_const(SwigClassFXTable.klass, "ID_VERT_GRID", SWIG_From_int(static_cast< int >(FXTable::ID_VERT_GRID)));
+  rb_define_const(SwigClassFXTable.klass, "ID_TOGGLE_EDITABLE", SWIG_From_int(static_cast< int >(FXTable::ID_TOGGLE_EDITABLE)));
+  rb_define_const(SwigClassFXTable.klass, "ID_DELETE_COLUMN", SWIG_From_int(static_cast< int >(FXTable::ID_DELETE_COLUMN)));
+  rb_define_const(SwigClassFXTable.klass, "ID_DELETE_ROW", SWIG_From_int(static_cast< int >(FXTable::ID_DELETE_ROW)));
+  rb_define_const(SwigClassFXTable.klass, "ID_INSERT_COLUMN", SWIG_From_int(static_cast< int >(FXTable::ID_INSERT_COLUMN)));
+  rb_define_const(SwigClassFXTable.klass, "ID_INSERT_ROW", SWIG_From_int(static_cast< int >(FXTable::ID_INSERT_ROW)));
+  rb_define_const(SwigClassFXTable.klass, "ID_SELECT_COLUMN_INDEX", SWIG_From_int(static_cast< int >(FXTable::ID_SELECT_COLUMN_INDEX)));
+  rb_define_const(SwigClassFXTable.klass, "ID_SELECT_ROW_INDEX", SWIG_From_int(static_cast< int >(FXTable::ID_SELECT_ROW_INDEX)));
+  rb_define_const(SwigClassFXTable.klass, "ID_SELECT_COLUMN", SWIG_From_int(static_cast< int >(FXTable::ID_SELECT_COLUMN)));
+  rb_define_const(SwigClassFXTable.klass, "ID_SELECT_ROW", SWIG_From_int(static_cast< int >(FXTable::ID_SELECT_ROW)));
+  rb_define_const(SwigClassFXTable.klass, "ID_SELECT_CELL", SWIG_From_int(static_cast< int >(FXTable::ID_SELECT_CELL)));
+  rb_define_const(SwigClassFXTable.klass, "ID_SELECT_ALL", SWIG_From_int(static_cast< int >(FXTable::ID_SELECT_ALL)));
+  rb_define_const(SwigClassFXTable.klass, "ID_DESELECT_ALL", SWIG_From_int(static_cast< int >(FXTable::ID_DESELECT_ALL)));
+  rb_define_const(SwigClassFXTable.klass, "ID_MOVE_LEFT", SWIG_From_int(static_cast< int >(FXTable::ID_MOVE_LEFT)));
+  rb_define_const(SwigClassFXTable.klass, "ID_MOVE_RIGHT", SWIG_From_int(static_cast< int >(FXTable::ID_MOVE_RIGHT)));
+  rb_define_const(SwigClassFXTable.klass, "ID_MOVE_UP", SWIG_From_int(static_cast< int >(FXTable::ID_MOVE_UP)));
+  rb_define_const(SwigClassFXTable.klass, "ID_MOVE_DOWN", SWIG_From_int(static_cast< int >(FXTable::ID_MOVE_DOWN)));
+  rb_define_const(SwigClassFXTable.klass, "ID_MOVE_HOME", SWIG_From_int(static_cast< int >(FXTable::ID_MOVE_HOME)));
+  rb_define_const(SwigClassFXTable.klass, "ID_MOVE_END", SWIG_From_int(static_cast< int >(FXTable::ID_MOVE_END)));
+  rb_define_const(SwigClassFXTable.klass, "ID_MOVE_TOP", SWIG_From_int(static_cast< int >(FXTable::ID_MOVE_TOP)));
+  rb_define_const(SwigClassFXTable.klass, "ID_MOVE_BOTTOM", SWIG_From_int(static_cast< int >(FXTable::ID_MOVE_BOTTOM)));
+  rb_define_const(SwigClassFXTable.klass, "ID_MOVE_PAGEDOWN", SWIG_From_int(static_cast< int >(FXTable::ID_MOVE_PAGEDOWN)));
+  rb_define_const(SwigClassFXTable.klass, "ID_MOVE_PAGEUP", SWIG_From_int(static_cast< int >(FXTable::ID_MOVE_PAGEUP)));
+  rb_define_const(SwigClassFXTable.klass, "ID_START_INPUT", SWIG_From_int(static_cast< int >(FXTable::ID_START_INPUT)));
+  rb_define_const(SwigClassFXTable.klass, "ID_CANCEL_INPUT", SWIG_From_int(static_cast< int >(FXTable::ID_CANCEL_INPUT)));
+  rb_define_const(SwigClassFXTable.klass, "ID_ACCEPT_INPUT", SWIG_From_int(static_cast< int >(FXTable::ID_ACCEPT_INPUT)));
+  rb_define_const(SwigClassFXTable.klass, "ID_MARK", SWIG_From_int(static_cast< int >(FXTable::ID_MARK)));
+  rb_define_const(SwigClassFXTable.klass, "ID_EXTEND", SWIG_From_int(static_cast< int >(FXTable::ID_EXTEND)));
+  rb_define_const(SwigClassFXTable.klass, "ID_CUT_SEL", SWIG_From_int(static_cast< int >(FXTable::ID_CUT_SEL)));
+  rb_define_const(SwigClassFXTable.klass, "ID_COPY_SEL", SWIG_From_int(static_cast< int >(FXTable::ID_COPY_SEL)));
+  rb_define_const(SwigClassFXTable.klass, "ID_PASTE_SEL", SWIG_From_int(static_cast< int >(FXTable::ID_PASTE_SEL)));
+  rb_define_const(SwigClassFXTable.klass, "ID_DELETE_SEL", SWIG_From_int(static_cast< int >(FXTable::ID_DELETE_SEL)));
+  rb_define_const(SwigClassFXTable.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXTable::ID_LAST)));
+  rb_define_method(SwigClassFXTable.klass, "cornerButton", VALUEFUNC(_wrap_FXTable_cornerButton), -1);
+  rb_define_method(SwigClassFXTable.klass, "getColumnHeader", VALUEFUNC(_wrap_FXTable_getColumnHeader), -1);
+  rb_define_method(SwigClassFXTable.klass, "getRowHeader", VALUEFUNC(_wrap_FXTable_getRowHeader), -1);
+  rb_define_method(SwigClassFXTable.klass, "setVisibleRows", VALUEFUNC(_wrap_FXTable_setVisibleRows), -1);
+  rb_define_method(SwigClassFXTable.klass, "getVisibleRows", VALUEFUNC(_wrap_FXTable_getVisibleRows), -1);
+  rb_define_method(SwigClassFXTable.klass, "setVisibleColumns", VALUEFUNC(_wrap_FXTable_setVisibleColumns), -1);
+  rb_define_method(SwigClassFXTable.klass, "getVisibleColumns", VALUEFUNC(_wrap_FXTable_getVisibleColumns), -1);
+  rb_define_method(SwigClassFXTable.klass, "editable?", VALUEFUNC(_wrap_FXTable_editableq___), -1);
+  rb_define_method(SwigClassFXTable.klass, "editable=", VALUEFUNC(_wrap_FXTable_editablee___), -1);
+  rb_define_method(SwigClassFXTable.klass, "showHorzGrid", VALUEFUNC(_wrap_FXTable_showHorzGrid), -1);
+  rb_define_method(SwigClassFXTable.klass, "isHorzGridShown", VALUEFUNC(_wrap_FXTable_isHorzGridShown), -1);
+  rb_define_method(SwigClassFXTable.klass, "showVertGrid", VALUEFUNC(_wrap_FXTable_showVertGrid), -1);
+  rb_define_method(SwigClassFXTable.klass, "isVertGridShown", VALUEFUNC(_wrap_FXTable_isVertGridShown), -1);
+  rb_define_method(SwigClassFXTable.klass, "getNumRows", VALUEFUNC(_wrap_FXTable_getNumRows), -1);
+  rb_define_method(SwigClassFXTable.klass, "getNumColumns", VALUEFUNC(_wrap_FXTable_getNumColumns), -1);
+  rb_define_method(SwigClassFXTable.klass, "setMarginTop", VALUEFUNC(_wrap_FXTable_setMarginTop), -1);
+  rb_define_method(SwigClassFXTable.klass, "getMarginTop", VALUEFUNC(_wrap_FXTable_getMarginTop), -1);
+  rb_define_method(SwigClassFXTable.klass, "setMarginBottom", VALUEFUNC(_wrap_FXTable_setMarginBottom), -1);
+  rb_define_method(SwigClassFXTable.klass, "getMarginBottom", VALUEFUNC(_wrap_FXTable_getMarginBottom), -1);
+  rb_define_method(SwigClassFXTable.klass, "setMarginLeft", VALUEFUNC(_wrap_FXTable_setMarginLeft), -1);
+  rb_define_method(SwigClassFXTable.klass, "getMarginLeft", VALUEFUNC(_wrap_FXTable_getMarginLeft), -1);
+  rb_define_method(SwigClassFXTable.klass, "setMarginRight", VALUEFUNC(_wrap_FXTable_setMarginRight), -1);
+  rb_define_method(SwigClassFXTable.klass, "getMarginRight", VALUEFUNC(_wrap_FXTable_getMarginRight), -1);
+  rb_define_method(SwigClassFXTable.klass, "colAtX", VALUEFUNC(_wrap_FXTable_colAtX), -1);
+  rb_define_method(SwigClassFXTable.klass, "rowAtY", VALUEFUNC(_wrap_FXTable_rowAtY), -1);
+  rb_define_method(SwigClassFXTable.klass, "getItem", VALUEFUNC(_wrap_FXTable_getItem), -1);
+  rb_define_method(SwigClassFXTable.klass, "setItem", VALUEFUNC(_wrap_FXTable_setItem), -1);
+  rb_define_method(SwigClassFXTable.klass, "isItemVisible", VALUEFUNC(_wrap_FXTable_isItemVisible), -1);
+  rb_define_method(SwigClassFXTable.klass, "setColumnHeaderMode", VALUEFUNC(_wrap_FXTable_setColumnHeaderMode), -1);
+  rb_define_method(SwigClassFXTable.klass, "getColumnHeaderMode", VALUEFUNC(_wrap_FXTable_getColumnHeaderMode), -1);
+  rb_define_method(SwigClassFXTable.klass, "setRowHeaderMode", VALUEFUNC(_wrap_FXTable_setRowHeaderMode), -1);
+  rb_define_method(SwigClassFXTable.klass, "getRowHeaderMode", VALUEFUNC(_wrap_FXTable_getRowHeaderMode), -1);
+  rb_define_method(SwigClassFXTable.klass, "setColumnHeaderFont", VALUEFUNC(_wrap_FXTable_setColumnHeaderFont), -1);
+  rb_define_method(SwigClassFXTable.klass, "getColumnHeaderFont", VALUEFUNC(_wrap_FXTable_getColumnHeaderFont), -1);
+  rb_define_method(SwigClassFXTable.klass, "setRowHeaderFont", VALUEFUNC(_wrap_FXTable_setRowHeaderFont), -1);
+  rb_define_method(SwigClassFXTable.klass, "getRowHeaderFont", VALUEFUNC(_wrap_FXTable_getRowHeaderFont), -1);
+  rb_define_method(SwigClassFXTable.klass, "setColumnHeaderHeight", VALUEFUNC(_wrap_FXTable_setColumnHeaderHeight), -1);
+  rb_define_method(SwigClassFXTable.klass, "getColumnHeaderHeight", VALUEFUNC(_wrap_FXTable_getColumnHeaderHeight), -1);
+  rb_define_method(SwigClassFXTable.klass, "setRowHeaderWidth", VALUEFUNC(_wrap_FXTable_setRowHeaderWidth), -1);
+  rb_define_method(SwigClassFXTable.klass, "getRowHeaderWidth", VALUEFUNC(_wrap_FXTable_getRowHeaderWidth), -1);
+  rb_define_method(SwigClassFXTable.klass, "getColumnX", VALUEFUNC(_wrap_FXTable_getColumnX), -1);
+  rb_define_method(SwigClassFXTable.klass, "getRowY", VALUEFUNC(_wrap_FXTable_getRowY), -1);
+  rb_define_method(SwigClassFXTable.klass, "getColumnWidth", VALUEFUNC(_wrap_FXTable_getColumnWidth), -1);
+  rb_define_method(SwigClassFXTable.klass, "getRowHeight", VALUEFUNC(_wrap_FXTable_getRowHeight), -1);
+  rb_define_method(SwigClassFXTable.klass, "setDefColumnWidth", VALUEFUNC(_wrap_FXTable_setDefColumnWidth), -1);
+  rb_define_method(SwigClassFXTable.klass, "getDefColumnWidth", VALUEFUNC(_wrap_FXTable_getDefColumnWidth), -1);
+  rb_define_method(SwigClassFXTable.klass, "setDefRowHeight", VALUEFUNC(_wrap_FXTable_setDefRowHeight), -1);
+  rb_define_method(SwigClassFXTable.klass, "getDefRowHeight", VALUEFUNC(_wrap_FXTable_getDefRowHeight), -1);
+  rb_define_method(SwigClassFXTable.klass, "getMinRowHeight", VALUEFUNC(_wrap_FXTable_getMinRowHeight), -1);
+  rb_define_method(SwigClassFXTable.klass, "getMinColumnWidth", VALUEFUNC(_wrap_FXTable_getMinColumnWidth), -1);
+  rb_define_method(SwigClassFXTable.klass, "fitRowsToContents", VALUEFUNC(_wrap_FXTable_fitRowsToContents), -1);
+  rb_define_method(SwigClassFXTable.klass, "fitColumnsToContents", VALUEFUNC(_wrap_FXTable_fitColumnsToContents), -1);
+  rb_define_method(SwigClassFXTable.klass, "setColumnText", VALUEFUNC(_wrap_FXTable_setColumnText), -1);
+  rb_define_method(SwigClassFXTable.klass, "getColumnText", VALUEFUNC(_wrap_FXTable_getColumnText), -1);
+  rb_define_method(SwigClassFXTable.klass, "setRowText", VALUEFUNC(_wrap_FXTable_setRowText), -1);
+  rb_define_method(SwigClassFXTable.klass, "getRowText", VALUEFUNC(_wrap_FXTable_getRowText), -1);
+  rb_define_method(SwigClassFXTable.klass, "setColumnIcon", VALUEFUNC(_wrap_FXTable_setColumnIcon), -1);
+  rb_define_method(SwigClassFXTable.klass, "getColumnIcon", VALUEFUNC(_wrap_FXTable_getColumnIcon), -1);
+  rb_define_method(SwigClassFXTable.klass, "setRowIcon", VALUEFUNC(_wrap_FXTable_setRowIcon), -1);
+  rb_define_method(SwigClassFXTable.klass, "getRowIcon", VALUEFUNC(_wrap_FXTable_getRowIcon), -1);
+  rb_define_method(SwigClassFXTable.klass, "setColumnIconPosition", VALUEFUNC(_wrap_FXTable_setColumnIconPosition), -1);
+  rb_define_method(SwigClassFXTable.klass, "getColumnIconPosition", VALUEFUNC(_wrap_FXTable_getColumnIconPosition), -1);
+  rb_define_method(SwigClassFXTable.klass, "setRowIconPosition", VALUEFUNC(_wrap_FXTable_setRowIconPosition), -1);
+  rb_define_method(SwigClassFXTable.klass, "getRowIconPosition", VALUEFUNC(_wrap_FXTable_getRowIconPosition), -1);
+  rb_define_method(SwigClassFXTable.klass, "setColumnJustify", VALUEFUNC(_wrap_FXTable_setColumnJustify), -1);
+  rb_define_method(SwigClassFXTable.klass, "getColumnJustify", VALUEFUNC(_wrap_FXTable_getColumnJustify), -1);
+  rb_define_method(SwigClassFXTable.klass, "setRowJustify", VALUEFUNC(_wrap_FXTable_setRowJustify), -1);
+  rb_define_method(SwigClassFXTable.klass, "getRowJustify", VALUEFUNC(_wrap_FXTable_getRowJustify), -1);
+  rb_define_method(SwigClassFXTable.klass, "setItemText", VALUEFUNC(_wrap_FXTable_setItemText), -1);
+  rb_define_method(SwigClassFXTable.klass, "getItemText", VALUEFUNC(_wrap_FXTable_getItemText), -1);
+  rb_define_method(SwigClassFXTable.klass, "setItemIcon", VALUEFUNC(_wrap_FXTable_setItemIcon), -1);
+  rb_define_method(SwigClassFXTable.klass, "getItemIcon", VALUEFUNC(_wrap_FXTable_getItemIcon), -1);
+  rb_define_method(SwigClassFXTable.klass, "setItemData", VALUEFUNC(_wrap_FXTable_setItemData), -1);
+  rb_define_method(SwigClassFXTable.klass, "getItemData", VALUEFUNC(_wrap_FXTable_getItemData), -1);
+  rb_define_method(SwigClassFXTable.klass, "extractText", VALUEFUNC(_wrap_FXTable_extractText), -1);
+  rb_define_method(SwigClassFXTable.klass, "overlayText", VALUEFUNC(_wrap_FXTable_overlayText), -1);
+  rb_define_method(SwigClassFXTable.klass, "countText", VALUEFUNC(_wrap_FXTable_countText), -1);
+  rb_define_method(SwigClassFXTable.klass, "isItemSpanning", VALUEFUNC(_wrap_FXTable_isItemSpanning), -1);
+  rb_define_method(SwigClassFXTable.klass, "updateRange", VALUEFUNC(_wrap_FXTable_updateRange), -1);
+  rb_define_method(SwigClassFXTable.klass, "updateItem", VALUEFUNC(_wrap_FXTable_updateItem), -1);
+  rb_define_method(SwigClassFXTable.klass, "isItemEnabled", VALUEFUNC(_wrap_FXTable_isItemEnabled), -1);
+  rb_define_method(SwigClassFXTable.klass, "setItemJustify", VALUEFUNC(_wrap_FXTable_setItemJustify), -1);
+  rb_define_method(SwigClassFXTable.klass, "getItemJustify", VALUEFUNC(_wrap_FXTable_getItemJustify), -1);
+  rb_define_method(SwigClassFXTable.klass, "setItemIconPosition", VALUEFUNC(_wrap_FXTable_setItemIconPosition), -1);
+  rb_define_method(SwigClassFXTable.klass, "getItemIconPosition", VALUEFUNC(_wrap_FXTable_getItemIconPosition), -1);
+  rb_define_method(SwigClassFXTable.klass, "setItemBorders", VALUEFUNC(_wrap_FXTable_setItemBorders), -1);
+  rb_define_method(SwigClassFXTable.klass, "getItemBorders", VALUEFUNC(_wrap_FXTable_getItemBorders), -1);
+  rb_define_method(SwigClassFXTable.klass, "setItemStipple", VALUEFUNC(_wrap_FXTable_setItemStipple), -1);
+  rb_define_method(SwigClassFXTable.klass, "getItemStipple", VALUEFUNC(_wrap_FXTable_getItemStipple), -1);
+  rb_define_method(SwigClassFXTable.klass, "getCurrentRow", VALUEFUNC(_wrap_FXTable_getCurrentRow), -1);
+  rb_define_method(SwigClassFXTable.klass, "getCurrentColumn", VALUEFUNC(_wrap_FXTable_getCurrentColumn), -1);
+  rb_define_method(SwigClassFXTable.klass, "isItemCurrent", VALUEFUNC(_wrap_FXTable_isItemCurrent), -1);
+  rb_define_method(SwigClassFXTable.klass, "setAnchorItem", VALUEFUNC(_wrap_FXTable_setAnchorItem), -1);
+  rb_define_method(SwigClassFXTable.klass, "getAnchorRow", VALUEFUNC(_wrap_FXTable_getAnchorRow), -1);
+  rb_define_method(SwigClassFXTable.klass, "getAnchorColumn", VALUEFUNC(_wrap_FXTable_getAnchorColumn), -1);
+  rb_define_method(SwigClassFXTable.klass, "getSelStartRow", VALUEFUNC(_wrap_FXTable_getSelStartRow), -1);
+  rb_define_method(SwigClassFXTable.klass, "getSelStartColumn", VALUEFUNC(_wrap_FXTable_getSelStartColumn), -1);
+  rb_define_method(SwigClassFXTable.klass, "getSelEndRow", VALUEFUNC(_wrap_FXTable_getSelEndRow), -1);
+  rb_define_method(SwigClassFXTable.klass, "getSelEndColumn", VALUEFUNC(_wrap_FXTable_getSelEndColumn), -1);
+  rb_define_method(SwigClassFXTable.klass, "isItemSelected", VALUEFUNC(_wrap_FXTable_isItemSelected), -1);
+  rb_define_method(SwigClassFXTable.klass, "isRowSelected", VALUEFUNC(_wrap_FXTable_isRowSelected), -1);
+  rb_define_method(SwigClassFXTable.klass, "isColumnSelected", VALUEFUNC(_wrap_FXTable_isColumnSelected), -1);
+  rb_define_method(SwigClassFXTable.klass, "isAnythingSelected", VALUEFUNC(_wrap_FXTable_isAnythingSelected), -1);
+  rb_define_method(SwigClassFXTable.klass, "setFont", VALUEFUNC(_wrap_FXTable_setFont), -1);
+  rb_define_method(SwigClassFXTable.klass, "getFont", VALUEFUNC(_wrap_FXTable_getFont), -1);
+  rb_define_method(SwigClassFXTable.klass, "getTextColor", VALUEFUNC(_wrap_FXTable_getTextColor), -1);
+  rb_define_method(SwigClassFXTable.klass, "getBaseColor", VALUEFUNC(_wrap_FXTable_getBaseColor), -1);
+  rb_define_method(SwigClassFXTable.klass, "getHiliteColor", VALUEFUNC(_wrap_FXTable_getHiliteColor), -1);
+  rb_define_method(SwigClassFXTable.klass, "getShadowColor", VALUEFUNC(_wrap_FXTable_getShadowColor), -1);
+  rb_define_method(SwigClassFXTable.klass, "getBorderColor", VALUEFUNC(_wrap_FXTable_getBorderColor), -1);
+  rb_define_method(SwigClassFXTable.klass, "getSelBackColor", VALUEFUNC(_wrap_FXTable_getSelBackColor), -1);
+  rb_define_method(SwigClassFXTable.klass, "getSelTextColor", VALUEFUNC(_wrap_FXTable_getSelTextColor), -1);
+  rb_define_method(SwigClassFXTable.klass, "getGridColor", VALUEFUNC(_wrap_FXTable_getGridColor), -1);
+  rb_define_method(SwigClassFXTable.klass, "getStippleColor", VALUEFUNC(_wrap_FXTable_getStippleColor), -1);
+  rb_define_method(SwigClassFXTable.klass, "getCellBorderColor", VALUEFUNC(_wrap_FXTable_getCellBorderColor), -1);
+  rb_define_method(SwigClassFXTable.klass, "setTextColor", VALUEFUNC(_wrap_FXTable_setTextColor), -1);
+  rb_define_method(SwigClassFXTable.klass, "setBaseColor", VALUEFUNC(_wrap_FXTable_setBaseColor), -1);
+  rb_define_method(SwigClassFXTable.klass, "setHiliteColor", VALUEFUNC(_wrap_FXTable_setHiliteColor), -1);
+  rb_define_method(SwigClassFXTable.klass, "setShadowColor", VALUEFUNC(_wrap_FXTable_setShadowColor), -1);
+  rb_define_method(SwigClassFXTable.klass, "setBorderColor", VALUEFUNC(_wrap_FXTable_setBorderColor), -1);
+  rb_define_method(SwigClassFXTable.klass, "setSelBackColor", VALUEFUNC(_wrap_FXTable_setSelBackColor), -1);
+  rb_define_method(SwigClassFXTable.klass, "setSelTextColor", VALUEFUNC(_wrap_FXTable_setSelTextColor), -1);
+  rb_define_method(SwigClassFXTable.klass, "setGridColor", VALUEFUNC(_wrap_FXTable_setGridColor), -1);
+  rb_define_method(SwigClassFXTable.klass, "setStippleColor", VALUEFUNC(_wrap_FXTable_setStippleColor), -1);
+  rb_define_method(SwigClassFXTable.klass, "setCellBorderColor", VALUEFUNC(_wrap_FXTable_setCellBorderColor), -1);
+  rb_define_method(SwigClassFXTable.klass, "setCellColor", VALUEFUNC(_wrap_FXTable_setCellColor), -1);
+  rb_define_method(SwigClassFXTable.klass, "getCellColor", VALUEFUNC(_wrap_FXTable_getCellColor), -1);
+  rb_define_method(SwigClassFXTable.klass, "setCellBorderWidth", VALUEFUNC(_wrap_FXTable_setCellBorderWidth), -1);
+  rb_define_method(SwigClassFXTable.klass, "getCellBorderWidth", VALUEFUNC(_wrap_FXTable_getCellBorderWidth), -1);
+  rb_define_method(SwigClassFXTable.klass, "getTableStyle", VALUEFUNC(_wrap_FXTable_getTableStyle), -1);
+  rb_define_method(SwigClassFXTable.klass, "setTableStyle", VALUEFUNC(_wrap_FXTable_setTableStyle), -1);
+  rb_define_method(SwigClassFXTable.klass, "columnRenumbering=", VALUEFUNC(_wrap_FXTable_columnRenumberinge___), -1);
+  rb_define_method(SwigClassFXTable.klass, "columnRenumbering?", VALUEFUNC(_wrap_FXTable_columnRenumberingq___), -1);
+  rb_define_method(SwigClassFXTable.klass, "rowRenumbering=", VALUEFUNC(_wrap_FXTable_rowRenumberinge___), -1);
+  rb_define_method(SwigClassFXTable.klass, "rowRenumbering?", VALUEFUNC(_wrap_FXTable_rowRenumberingq___), -1);
+  rb_define_method(SwigClassFXTable.klass, "setHelpText", VALUEFUNC(_wrap_FXTable_setHelpText), -1);
+  rb_define_method(SwigClassFXTable.klass, "getHelpText", VALUEFUNC(_wrap_FXTable_getHelpText), -1);
+  rb_define_method(SwigClassFXTable.klass, "save", VALUEFUNC(_wrap_FXTable_save), -1);
+  rb_define_method(SwigClassFXTable.klass, "load", VALUEFUNC(_wrap_FXTable_load), -1);
+  rb_define_method(SwigClassFXTable.klass, "create", VALUEFUNC(_wrap_FXTable_create), -1);
+  rb_define_method(SwigClassFXTable.klass, "detach", VALUEFUNC(_wrap_FXTable_detach), -1);
+  rb_define_method(SwigClassFXTable.klass, "destroy", VALUEFUNC(_wrap_FXTable_destroy), -1);
+  rb_define_method(SwigClassFXTable.klass, "resize", VALUEFUNC(_wrap_FXTable_resize), -1);
+  rb_define_method(SwigClassFXTable.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXTable_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXTable.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXTable_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXTable.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXTable_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXTable.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXTable_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXTable.klass, "canFocus", VALUEFUNC(_wrap_FXTable_canFocus), -1);
+  rb_define_method(SwigClassFXTable.klass, "setFocus", VALUEFUNC(_wrap_FXTable_setFocus), -1);
+  rb_define_method(SwigClassFXTable.klass, "killFocus", VALUEFUNC(_wrap_FXTable_killFocus), -1);
+  rb_define_method(SwigClassFXTable.klass, "changeFocus", VALUEFUNC(_wrap_FXTable_changeFocus), -1);
+  rb_define_method(SwigClassFXTable.klass, "setDefault", VALUEFUNC(_wrap_FXTable_setDefault), -1);
+  rb_define_method(SwigClassFXTable.klass, "enable", VALUEFUNC(_wrap_FXTable_enable), -1);
+  rb_define_method(SwigClassFXTable.klass, "disable", VALUEFUNC(_wrap_FXTable_disable), -1);
+  rb_define_method(SwigClassFXTable.klass, "raiseWindow", VALUEFUNC(_wrap_FXTable_raiseWindow), -1);
+  rb_define_method(SwigClassFXTable.klass, "lower", VALUEFUNC(_wrap_FXTable_lower), -1);
+  rb_define_method(SwigClassFXTable.klass, "move", VALUEFUNC(_wrap_FXTable_move), -1);
+  rb_define_method(SwigClassFXTable.klass, "layout", VALUEFUNC(_wrap_FXTable_layout), -1);
+  rb_define_method(SwigClassFXTable.klass, "recalc", VALUEFUNC(_wrap_FXTable_recalc), -1);
+  rb_define_method(SwigClassFXTable.klass, "reparent", VALUEFUNC(_wrap_FXTable_reparent), -1);
+  rb_define_method(SwigClassFXTable.klass, "show", VALUEFUNC(_wrap_FXTable_show), -1);
+  rb_define_method(SwigClassFXTable.klass, "hide", VALUEFUNC(_wrap_FXTable_hide), -1);
+  rb_define_method(SwigClassFXTable.klass, "isComposite", VALUEFUNC(_wrap_FXTable_isComposite), -1);
+  rb_define_method(SwigClassFXTable.klass, "contains", VALUEFUNC(_wrap_FXTable_contains), -1);
+  rb_define_method(SwigClassFXTable.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXTable_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXTable.klass, "setBackColor", VALUEFUNC(_wrap_FXTable_setBackColor), -1);
+  rb_define_method(SwigClassFXTable.klass, "tr", VALUEFUNC(_wrap_FXTable_tr), -1);
+  rb_define_method(SwigClassFXTable.klass, "dropEnable", VALUEFUNC(_wrap_FXTable_dropEnable), -1);
+  rb_define_method(SwigClassFXTable.klass, "dropDisable", VALUEFUNC(_wrap_FXTable_dropDisable), -1);
+  rb_define_method(SwigClassFXTable.klass, "setShape", VALUEFUNC(_wrap_FXTable_setShape), -1);
+  rb_define_method(SwigClassFXTable.klass, "clearShape", VALUEFUNC(_wrap_FXTable_clearShape), -1);
+  rb_define_method(SwigClassFXTable.klass, "getViewportHeight", VALUEFUNC(_wrap_FXTable_getViewportHeight), -1);
+  rb_define_method(SwigClassFXTable.klass, "getViewportWidth", VALUEFUNC(_wrap_FXTable_getViewportWidth), -1);
+  rb_define_method(SwigClassFXTable.klass, "getContentHeight", VALUEFUNC(_wrap_FXTable_getContentHeight), -1);
+  rb_define_method(SwigClassFXTable.klass, "getContentWidth", VALUEFUNC(_wrap_FXTable_getContentWidth), -1);
+  rb_define_method(SwigClassFXTable.klass, "position", VALUEFUNC(_wrap_FXTable_position), -1);
+  rb_define_method(SwigClassFXTable.klass, "drawCell", VALUEFUNC(_wrap_FXTable_drawCell), -1);
+  rb_define_method(SwigClassFXTable.klass, "drawRange", VALUEFUNC(_wrap_FXTable_drawRange), -1);
+  rb_define_method(SwigClassFXTable.klass, "drawHGrid", VALUEFUNC(_wrap_FXTable_drawHGrid), -1);
+  rb_define_method(SwigClassFXTable.klass, "drawVGrid", VALUEFUNC(_wrap_FXTable_drawVGrid), -1);
+  rb_define_method(SwigClassFXTable.klass, "drawContents", VALUEFUNC(_wrap_FXTable_drawContents), -1);
+  rb_define_method(SwigClassFXTable.klass, "createItem", VALUEFUNC(_wrap_FXTable_createItem), -1);
+  rb_define_method(SwigClassFXTable.klass, "setTableSize", VALUEFUNC(_wrap_FXTable_setTableSize), -1);
+  rb_define_method(SwigClassFXTable.klass, "insertRows", VALUEFUNC(_wrap_FXTable_insertRows), -1);
+  rb_define_method(SwigClassFXTable.klass, "insertColumns", VALUEFUNC(_wrap_FXTable_insertColumns), -1);
+  rb_define_method(SwigClassFXTable.klass, "removeRows", VALUEFUNC(_wrap_FXTable_removeRows), -1);
+  rb_define_method(SwigClassFXTable.klass, "removeColumns", VALUEFUNC(_wrap_FXTable_removeColumns), -1);
+  rb_define_method(SwigClassFXTable.klass, "extractItem", VALUEFUNC(_wrap_FXTable_extractItem), -1);
+  rb_define_method(SwigClassFXTable.klass, "removeItem", VALUEFUNC(_wrap_FXTable_removeItem), -1);
+  rb_define_method(SwigClassFXTable.klass, "removeRange", VALUEFUNC(_wrap_FXTable_removeRange), -1);
+  rb_define_method(SwigClassFXTable.klass, "clearItems", VALUEFUNC(_wrap_FXTable_clearItems), -1);
+  rb_define_method(SwigClassFXTable.klass, "setColumnWidth", VALUEFUNC(_wrap_FXTable_setColumnWidth), -1);
+  rb_define_method(SwigClassFXTable.klass, "setRowHeight", VALUEFUNC(_wrap_FXTable_setRowHeight), -1);
+  rb_define_method(SwigClassFXTable.klass, "setCurrentItem", VALUEFUNC(_wrap_FXTable_setCurrentItem), -1);
+  rb_define_method(SwigClassFXTable.klass, "selectRow", VALUEFUNC(_wrap_FXTable_selectRow), -1);
+  rb_define_method(SwigClassFXTable.klass, "selectColumn", VALUEFUNC(_wrap_FXTable_selectColumn), -1);
+  rb_define_method(SwigClassFXTable.klass, "selectRange", VALUEFUNC(_wrap_FXTable_selectRange), -1);
+  rb_define_method(SwigClassFXTable.klass, "extendSelection", VALUEFUNC(_wrap_FXTable_extendSelection), -1);
+  rb_define_method(SwigClassFXTable.klass, "killSelection", VALUEFUNC(_wrap_FXTable_killSelection), -1);
+  rb_define_method(SwigClassFXTable.klass, "startInput", VALUEFUNC(_wrap_FXTable_startInput), -1);
+  rb_define_method(SwigClassFXTable.klass, "cancelInput", VALUEFUNC(_wrap_FXTable_cancelInput), -1);
+  rb_define_method(SwigClassFXTable.klass, "acceptInput", VALUEFUNC(_wrap_FXTable_acceptInput), -1);
+  rb_define_method(SwigClassFXTable.klass, "makePositionVisible", VALUEFUNC(_wrap_FXTable_makePositionVisible), -1);
+  rb_define_method(SwigClassFXTable.klass, "enableItem", VALUEFUNC(_wrap_FXTable_enableItem), -1);
+  rb_define_method(SwigClassFXTable.klass, "disableItem", VALUEFUNC(_wrap_FXTable_disableItem), -1);
+  SwigClassFXTable.mark = (void (*)(void *)) FXRbTable::markfunc;
+  SwigClassFXTable.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXTable.trackObjects = 0;
+}
+
diff --git a/ext/fox16_c/text_wrap.cpp b/ext/fox16_c/text_wrap.cpp
new file mode 100644
index 00000000..4bafadf7
--- /dev/null
+++ b/ext/fox16_c/text_wrap.cpp
@@ -0,0 +1,13599 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 3.0.12
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+
+#ifndef SWIGRUBY
+#define SWIGRUBY
+#endif
+
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
+};
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic C API SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "4"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/*  Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN           0x1
+
+
+/*
+   Flags/methods for returning states.
+
+   The SWIG conversion methods, as ConvertPtr, return an integer
+   that tells if the conversion was successful or not. And if not,
+   an error code can be returned (see swigerrors.swg for the codes).
+
+   Use the following macros/flags to set or process the returning
+   states.
+
+   In old versions of SWIG, code such as the following was usually written:
+
+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+       // success code
+     } else {
+       //fail code
+     }
+
+   Now you can be more explicit:
+
+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+    } else {
+      // fail code
+    }
+
+   which is the same really, but now you can also do
+
+    Type *ptr;
+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+      if (SWIG_IsNewObj(res) {
+        ...
+	delete *ptr;
+      } else {
+        ...
+      }
+    } else {
+      // fail code
+    }
+
+   I.e., now SWIG_ConvertPtr can return new objects and you can
+   identify the case and take care of the deallocation. Of course that
+   also requires SWIG_ConvertPtr to return new result values, such as
+
+      int SWIG_ConvertPtr(obj, ptr,...) {
+        if (<obj is ok>) {
+          if (<need new object>) {
+            *ptr = <ptr to new allocated object>;
+            return SWIG_NEWOBJ;
+          } else {
+            *ptr = <ptr to old object>;
+            return SWIG_OLDOBJ;
+          }
+        } else {
+          return SWIG_BADOBJ;
+        }
+      }
+
+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+   SWIG errors code.
+
+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+   allows to return the 'cast rank', for example, if you have this
+
+       int food(double)
+       int fooi(int);
+
+   and you call
+
+      food(1)   // cast rank '1'  (1 -> 1.0)
+      fooi(1)   // cast rank '0'
+
+   just use the SWIG_AddCast()/SWIG_CheckState()
+*/
+
+#define SWIG_OK                    (0)
+#define SWIG_ERROR                 (-1)
+#define SWIG_IsOK(r)               (r >= 0)
+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT         (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ                (SWIG_ERROR)
+#define SWIG_OLDOBJ                (SWIG_OK)
+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+#  ifndef SWIG_TypeRank
+#    define SWIG_TypeRank             unsigned long
+#  endif
+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
+#    define SWIG_MAXCASTRANK          (2)
+#  endif
+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+#  define SWIG_AddCast(r) (r)
+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *, int *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store information on one type */
+typedef struct swig_type_info {
+  const char             *name;			/* mangled name of this type */
+  const char             *str;			/* human readable name of this type */
+  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
+  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
+  void                   *clientdata;		/* language specific type data */
+  int                    owndata;		/* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
+  swig_converter_func     converter;		/* function to cast the void pointers */
+  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
+  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
+  size_t                 size;		        /* Number of types in this module */
+  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
+  swig_type_info         **type_initial;	/* Array of initially generated type structures */
+  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
+  void                    *clientdata;		/* Language specific module data */
+} swig_module_info;
+
+/*
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+  }
+  return (int)((l1 - f1) - (l2 - f2));
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCmp(const char *nb, const char *tb) {
+  int equiv = 1;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (equiv != 0 && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
+}
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
+}
+
+/*
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+  swig_type_info *lastty = ty;
+  if (!ty || !ty->dcast) return ty;
+  while (ty && (ty->dcast)) {
+    ty = (*ty->dcast)(ptr);
+    if (ty) lastty = ty;
+  }
+  return lastty;
+}
+
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+  return ty->name;
+}
+
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (!type) return NULL;
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
+  }
+  else
+    return type->name;
+}
+
+/*
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+  swig_cast_info *cast = ti->cast;
+  /* if (ti->clientdata == clientdata) return; */
+  ti->clientdata = clientdata;
+
+  while (cast) {
+    if (!cast->converter) {
+      swig_type_info *tc = cast->type;
+      if (!tc->clientdata) {
+	SWIG_TypeClientData(tc, clientdata);
+      }
+    }
+    cast = cast->next;
+  }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientData(ti, clientdata);
+  ti->owndata = 1;
+}
+
+/*
+  Search for a swig_type_info structure only by mangled name
+  Search is a O(log #types)
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+                            swig_module_info *end,
+		            const char *name) {
+  swig_module_info *iter = start;
+  do {
+    if (iter->size) {
+      size_t l = 0;
+      size_t r = iter->size - 1;
+      do {
+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
+	size_t i = (l + r) >> 1;
+	const char *iname = iter->types[i]->name;
+	if (iname) {
+	  int compare = strcmp(name, iname);
+	  if (compare == 0) {
+	    return iter->types[i];
+	  } else if (compare < 0) {
+	    if (i) {
+	      r = i - 1;
+	    } else {
+	      break;
+	    }
+	  } else if (compare > 0) {
+	    l = i + 1;
+	  }
+	} else {
+	  break; /* should never happen */
+	}
+      } while (l <= r);
+    }
+    iter = iter->next;
+  } while (iter != end);
+  return 0;
+}
+
+/*
+  Search for a swig_type_info structure for either a mangled name or a human readable name.
+  It first searches the mangled names of the types, which is a O(log #types)
+  If a type is not found it then searches the human readable names, which is O(#types).
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+                     swig_module_info *end,
+		     const char *name) {
+  /* STEP 1: Search the name field using binary search */
+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+  if (ret) {
+    return ret;
+  } else {
+    /* STEP 2: If the type hasn't been found, do a complete search
+       of the str field (the human readable name) */
+    swig_module_info *iter = start;
+    do {
+      size_t i = 0;
+      for (; i < iter->size; ++i) {
+	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+	  return iter->types[i];
+      }
+      iter = iter->next;
+    } while (iter != end);
+  }
+
+  /* neither found a match */
+  return 0;
+}
+
+/*
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+
+/*
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = (unsigned char)((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = (unsigned char)((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (unsigned char)(d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (unsigned char)(d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/*
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/*  Errors in SWIG */
+#define  SWIG_UnknownError    	   -1
+#define  SWIG_IOError        	   -2
+#define  SWIG_RuntimeError   	   -3
+#define  SWIG_IndexError     	   -4
+#define  SWIG_TypeError      	   -5
+#define  SWIG_DivisionByZero 	   -6
+#define  SWIG_OverflowError  	   -7
+#define  SWIG_SyntaxError    	   -8
+#define  SWIG_ValueError     	   -9
+#define  SWIG_SystemError    	   -10
+#define  SWIG_AttributeError 	   -11
+#define  SWIG_MemoryError    	   -12
+#define  SWIG_NullReferenceError   -13
+
+
+
+      #include <ruby.h>
+
+      #if defined(RB_METHOD_DEFINITION_DECL)
+      # define RUBY_VALUE_METHOD_FUNC(func) (func)
+      # define RUBY_INT_METHOD_FUNC(func) (func)
+      # define RUBY_VOID_METHOD_FUNC(func) (func)
+      # define RUBY_VOIDP_METHOD_FUNC(func) (func)
+      #else
+      # define RUBY_VALUE_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
+      # define RUBY_INT_METHOD_FUNC(func) ((int (*)(ANYARGS))(func))
+      # define RUBY_VOID_METHOD_FUNC(func) ((void (*)(ANYARGS))(func))
+      # define RUBY_VOIDP_METHOD_FUNC(func) ((void *(*)(ANYARGS))(func))
+      #endif
+
+
+/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
+ * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
+ * issue for now by disabling this.
+ * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
+ */
+#ifdef rb_intern
+# undef rb_intern
+#endif
+
+/* Remove global macros defined in Ruby's win32.h */
+#ifdef write
+# undef write
+#endif
+#ifdef read
+# undef read
+#endif
+#ifdef bind
+# undef bind
+#endif
+#ifdef close
+# undef close
+#endif
+#ifdef connect
+# undef connect
+#endif
+
+
+/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
+#ifndef NUM2LL
+#define NUM2LL(x) NUM2LONG((x))
+#endif
+#ifndef LL2NUM
+#define LL2NUM(x) INT2NUM((long) (x))
+#endif
+#ifndef ULL2NUM
+#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
+#endif
+
+/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
+#ifndef NUM2ULL
+#ifdef HAVE_LONG_LONG
+#define NUM2ULL(x) rb_num2ull((x))
+#else
+#define NUM2ULL(x) NUM2ULONG(x)
+#endif
+#endif
+
+/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
+/* Define these for older versions so we can just write code the new way */
+#ifndef RSTRING_LEN
+# define RSTRING_LEN(x) RSTRING(x)->len
+#endif
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(x) RSTRING(x)->ptr
+#endif
+#ifndef RSTRING_END
+# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
+#endif
+#ifndef RARRAY_LEN
+# define RARRAY_LEN(x) RARRAY(x)->len
+#endif
+#ifndef RARRAY_PTR
+# define RARRAY_PTR(x) RARRAY(x)->ptr
+#endif
+#ifndef RFLOAT_VALUE
+# define RFLOAT_VALUE(x) RFLOAT(x)->value
+#endif
+#ifndef DOUBLE2NUM
+# define DOUBLE2NUM(x) rb_float_new(x)
+#endif
+#ifndef RHASH_TBL
+# define RHASH_TBL(x) (RHASH(x)->tbl)
+#endif
+#ifndef RHASH_ITER_LEV
+# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
+#endif
+#ifndef RHASH_IFNONE
+# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
+#endif
+#ifndef RHASH_SIZE
+# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
+#endif
+#ifndef RHASH_EMPTY_P
+# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
+#endif
+#ifndef RSTRUCT_LEN
+# define RSTRUCT_LEN(x) RSTRUCT(x)->len
+#endif
+#ifndef RSTRUCT_PTR
+# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
+#endif
+
+
+
+/*
+ * Need to be very careful about how these macros are defined, especially
+ * when compiling C++ code or C code with an ANSI C compiler.
+ *
+ * VALUEFUNC(f) is a macro used to typecast a C function that implements
+ * a Ruby method so that it can be passed as an argument to API functions
+ * like rb_define_method() and rb_define_singleton_method().
+ *
+ * VOIDFUNC(f) is a macro used to typecast a C function that implements
+ * either the "mark" or "free" stuff for a Ruby Data object, so that it
+ * can be passed as an argument to API functions like Data_Wrap_Struct()
+ * and Data_Make_Struct().
+ */
+ 
+#ifdef __cplusplus
+#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
+#    define PROTECTFUNC(f) ((VALUE (*)()) f)
+#    define VALUEFUNC(f) ((VALUE (*)()) f)
+#    define VOIDFUNC(f)  ((void (*)()) f)
+#  else
+#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
+#      define PROTECTFUNC(f) ((VALUE (*)()) f)
+#      define VALUEFUNC(f) ((VALUE (*)()) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    else /* These definitions should work for Ruby 1.7+ */
+#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
+#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    endif
+#  endif
+#else
+#  define VALUEFUNC(f) (f)
+#  define VOIDFUNC(f) (f)
+#endif
+
+/* Don't use for expressions have side effect */
+#ifndef RB_STRING_VALUE
+#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
+#endif
+#ifndef StringValue
+#define StringValue(s) RB_STRING_VALUE(s)
+#endif
+#ifndef StringValuePtr
+#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
+#endif
+#ifndef StringValueLen
+#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
+#endif
+#ifndef SafeStringValue
+#define SafeStringValue(v) do {\
+    StringValue(v);\
+    rb_check_safe_str(v);\
+} while (0)
+#endif
+
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
+#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
+#endif
+
+static VALUE _mSWIG = Qnil;
+
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+
+/* Define some additional error types */
+#define SWIG_ObjectPreviouslyDeletedError  -100
+
+
+/* Define custom exceptions for errors that do not map to existing Ruby
+   exceptions.  Note this only works for C++ since a global cannot be
+   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/
+
+SWIGINTERN VALUE 
+getNullReferenceError(void) {
+  static int init = 0;
+  static VALUE rb_eNullReferenceError ;
+  if (!init) {
+    init = 1;
+    rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
+  }
+  return rb_eNullReferenceError;
+} 
+
+SWIGINTERN VALUE 
+getObjectPreviouslyDeletedError(void) {
+  static int init = 0;
+  static VALUE rb_eObjectPreviouslyDeleted ;
+  if (!init) {
+    init = 1;
+    rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
+  }
+  return rb_eObjectPreviouslyDeleted;
+} 
+
+
+SWIGINTERN VALUE
+SWIG_Ruby_ErrorType(int SWIG_code) {
+  VALUE type;
+  switch (SWIG_code) {
+  case SWIG_MemoryError:
+    type = rb_eNoMemError;
+    break;
+  case SWIG_IOError:
+    type = rb_eIOError;
+    break;
+  case SWIG_RuntimeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_IndexError:
+    type = rb_eIndexError;
+    break;
+  case SWIG_TypeError:
+    type = rb_eTypeError;
+    break;
+  case SWIG_DivisionByZero:
+    type = rb_eZeroDivError;
+    break;
+  case SWIG_OverflowError:
+    type = rb_eRangeError;
+    break;
+  case SWIG_SyntaxError:
+    type = rb_eSyntaxError;
+    break;
+  case SWIG_ValueError:
+    type = rb_eArgError;
+    break;
+  case SWIG_SystemError:
+    type = rb_eFatal;
+    break;
+  case SWIG_AttributeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_NullReferenceError:
+    type = getNullReferenceError();
+    break;
+  case SWIG_ObjectPreviouslyDeletedError:
+    type = getObjectPreviouslyDeletedError();
+    break;
+  case SWIG_UnknownError:
+    type = rb_eRuntimeError;
+    break;
+  default:
+    type = rb_eRuntimeError;
+  }
+  return type;
+}
+
+
+/* This function is called when a user inputs a wrong argument to
+   a method.
+ */
+SWIGINTERN 
+const char* Ruby_Format_TypeError( const char* msg,
+				   const char* type, 
+				   const char* name, 
+				   const int argn,
+				   VALUE input )
+{
+  char buf[128];
+  VALUE str;
+  VALUE asStr;
+  if ( msg && *msg )
+    {
+      str = rb_str_new2(msg);
+    }
+  else
+    {
+      str = rb_str_new(NULL, 0);
+    }
+
+  str = rb_str_cat2( str, "Expected argument " );
+  sprintf( buf, "%d of type ", argn-1 );
+  str = rb_str_cat2( str, buf );
+  str = rb_str_cat2( str, type );
+  str = rb_str_cat2( str, ", but got " );
+  str = rb_str_cat2( str, rb_obj_classname(input) );
+  str = rb_str_cat2( str, " " );
+  asStr = rb_inspect(input);
+  if ( RSTRING_LEN(asStr) > 30 )
+    {
+      str = rb_str_cat( str, StringValuePtr(asStr), 30 );
+      str = rb_str_cat2( str, "..." );
+    }
+  else
+    {
+      str = rb_str_append( str, asStr );
+    }
+
+  if ( name )
+    {
+      str = rb_str_cat2( str, "\n\tin SWIG method '" );
+      str = rb_str_cat2( str, name );
+      str = rb_str_cat2( str, "'" );
+    }
+
+  return StringValuePtr( str );
+}
+
+/* This function is called when an overloaded method fails */
+SWIGINTERN 
+void Ruby_Format_OverloadedError(
+				 const int argc,
+				 const int maxargs,
+				 const char* method, 
+				 const char* prototypes 
+				 )
+{
+  const char* msg = "Wrong # of arguments";
+  if ( argc <= maxargs ) msg = "Wrong arguments";
+  rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
+	   "Possible C/C++ prototypes are:\n%s",
+	   msg, method, prototypes);
+}
+
+/* -----------------------------------------------------------------------------
+ * rubytracking.swg
+ *
+ * This file contains support for tracking mappings from 
+ * Ruby objects to C++ objects.  This functionality is needed
+ * to implement mark functions for Ruby's mark and sweep
+ * garbage collector.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(ST_DATA_T_DEFINED)
+/* Needs to be explicitly included for Ruby 1.8 and earlier */
+#include <st.h>
+#endif
+
+/* Ruby 1.8 actually assumes the first case. */
+#if SIZEOF_VOIDP == SIZEOF_LONG
+#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
+#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
+#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
+#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
+#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
+#else
+#  error sizeof(void*) is not the same as long or long long
+#endif
+
+/* Global hash table to store Trackings from C/C++
+   structs to Ruby Objects. 
+*/
+static st_table* swig_ruby_trackings = NULL;
+
+static VALUE swig_ruby_trackings_count(ID id, VALUE *var) {
+  return SWIG2NUM(swig_ruby_trackings->num_entries);
+}
+
+
+/* Setup a hash table to store Trackings */
+SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
+  /* Create a hash table to store Trackings from C++
+     objects to Ruby objects. */
+
+  /* Try to see if some other .so has already created a 
+     tracking hash table, which we keep hidden in an instance var
+     in the SWIG module.
+     This is done to allow multiple DSOs to share the same
+     tracking table.
+  */
+  VALUE trackings_value = Qnil;
+  /* change the variable name so that we can mix modules
+     compiled with older SWIG's - this used to be called "@__trackings__" */
+  ID trackings_id = rb_intern( "@__safetrackings__" );
+  VALUE verbose = rb_gv_get("VERBOSE");
+  rb_gv_set("VERBOSE", Qfalse);
+  trackings_value = rb_ivar_get( _mSWIG, trackings_id );
+  rb_gv_set("VERBOSE", verbose);
+
+  /* The trick here is that we have to store the hash table
+  pointer in a Ruby variable. We do not want Ruby's GC to
+  treat this pointer as a Ruby object, so we convert it to
+  a Ruby numeric value. */
+  if (trackings_value == Qnil) {
+    /* No, it hasn't.  Create one ourselves */
+    swig_ruby_trackings = st_init_numtable();
+    rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
+  } else {
+    swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
+  }
+
+        rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", RUBY_VALUE_METHOD_FUNC(swig_ruby_trackings_count), RUBY_VOID_METHOD_FUNC((rb_gvar_setter_t*)NULL))
+;
+}
+
+/* Add a Tracking from a C/C++ struct to a Ruby object */
+SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
+  /* Store the mapping to the global hash table. */
+  st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
+}
+
+/* Get the Ruby object that owns the specified C/C++ struct */
+SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
+  /* Now lookup the value stored in the global hash table */
+  VALUE value;
+
+  if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
+    return value;
+  } else {
+    return Qnil;
+  }
+}
+
+/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
+   is very important to remove objects once they are destroyed
+   since the same memory address may be reused later to create
+   a new object. */
+SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
+  /* Delete the object from the hash table */
+  st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
+}
+
+/* This is a helper method that unlinks a Ruby object from its
+   underlying C++ object.  This is needed if the lifetime of the
+   Ruby object is longer than the C++ object */
+SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
+  VALUE object = SWIG_RubyInstanceFor(ptr);
+
+  if (object != Qnil) {
+    if (TYPE(object) != T_DATA)
+      abort();
+    DATA_PTR(object) = 0;
+  }
+}
+
+/* This is a helper method that iterates over all the trackings
+   passing the C++ object pointer and its related Ruby object
+   to the passed callback function. */
+
+/* Proxy method to abstract the internal trackings datatype */
+      static int swig_ruby_internal_iterate_callback(st_data_t ptr, st_data_t obj, st_data_t meth) {
+        ((void(*)(void*, VALUE))meth)((void*)ptr, (VALUE)obj);
+
+  return ST_CONTINUE;
+}
+
+SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
+  st_foreach(swig_ruby_trackings, RUBY_INT_METHOD_FUNC(swig_ruby_internal_iterate_callback), (st_data_t)meth);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Ruby API portion that goes into the runtime
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGINTERN VALUE
+SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
+  if (NIL_P(target)) {
+    target = o;
+  } else {
+    if (TYPE(target) != T_ARRAY) {
+      VALUE o2 = target;
+      target = rb_ary_new();
+      rb_ary_push(target, o2);
+    }
+    rb_ary_push(target, o);
+  }
+  return target;
+}
+
+/* For ruby1.8.4 and earlier. */
+#ifndef RUBY_INIT_STACK
+   RUBY_EXTERN void Init_stack(VALUE* addr);
+#  define RUBY_INIT_STACK \
+   VALUE variable_in_this_stack_frame; \
+   Init_stack(&variable_in_this_stack_frame);
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* -----------------------------------------------------------------------------
+ * rubyrun.swg
+ *
+ * This file contains the runtime support for Ruby modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
+#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
+#define swig_owntype                                    swig_ruby_owntype
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) 		SWIG_Ruby_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
+#define SWIG_Error(code, msg)            		rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
+#define SWIG_fail                        		goto fail				 
+
+
+/* Ruby-specific SWIG API */
+
+#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
+#define SWIG_define_class(ty)                        	SWIG_Ruby_define_class(ty)
+#define SWIG_NewClassInstance(value, ty)             	SWIG_Ruby_NewClassInstance(value, ty)
+#define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
+#define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  
+
+#include "assert.h"
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  VALUE klass;
+  VALUE mImpl;
+  void  (*mark)(void *);
+  void  (*destroy)(void *);
+  int trackObjects;
+} swig_class;
+
+
+/* Global pointer used to keep some internal SWIG stuff */
+static VALUE _cSWIG_Pointer = Qnil;
+static VALUE swig_runtime_data_type_pointer = Qnil;
+
+/* Global IDs used to keep some internal SWIG stuff */
+static ID swig_arity_id = 0;
+static ID swig_call_id  = 0;
+
+/*
+  If your swig extension is to be run within an embedded ruby and has
+  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
+  This will reset ruby's stack frame on each entry point from the main 
+  program the first time a virtual director function is invoked (in a 
+  non-recursive way).
+  If this is not done, you run the risk of Ruby trashing the stack.
+*/
+
+#ifdef RUBY_EMBEDDED
+
+#  define SWIG_INIT_STACK                            \
+      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
+      ++swig_virtual_calls;
+#  define SWIG_RELEASE_STACK --swig_virtual_calls;
+#  define Ruby_DirectorTypeMismatchException(x) \
+          rb_raise( rb_eTypeError, "%s", x ); return c_result;
+
+      static unsigned int swig_virtual_calls = 0;
+
+#else  /* normal non-embedded extension */
+
+#  define SWIG_INIT_STACK
+#  define SWIG_RELEASE_STACK
+#  define Ruby_DirectorTypeMismatchException(x) \
+          throw Swig::DirectorTypeMismatchException( x );
+
+#endif  /* RUBY_EMBEDDED */
+
+
+SWIGRUNTIME VALUE 
+getExceptionClass(void) {
+  static int init = 0;
+  static VALUE rubyExceptionClass ;
+  if (!init) {
+    init = 1;
+    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
+  }
+  return rubyExceptionClass;
+} 
+
+/* This code checks to see if the Ruby object being raised as part
+   of an exception inherits from the Ruby class Exception.  If so,
+   the object is simply returned.  If not, then a new Ruby exception
+   object is created and that will be returned to Ruby.*/
+SWIGRUNTIME VALUE
+SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
+  VALUE exceptionClass = getExceptionClass();
+  if (rb_obj_is_kind_of(obj, exceptionClass)) {
+    return obj;
+  }  else {
+    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
+  }
+}
+
+/* Initialize Ruby runtime support */
+SWIGRUNTIME void
+SWIG_Ruby_InitRuntime(void)
+{
+  if (_mSWIG == Qnil) {
+    _mSWIG = rb_define_module("SWIG");
+    swig_call_id  = rb_intern("call");
+    swig_arity_id = rb_intern("arity");
+  }
+}
+
+/* Define Ruby class for C type */
+SWIGRUNTIME void
+SWIG_Ruby_define_class(swig_type_info *type)
+{
+  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+  sprintf(klass_name, "TYPE%s", type->name);
+  if (NIL_P(_cSWIG_Pointer)) {
+    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
+    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
+  }
+  rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
+  free((void *) klass_name);
+}
+
+/* Create a new pointer object */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
+{
+  int own =  flags & SWIG_POINTER_OWN; 
+  int track;
+  char *klass_name;
+  swig_class *sklass;
+  VALUE klass;
+  VALUE obj;
+  
+  if (!ptr)
+    return Qnil;
+  
+  if (type->clientdata) {
+    sklass = (swig_class *) type->clientdata;
+		
+    /* Are we tracking this class and have we already returned this Ruby object? */
+    track = sklass->trackObjects;
+    if (track) {
+      obj = SWIG_RubyInstanceFor(ptr);
+      
+      /* Check the object's type and make sure it has the correct type.
+        It might not in cases where methods do things like 
+        downcast methods. */
+      if (obj != Qnil) {
+        VALUE value = rb_iv_get(obj, "@__swigtype__");
+        const char* type_name = RSTRING_PTR(value);
+				
+        if (strcmp(type->name, type_name) == 0) {
+          return obj;
+        }
+      }
+    }
+
+    /* Create a new Ruby object */
+    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
+			   ( own ? VOIDFUNC(sklass->destroy) : 
+			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
+			     ), ptr);
+
+    /* If tracking is on for this class then track this object. */
+    if (track) {
+      SWIG_RubyAddTracking(ptr, obj);
+    }
+  } else {
+    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+    sprintf(klass_name, "TYPE%s", type->name);
+    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
+    free((void *) klass_name);
+    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
+  }
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  
+  return obj;
+}
+
+/* Create a new class instance (always owned) */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
+{
+  VALUE obj;
+  swig_class *sklass = (swig_class *) type->clientdata;
+  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  return obj;
+}
+
+/* Get type mangle from class name */
+SWIGRUNTIMEINLINE char *
+SWIG_Ruby_MangleStr(VALUE obj)
+{
+  VALUE stype = rb_iv_get(obj, "@__swigtype__");
+  return StringValuePtr(stype);
+}
+
+/* Acquire a pointer value */
+typedef struct {
+  void (*datafree)(void *);
+  int own;
+} swig_ruby_owntype;
+
+SWIGRUNTIME swig_ruby_owntype
+SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
+  swig_ruby_owntype oldown = {0, 0};
+  if (obj) {
+    oldown.datafree = RDATA(obj)->dfree;
+    RDATA(obj)->dfree = own.datafree;
+  }
+  return oldown;
+}
+
+/* Convert a pointer value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
+{
+  char *c;
+  swig_cast_info *tc;
+  void *vptr = 0;
+
+  /* Grab the pointer */
+  if (NIL_P(obj)) {
+    if (ptr)
+      *ptr = 0;
+    return SWIG_OK;
+  } else {
+    if (TYPE(obj) != T_DATA) {
+      return SWIG_ERROR;
+    }
+    Data_Get_Struct(obj, void, vptr);
+  }
+  
+  if (own) {
+    own->datafree = RDATA(obj)->dfree;
+    own->own = 0;
+  }
+    
+  /* Check to see if the input object is giving up ownership
+     of the underlying C struct or C++ object.  If so then we
+     need to reset the destructor since the Ruby object no 
+     longer owns the underlying C++ object.*/ 
+  if (flags & SWIG_POINTER_DISOWN) {
+    /* Is tracking on for this class? */
+    int track = 0;
+    if (ty && ty->clientdata) {
+      swig_class *sklass = (swig_class *) ty->clientdata;
+      track = sklass->trackObjects;
+    }
+		
+    if (track) {
+      /* We are tracking objects for this class.  Thus we change the destructor
+       * to SWIG_RubyRemoveTracking.  This allows us to
+       * remove the mapping from the C++ to Ruby object
+       * when the Ruby object is garbage collected.  If we don't
+       * do this, then it is possible we will return a reference 
+       * to a Ruby object that no longer exists thereby crashing Ruby. */
+      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
+    } else {    
+      RDATA(obj)->dfree = 0;
+    }
+  }
+
+  /* Do type-checking if type info was provided */
+  if (ty) {
+    if (ty->clientdata) {
+      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
+        if (vptr == 0) {
+          /* The object has already been deleted */
+          return SWIG_ObjectPreviouslyDeletedError;
+        }
+      }
+    }
+    if ((c = SWIG_MangleStr(obj)) == NULL) {
+      return SWIG_ERROR;
+    }
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) {
+      return SWIG_ERROR;
+    } else {
+      if (ptr) {
+        if (tc->type == ty) {
+          *ptr = vptr;
+        } else {
+          int newmemory = 0;
+          *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
+          if (newmemory == SWIG_CAST_NEW_MEMORY) {
+            assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+            if (own)
+              own->own = own->own | SWIG_CAST_NEW_MEMORY;
+          }
+        }
+      }
+    }
+  } else {
+    if (ptr)
+      *ptr = vptr;
+  }
+  
+  return SWIG_OK;
+}
+
+/* Check convert */
+SWIGRUNTIMEINLINE int
+SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
+{
+  char *c = SWIG_MangleStr(obj);
+  if (!c) return 0;
+  return SWIG_TypeCheck(c,ty) != 0;
+}
+
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r, ptr, sz);
+  strcpy(r, type->name);
+  return rb_str_new2(result);
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c;
+
+  if (TYPE(obj) != T_STRING) goto type_error;
+  c = StringValuePtr(obj);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') goto type_error;
+  c++;
+  c = SWIG_UnpackData(c, ptr, sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) goto type_error;
+  }
+  return SWIG_OK;
+
+ type_error:
+  return SWIG_ERROR;
+}
+
+SWIGRUNTIME swig_module_info *
+SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
+{
+  VALUE pointer;
+  swig_module_info *ret = 0;
+  VALUE verbose = rb_gv_get("VERBOSE");
+
+ /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
+  rb_gv_set("VERBOSE", Qfalse);
+  
+  /* first check if pointer already created */
+  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  if (pointer != Qnil) {
+    Data_Get_Struct(pointer, swig_module_info, ret);
+  }
+
+  /* reinstate warnings */
+  rb_gv_set("VERBOSE", verbose);
+  return ret;
+}
+
+SWIGRUNTIME void 
+SWIG_Ruby_SetModule(swig_module_info *pointer)
+{
+  /* register a new class */
+  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
+  /* create and store the structure pointer to a global variable */
+  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
+  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
+}
+
+/* This function can be used to check whether a proc or method or similarly
+   callable function has been passed.  Usually used in a %typecheck, like:
+
+   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
+        $result = SWIG_Ruby_isCallable( $input );
+   }
+ */
+SWIGINTERN
+int SWIG_Ruby_isCallable( VALUE proc )
+{
+  if ( rb_respond_to( proc, swig_call_id ) )
+    return 1;
+  return 0;
+}
+
+/* This function can be used to check the arity (number of arguments)
+   a proc or method can take.  Usually used in a %typecheck.
+   Valid arities will be that equal to minimal or those < 0
+   which indicate a variable number of parameters at the end.
+ */
+SWIGINTERN
+int SWIG_Ruby_arity( VALUE proc, int minimal )
+{
+  if ( rb_respond_to( proc, swig_arity_id ) )
+    {
+      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
+      int arity = NUM2INT(num);
+      if ( arity < 0 && (arity+1) < -minimal ) return 1;
+      if ( arity == minimal ) return 1;
+      return 1;
+    }
+  return 0;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
+
+
+
+  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) 
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_p_FX4Splitter swig_types[0]
+#define SWIGTYPE_p_FX7Segment swig_types[1]
+#define SWIGTYPE_p_FXAccelTable swig_types[2]
+#define SWIGTYPE_p_FXApp swig_types[3]
+#define SWIGTYPE_p_FXArrowButton swig_types[4]
+#define SWIGTYPE_p_FXBitmap swig_types[5]
+#define SWIGTYPE_p_FXBitmapFrame swig_types[6]
+#define SWIGTYPE_p_FXCURCursor swig_types[7]
+#define SWIGTYPE_p_FXCanvas swig_types[8]
+#define SWIGTYPE_p_FXColorBar swig_types[9]
+#define SWIGTYPE_p_FXColorRing swig_types[10]
+#define SWIGTYPE_p_FXColorSelector swig_types[11]
+#define SWIGTYPE_p_FXColorWell swig_types[12]
+#define SWIGTYPE_p_FXColorWheel swig_types[13]
+#define SWIGTYPE_p_FXComboBox swig_types[14]
+#define SWIGTYPE_p_FXComposite swig_types[15]
+#define SWIGTYPE_p_FXCursor swig_types[16]
+#define SWIGTYPE_p_FXDCWindow swig_types[17]
+#define SWIGTYPE_p_FXDataTarget swig_types[18]
+#define SWIGTYPE_p_FXDebugTarget swig_types[19]
+#define SWIGTYPE_p_FXDelegator swig_types[20]
+#define SWIGTYPE_p_FXDial swig_types[21]
+#define SWIGTYPE_p_FXDict swig_types[22]
+#define SWIGTYPE_p_FXDirBox swig_types[23]
+#define SWIGTYPE_p_FXDirSelector swig_types[24]
+#define SWIGTYPE_p_FXDockBar swig_types[25]
+#define SWIGTYPE_p_FXDockHandler swig_types[26]
+#define SWIGTYPE_p_FXDockSite swig_types[27]
+#define SWIGTYPE_p_FXDockTitle swig_types[28]
+#define SWIGTYPE_p_FXDocument swig_types[29]
+#define SWIGTYPE_p_FXDragCorner swig_types[30]
+#define SWIGTYPE_p_FXDrawable swig_types[31]
+#define SWIGTYPE_p_FXDriveBox swig_types[32]
+#define SWIGTYPE_p_FXFileDict swig_types[33]
+#define SWIGTYPE_p_FXFileSelector swig_types[34]
+#define SWIGTYPE_p_FXFileStream swig_types[35]
+#define SWIGTYPE_p_FXFont swig_types[36]
+#define SWIGTYPE_p_FXFontSelector swig_types[37]
+#define SWIGTYPE_p_FXFrame swig_types[38]
+#define SWIGTYPE_p_FXGIFCursor swig_types[39]
+#define SWIGTYPE_p_FXGradientBar swig_types[40]
+#define SWIGTYPE_p_FXGroupBox swig_types[41]
+#define SWIGTYPE_p_FXHeader swig_types[42]
+#define SWIGTYPE_p_FXHeaderItem swig_types[43]
+#define SWIGTYPE_p_FXHiliteStyle swig_types[44]
+#define SWIGTYPE_p_FXHorizontalFrame swig_types[45]
+#define SWIGTYPE_p_FXHorizontalSeparator swig_types[46]
+#define SWIGTYPE_p_FXIcon swig_types[47]
+#define SWIGTYPE_p_FXIconDict swig_types[48]
+#define SWIGTYPE_p_FXId swig_types[49]
+#define SWIGTYPE_p_FXImageFrame swig_types[50]
+#define SWIGTYPE_p_FXImageView swig_types[51]
+#define SWIGTYPE_p_FXKnob swig_types[52]
+#define SWIGTYPE_p_FXListBox swig_types[53]
+#define SWIGTYPE_p_FXMainWindow swig_types[54]
+#define SWIGTYPE_p_FXMatrix swig_types[55]
+#define SWIGTYPE_p_FXMemoryStream swig_types[56]
+#define SWIGTYPE_p_FXObject swig_types[57]
+#define SWIGTYPE_p_FXPacker swig_types[58]
+#define SWIGTYPE_p_FXPopup swig_types[59]
+#define SWIGTYPE_p_FXProgressBar swig_types[60]
+#define SWIGTYPE_p_FXRealSlider swig_types[61]
+#define SWIGTYPE_p_FXRealSpinner swig_types[62]
+#define SWIGTYPE_p_FXRecentFiles swig_types[63]
+#define SWIGTYPE_p_FXRegion swig_types[64]
+#define SWIGTYPE_p_FXRegistry swig_types[65]
+#define SWIGTYPE_p_FXRootWindow swig_types[66]
+#define SWIGTYPE_p_FXRuler swig_types[67]
+#define SWIGTYPE_p_FXRulerView swig_types[68]
+#define SWIGTYPE_p_FXScrollArea swig_types[69]
+#define SWIGTYPE_p_FXScrollBar swig_types[70]
+#define SWIGTYPE_p_FXScrollCorner swig_types[71]
+#define SWIGTYPE_p_FXScrollWindow swig_types[72]
+#define SWIGTYPE_p_FXSeparator swig_types[73]
+#define SWIGTYPE_p_FXSettings swig_types[74]
+#define SWIGTYPE_p_FXShell swig_types[75]
+#define SWIGTYPE_p_FXShutter swig_types[76]
+#define SWIGTYPE_p_FXShutterItem swig_types[77]
+#define SWIGTYPE_p_FXSlider swig_types[78]
+#define SWIGTYPE_p_FXSpinner swig_types[79]
+#define SWIGTYPE_p_FXSplashWindow swig_types[80]
+#define SWIGTYPE_p_FXSplitter swig_types[81]
+#define SWIGTYPE_p_FXSpring swig_types[82]
+#define SWIGTYPE_p_FXStatusBar swig_types[83]
+#define SWIGTYPE_p_FXStatusLine swig_types[84]
+#define SWIGTYPE_p_FXStream swig_types[85]
+#define SWIGTYPE_p_FXStringDict swig_types[86]
+#define SWIGTYPE_p_FXSwitcher swig_types[87]
+#define SWIGTYPE_p_FXTabBar swig_types[88]
+#define SWIGTYPE_p_FXTabBook swig_types[89]
+#define SWIGTYPE_p_FXText swig_types[90]
+#define SWIGTYPE_p_FXTextChange swig_types[91]
+#define SWIGTYPE_p_FXTextField swig_types[92]
+#define SWIGTYPE_p_FXToolBar swig_types[93]
+#define SWIGTYPE_p_FXToolBarGrip swig_types[94]
+#define SWIGTYPE_p_FXToolBarShell swig_types[95]
+#define SWIGTYPE_p_FXToolBarTab swig_types[96]
+#define SWIGTYPE_p_FXToolTip swig_types[97]
+#define SWIGTYPE_p_FXTopWindow swig_types[98]
+#define SWIGTYPE_p_FXTranslator swig_types[99]
+#define SWIGTYPE_p_FXTreeListBox swig_types[100]
+#define SWIGTYPE_p_FXVerticalFrame swig_types[101]
+#define SWIGTYPE_p_FXVerticalSeparator swig_types[102]
+#define SWIGTYPE_p_FXVisual swig_types[103]
+#define SWIGTYPE_p_FXWindow swig_types[104]
+#define SWIGTYPE_p_char swig_types[105]
+#define SWIGTYPE_p_double swig_types[106]
+#define SWIGTYPE_p_float swig_types[107]
+#define SWIGTYPE_p_int swig_types[108]
+#define SWIGTYPE_p_long swig_types[109]
+#define SWIGTYPE_p_short swig_types[110]
+#define SWIGTYPE_p_unsigned_char swig_types[111]
+#define SWIGTYPE_p_unsigned_int swig_types[112]
+#define SWIGTYPE_p_unsigned_long swig_types[113]
+#define SWIGTYPE_p_unsigned_short swig_types[114]
+static swig_type_info *swig_types[116];
+static swig_module_info swig_module = {swig_types, 115, 0, 0, 0, 0};
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
+
+/* -------- TYPES TABLE (END) -------- */
+
+#define SWIG_init    Init_text
+#define SWIG_name    "Text"
+
+
+
+#define SWIG_RUBY_THREAD_BEGIN_BLOCK
+#define SWIG_RUBY_THREAD_END_BLOCK
+
+
+#define SWIGVERSION 0x030012 
+#define SWIG_VERSION SWIGVERSION
+
+
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
+
+
+#include <stdexcept>
+
+
+#include "FXRbCommon.h"
+
+
+inline FXColor to_FXColor(VALUE obj){
+  if(TYPE(obj)==T_STRING){
+    return fxcolorfromname(StringValuePtr(obj));
+    }
+  else if(TYPE(obj)==T_SYMBOL){
+    return fxcolorfromname(rb_id2name(SYM2ID(obj)));
+    }
+  else{
+    return NUM2ULONG(obj);
+    }
+  }
+
+
+inline FXString to_FXString(VALUE obj){
+  if(!NIL_P(obj)){
+    Check_Type(obj,T_STRING);
+    return FXString(StringValuePtr(obj));
+    }
+  else{
+    return FXString::null;
+    }
+  }
+
+
+inline FXbool to_FXbool(VALUE obj){
+  if (obj == Qtrue || obj == Qfalse){
+    return (obj == Qtrue) ? TRUE : FALSE;
+    }
+  else{
+    return static_cast<FXbool>(NUM2UINT(obj));
+    }
+  }
+
+
+static swig_type_info* FXEventTypeInfo=0;
+
+inline void* to_FXEvent(VALUE obj){
+  void* ptr;
+  if(!FXEventTypeInfo){
+    FXEventTypeInfo=SWIG_TypeQuery("FXEvent *");
+    FXASSERT(FXEventTypeInfo!=0);
+    }
+  SWIG_ConvertPtr(obj,&ptr,FXEventTypeInfo,1);
+  return ptr;
+  }
+
+
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
+
+
+  #define SWIG_From_long   LONG2NUM 
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_int  (int value)
+{    
+  return SWIG_From_long  (value);
+}
+
+SWIGINTERN FXHiliteStyle *new_FXHiliteStyle(){
+			FXHiliteStyle *self = new FXHiliteStyle();
+			self->normalForeColor = 0;
+			self->normalBackColor = 0;
+			self->selectForeColor = 0;
+			self->selectBackColor = 0;
+			self->hiliteForeColor = 0;
+			self->hiliteBackColor = 0;
+			self->activeBackColor = 0;
+			self->style = 0;
+			return self;
+			}
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_long  (unsigned long value)
+{
+  return ULONG2NUM(value); 
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_int  (unsigned int value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+SWIGINTERN VALUE FXTextChange_ins(FXTextChange const *self){
+      return to_ruby(self->ins,self->nins);
+      }
+SWIGINTERN VALUE FXTextChange_del(FXTextChange const *self){
+      return to_ruby(self->del,self->ndel);
+      }
+
+SWIGINTERN swig_type_info*
+SWIG_pchar_descriptor(void)
+{
+  static int init = 0;
+  static swig_type_info* info = 0;
+  if (!init) {
+    info = SWIG_TypeQuery("_p_char");
+    init = 1;
+  }
+  return info;
+}
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+  if (carray) {
+    if (size > LONG_MAX) {
+      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+      return pchar_descriptor ? 
+	SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : Qnil;
+    } else {
+      return rb_str_new(carray, static_cast< long >(size));
+    }
+  } else {
+    return Qnil;
+  }
+}
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtr(const char *cptr)
+{ 
+  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
+}
+
+SWIGINTERN FXText *new_FXText(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=3,FXint pr=3,FXint pt=2,FXint pb=2){
+      return new FXRbText(p,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
+{
+  if (TYPE(obj) == T_STRING) {
+    char *cstr = StringValuePtr(obj); 
+    size_t size = RSTRING_LEN(obj) + 1;
+    if (cptr)  {
+      if (alloc) {
+	if (*alloc == SWIG_NEWOBJ) {
+	  *cptr = reinterpret_cast< char* >(memcpy(new char[size], cstr, sizeof(char)*(size)));
+	} else {
+	  *cptr = cstr;
+	  *alloc = SWIG_OLDOBJ;
+	}
+      }
+    }
+    if (psize) *psize = size;
+    return SWIG_OK;
+  } else {
+    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+    if (pchar_descriptor) {
+      void* vptr = 0;
+      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
+	if (cptr) *cptr = (char *)vptr;
+	if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
+	if (alloc) *alloc = SWIG_OLDOBJ;
+	return SWIG_OK;
+      }
+    }
+  }  
+  return SWIG_TypeError;
+}
+
+
+
+
+SWIGINTERN VALUE FXText_extractText(FXText const *self,FXint pos,FXint n){
+      VALUE str;
+      FXString buffer;
+      self->extractText(buffer,pos,n);
+      str=to_ruby(buffer.text(),n);
+      return str;
+      }
+SWIGINTERN VALUE FXText_extractStyle(FXText const *self,FXint pos,FXint n){
+      FXString style;
+      VALUE str=Qnil;
+      if(self->isStyled()){
+        self->extractStyle(style,pos,n);
+        str=to_ruby(style.text(),n);
+        }
+      return str;
+      }
+SWIGINTERN VALUE FXText_findText(FXText *self,FXString const &string,FXint start=0,FXuint flags=SEARCH_FORWARD|SEARCH_WRAP|SEARCH_EXACT){
+      FXint* beg;
+      FXint* end;
+      VALUE ary=Qnil;
+      FXint ngroups = flags&SEARCH_REGEX ? string.contains('(')+1 : 1;  // FIXME: is this right?
+      if(!FXMALLOC(&beg,FXint,ngroups)){
+        return Qnil;
+      }
+      if(!FXMALLOC(&end,FXint,ngroups)){
+        FXFREE(&beg);
+        return Qnil;
+      }
+      if(self->findText(string,beg,end,start,flags,ngroups)){
+        ary=rb_ary_new();
+        rb_ary_push(ary,FXRbMakeArray(beg,ngroups));
+        rb_ary_push(ary,FXRbMakeArray(end,ngroups));
+      }
+      FXFREE(&beg);
+      FXFREE(&end);
+      return ary;
+    }
+SWIGINTERN void FXText_setHiliteStyles(FXText *self,VALUE styles){
+      if(self->isMemberOf(FXMETACLASS(FXRbText))){
+        FXRbText *text=dynamic_cast<FXRbText*>(self);
+	FXASSERT(text);
+        Check_Type(styles,T_ARRAY);
+	if(text->numStyles>0){
+	  delete [] text->styles;
+	  text->numStyles=0;
+	  }
+	text->numStyles=RARRAY_LEN(styles);
+	if(text->numStyles>0){
+          text->styles=new FXHiliteStyle[text->numStyles];
+          for (long i=0; i<text->numStyles; i++){
+            FXHiliteStyle* ptr;
+	    SWIG_ConvertPtr(rb_ary_entry(styles,i),(void **)&ptr,SWIGTYPE_p_FXHiliteStyle,1);
+            text->styles[i]=*ptr;
+            }
+	  self->setHiliteStyles(text->styles);
+	  }
+	}
+      else{
+        rb_notimplement();
+        }
+      }
+SWIGINTERN VALUE FXText_getHiliteStyles(FXText const *self){
+      if(self->isMemberOf(FXMETACLASS(FXRbText))){
+        const FXRbText* text=dynamic_cast<const FXRbText*>(self);
+	FXASSERT(text);
+        VALUE ary=rb_ary_new();
+        for(FXint i=0; i<text->numStyles; i++){
+	  rb_ary_push(ary,FXRbGetRubyObj(&(text->styles[i]),"FXHiliteStyle *"));
+	  }
+	return ary;
+	}
+      else{
+        rb_notimplement();
+	return Qnil; // not reached
+        }
+      }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_bool  (bool value)
+{
+  return value ? Qtrue : Qfalse;
+}
+
+SWIGINTERN VALUE FXText_position__SWIG_1(FXText const *self){
+    FXint x, y;
+    self->getPosition(x, y);
+    VALUE pos = rb_ary_new();
+    rb_ary_push(pos, INT2NUM(x));
+    rb_ary_push(pos, INT2NUM(y));
+    return pos;
+  }
+
+SWIGINTERN VALUE
+SWIG_ruby_failed(VALUE, VALUE)
+{
+  return Qnil;
+} 
+
+
+/*@SWIG:/usr/share/swig3.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE pargs){VALUE *args=(VALUE *)pargs;
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  long *res = (long *)(args[1]);
+  *res = type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj);
+  return obj;
+}
+/*@SWIG@*/
+
+SWIGINTERN int
+SWIG_AsVal_long (VALUE obj, long* val)
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
+    long v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_VALUE_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_VALUE_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_int (VALUE obj, int *val)
+{
+  long v;
+  int res = SWIG_AsVal_long (obj, &v);
+  if (SWIG_IsOK(res)) {
+    if ((v < INT_MIN || v > INT_MAX)) {
+      return SWIG_OverflowError;
+    } else {
+      if (val) *val = static_cast< int >(v);
+    }
+  }  
+  return res;
+}
+
+static swig_class SwigClassFXHiliteStyle;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXHiliteStyle_allocate(VALUE self)
+#else
+_wrap_FXHiliteStyle_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXHiliteStyle);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXHiliteStyle(int argc, VALUE *argv, VALUE self) {
+  FXHiliteStyle *result = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  result = (FXHiliteStyle *)new_FXHiliteStyle();
+  DATA_PTR(self) = result;
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHiliteStyle_normalForeColor_set(int argc, VALUE *argv, VALUE self) {
+  FXHiliteStyle *arg1 = (FXHiliteStyle *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHiliteStyle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHiliteStyle *","normalForeColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHiliteStyle * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (arg1) (arg1)->normalForeColor = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHiliteStyle_normalForeColor_get(int argc, VALUE *argv, VALUE self) {
+  FXHiliteStyle *arg1 = (FXHiliteStyle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHiliteStyle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHiliteStyle *","normalForeColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHiliteStyle * >(argp1);
+  result = (FXColor) ((arg1)->normalForeColor);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHiliteStyle_normalBackColor_set(int argc, VALUE *argv, VALUE self) {
+  FXHiliteStyle *arg1 = (FXHiliteStyle *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHiliteStyle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHiliteStyle *","normalBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHiliteStyle * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (arg1) (arg1)->normalBackColor = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHiliteStyle_normalBackColor_get(int argc, VALUE *argv, VALUE self) {
+  FXHiliteStyle *arg1 = (FXHiliteStyle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHiliteStyle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHiliteStyle *","normalBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHiliteStyle * >(argp1);
+  result = (FXColor) ((arg1)->normalBackColor);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHiliteStyle_selectForeColor_set(int argc, VALUE *argv, VALUE self) {
+  FXHiliteStyle *arg1 = (FXHiliteStyle *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHiliteStyle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHiliteStyle *","selectForeColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHiliteStyle * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (arg1) (arg1)->selectForeColor = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHiliteStyle_selectForeColor_get(int argc, VALUE *argv, VALUE self) {
+  FXHiliteStyle *arg1 = (FXHiliteStyle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHiliteStyle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHiliteStyle *","selectForeColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHiliteStyle * >(argp1);
+  result = (FXColor) ((arg1)->selectForeColor);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHiliteStyle_selectBackColor_set(int argc, VALUE *argv, VALUE self) {
+  FXHiliteStyle *arg1 = (FXHiliteStyle *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHiliteStyle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHiliteStyle *","selectBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHiliteStyle * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (arg1) (arg1)->selectBackColor = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHiliteStyle_selectBackColor_get(int argc, VALUE *argv, VALUE self) {
+  FXHiliteStyle *arg1 = (FXHiliteStyle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHiliteStyle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHiliteStyle *","selectBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHiliteStyle * >(argp1);
+  result = (FXColor) ((arg1)->selectBackColor);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHiliteStyle_hiliteForeColor_set(int argc, VALUE *argv, VALUE self) {
+  FXHiliteStyle *arg1 = (FXHiliteStyle *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHiliteStyle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHiliteStyle *","hiliteForeColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHiliteStyle * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (arg1) (arg1)->hiliteForeColor = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHiliteStyle_hiliteForeColor_get(int argc, VALUE *argv, VALUE self) {
+  FXHiliteStyle *arg1 = (FXHiliteStyle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHiliteStyle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHiliteStyle *","hiliteForeColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHiliteStyle * >(argp1);
+  result = (FXColor) ((arg1)->hiliteForeColor);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHiliteStyle_hiliteBackColor_set(int argc, VALUE *argv, VALUE self) {
+  FXHiliteStyle *arg1 = (FXHiliteStyle *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHiliteStyle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHiliteStyle *","hiliteBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHiliteStyle * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (arg1) (arg1)->hiliteBackColor = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHiliteStyle_hiliteBackColor_get(int argc, VALUE *argv, VALUE self) {
+  FXHiliteStyle *arg1 = (FXHiliteStyle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHiliteStyle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHiliteStyle *","hiliteBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHiliteStyle * >(argp1);
+  result = (FXColor) ((arg1)->hiliteBackColor);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHiliteStyle_activeBackColor_set(int argc, VALUE *argv, VALUE self) {
+  FXHiliteStyle *arg1 = (FXHiliteStyle *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHiliteStyle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHiliteStyle *","activeBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHiliteStyle * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  if (arg1) (arg1)->activeBackColor = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHiliteStyle_activeBackColor_get(int argc, VALUE *argv, VALUE self) {
+  FXHiliteStyle *arg1 = (FXHiliteStyle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHiliteStyle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHiliteStyle *","activeBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHiliteStyle * >(argp1);
+  result = (FXColor) ((arg1)->activeBackColor);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHiliteStyle_style_set(int argc, VALUE *argv, VALUE self) {
+  FXHiliteStyle *arg1 = (FXHiliteStyle *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHiliteStyle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHiliteStyle *","style", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHiliteStyle * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (arg1) (arg1)->style = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXHiliteStyle_style_get(int argc, VALUE *argv, VALUE self) {
+  FXHiliteStyle *arg1 = (FXHiliteStyle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXHiliteStyle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXHiliteStyle *","style", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXHiliteStyle * >(argp1);
+  result = (FXuint) ((arg1)->style);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN void
+free_FXHiliteStyle(void *self) {
+    FXHiliteStyle *arg1 = (FXHiliteStyle *)self;
+    delete arg1;
+}
+
+static swig_class SwigClassFXTextChange;
+
+SWIGINTERN VALUE
+_wrap_FXTextChange_pos_set(int argc, VALUE *argv, VALUE self) {
+  FXTextChange *arg1 = (FXTextChange *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextChange, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextChange *","pos", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextChange * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->pos = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextChange_pos_get(int argc, VALUE *argv, VALUE self) {
+  FXTextChange *arg1 = (FXTextChange *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextChange, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextChange *","pos", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextChange * >(argp1);
+  result = (FXint) ((arg1)->pos);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextChange_ndel_set(int argc, VALUE *argv, VALUE self) {
+  FXTextChange *arg1 = (FXTextChange *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextChange, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextChange *","ndel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextChange * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->ndel = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextChange_ndel_get(int argc, VALUE *argv, VALUE self) {
+  FXTextChange *arg1 = (FXTextChange *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextChange, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextChange *","ndel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextChange * >(argp1);
+  result = (FXint) ((arg1)->ndel);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextChange_nins_set(int argc, VALUE *argv, VALUE self) {
+  FXTextChange *arg1 = (FXTextChange *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextChange, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextChange *","nins", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextChange * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (arg1) (arg1)->nins = arg2;
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextChange_nins_get(int argc, VALUE *argv, VALUE self) {
+  FXTextChange *arg1 = (FXTextChange *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextChange, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextChange *","nins", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextChange * >(argp1);
+  result = (FXint) ((arg1)->nins);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextChange_ins(int argc, VALUE *argv, VALUE self) {
+  FXTextChange *arg1 = (FXTextChange *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextChange, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextChange const *","ins", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextChange * >(argp1);
+  result = (VALUE)FXTextChange_ins((FXTextChange const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTextChange_del(int argc, VALUE *argv, VALUE self) {
+  FXTextChange *arg1 = (FXTextChange *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTextChange, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTextChange const *","del", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTextChange * >(argp1);
+  result = (VALUE)FXTextChange_del((FXTextChange const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXText;
+
+SWIGINTERN VALUE
+_wrap_FXText_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onFocusIn(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onFocusIn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusIn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusIn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onFocusOut(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onFocusOut", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusOut", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusOut(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onMiddleBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onMiddleBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMiddleBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMiddleBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onMiddleBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onMiddleBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMiddleBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMiddleBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onRightBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onRightBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onRightBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onRightBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onRightBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onRightBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onBeginDrag(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onBeginDrag", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onBeginDrag", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onBeginDrag(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onEndDrag(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onEndDrag", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEndDrag", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEndDrag(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onDragged(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onDragged", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDragged", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDragged(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onDNDEnter(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onDNDEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onDNDLeave(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onDNDLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onDNDMotion(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onDNDMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onDNDDrop(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onDNDDrop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDDrop", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDDrop(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onDNDRequest(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onDNDRequest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDRequest", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDRequest(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onSelectionLost(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onSelectionLost", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSelectionLost", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onSelectionLost(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onSelectionGained(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onSelectionGained", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSelectionGained", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onSelectionGained(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onSelectionRequest(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onSelectionRequest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onSelectionRequest", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onSelectionRequest(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onClipboardLost(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onClipboardLost", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClipboardLost", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onClipboardLost(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onClipboardGained(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onClipboardGained", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClipboardGained", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onClipboardGained(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onClipboardRequest(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onClipboardRequest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClipboardRequest", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onClipboardRequest(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onBlink(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onBlink", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onBlink", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onBlink(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onFlash(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onFlash", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFlash", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onFlash(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onAutoScroll(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onAutoScroll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onAutoScroll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onAutoScroll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdToggleEditable(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdToggleEditable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdToggleEditable", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdToggleEditable(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onUpdToggleEditable(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onUpdToggleEditable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdToggleEditable", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdToggleEditable(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdToggleOverstrike(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdToggleOverstrike", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdToggleOverstrike", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdToggleOverstrike(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onUpdToggleOverstrike(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onUpdToggleOverstrike", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdToggleOverstrike", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdToggleOverstrike(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdCursorRow(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdCursorRow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorRow", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorRow(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onUpdCursorRow(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onUpdCursorRow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdCursorRow", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdCursorRow(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdCursorColumn(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdCursorColumn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorColumn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorColumn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onUpdCursorColumn(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onUpdCursorColumn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdCursorColumn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdCursorColumn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onUpdHaveSelection(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onUpdHaveSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdHaveSelection", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdHaveSelection(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onUpdSelectAll(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onUpdSelectAll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSelectAll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdSelectAll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdSetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdSetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdGetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdGetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdSearch(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdSearch", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSearch", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSearch(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdReplace(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdReplace", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdReplace", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdReplace(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdSearchNext(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdSearchNext", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSearchNext", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSearchNext(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdSearchSel(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdSearchSel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSearchSel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSearchSel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdCursorTop(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdCursorTop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorTop", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorTop(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdCursorBottom(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdCursorBottom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorBottom", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorBottom(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdCursorHome(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdCursorHome", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorHome", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorHome(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdCursorEnd(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdCursorEnd", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorEnd", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorEnd(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdCursorRight(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdCursorRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorRight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorRight(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdCursorLeft(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdCursorLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorLeft", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorLeft(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdCursorUp(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdCursorUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdCursorDown(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdCursorDown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorDown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorDown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdCursorWordLeft(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdCursorWordLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorWordLeft", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorWordLeft(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdCursorWordRight(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdCursorWordRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorWordRight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorWordRight(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdCursorWordStart(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdCursorWordStart", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorWordStart", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorWordStart(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdCursorWordEnd(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdCursorWordEnd", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorWordEnd", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorWordEnd(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdCursorPageDown(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdCursorPageDown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorPageDown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorPageDown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdCursorPageUp(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdCursorPageUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorPageUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorPageUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdCursorScreenTop(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdCursorScreenTop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorScreenTop", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorScreenTop(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdCursorScreenBottom(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdCursorScreenBottom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorScreenBottom", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorScreenBottom(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdCursorScreenCenter(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdCursorScreenCenter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorScreenCenter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorScreenCenter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdCursorParHome(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdCursorParHome", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorParHome", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorParHome(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdCursorParEnd(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdCursorParEnd", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCursorParEnd", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCursorParEnd(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdBlockBeg(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdBlockBeg", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdBlockBeg", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdBlockBeg(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdBlockEnd(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdBlockEnd", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdBlockEnd", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdBlockEnd(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdGotoMatching(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdGotoMatching", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGotoMatching", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGotoMatching(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdGotoSelected(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdGotoSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGotoSelected", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGotoSelected(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdGotoLine(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdGotoLine", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGotoLine", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGotoLine(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdScrollUp(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdScrollUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdScrollUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdScrollUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdScrollDown(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdScrollDown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdScrollDown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdScrollDown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdMark(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdMark", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMark", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdMark(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdExtend(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdExtend", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdExtend", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdExtend(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdOverstString(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdOverstString", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdOverstString", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdOverstString", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdOverstString(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdInsertString(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdInsertString", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdInsertString", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = static_cast<void*>(StringValuePtr(argv[2]));
+  result = (long)(arg1)->onCmdInsertString(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdInsertNewline(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdInsertNewline", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdInsertNewline", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdInsertNewline(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdInsertTab(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdInsertTab", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdInsertTab", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdInsertTab(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdCutSel(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdCutSel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCutSel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCutSel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdCopySel(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdCopySel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCopySel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCopySel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdPasteSel(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdPasteSel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdPasteSel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdPasteSel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdDeleteSel(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdDeleteSel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDeleteSel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDeleteSel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdChangeCase(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdChangeCase", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdChangeCase", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdChangeCase(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdShiftText(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdShiftText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdShiftText", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdShiftText(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdPasteMiddle(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdPasteMiddle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdPasteMiddle", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdPasteMiddle(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdSelectChar(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdSelectChar", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSelectChar", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSelectChar(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdSelectWord(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdSelectWord", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSelectWord", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSelectWord(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdSelectLine(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdSelectLine", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSelectLine", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSelectLine(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdSelectAll(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdSelectAll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSelectAll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSelectAll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdSelectMatching(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdSelectMatching", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSelectMatching", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSelectMatching(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdSelectBlock(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdSelectBlock", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSelectBlock", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSelectBlock(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdDeselectAll(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdDeselectAll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDeselectAll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDeselectAll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdBackspace(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdBackspace", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdBackspace", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdBackspace(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdBackspaceWord(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdBackspaceWord", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdBackspaceWord", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdBackspaceWord(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdBackspaceBol(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdBackspaceBol", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdBackspaceBol", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdBackspaceBol(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdDelete(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdDelete", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDelete", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDelete(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdDeleteWord(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdDeleteWord", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDeleteWord", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDeleteWord(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdDeleteEol(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdDeleteEol", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDeleteEol", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDeleteEol(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdDeleteAll(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdDeleteAll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDeleteAll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDeleteAll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_onCmdDeleteLine(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","onCmdDeleteLine", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDeleteLine", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDeleteLine(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_textDelimiters_get(VALUE self) {
+  VALUE _val;
+  
+  _val = SWIG_FromCharPtr(FXText::textDelimiters);
+  return _val;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXText_allocate(VALUE self)
+#else
+_wrap_FXText_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXText);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXText(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 3 ;
+  FXint arg10 = (FXint) 3 ;
+  FXint arg11 = (FXint) 2 ;
+  FXint arg12 = (FXint) 2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXText *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXText", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXText", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXText *)new_FXText(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setMarginTop(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setMarginTop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setMarginTop(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getMarginTop(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getMarginTop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)((FXText const *)arg1)->getMarginTop();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setMarginBottom(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setMarginBottom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setMarginBottom(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getMarginBottom(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getMarginBottom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)((FXText const *)arg1)->getMarginBottom();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setMarginLeft(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setMarginLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setMarginLeft(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getMarginLeft(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getMarginLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)((FXText const *)arg1)->getMarginLeft();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setMarginRight(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setMarginRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setMarginRight(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getMarginRight(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getMarginRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)((FXText const *)arg1)->getMarginRight();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getWrapColumns(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getWrapColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)((FXText const *)arg1)->getWrapColumns();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setWrapColumns(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setWrapColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setWrapColumns(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getTabColumns(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getTabColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)((FXText const *)arg1)->getTabColumns();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setTabColumns(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setTabColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setTabColumns(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getBarColumns(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getBarColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)((FXText const *)arg1)->getBarColumns();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setBarColumns(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setBarColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setBarColumns(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_isModified(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","isModified", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXbool)((FXText const *)arg1)->isModified();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setModified(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setModified", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->setModified(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setEditable(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setEditable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->setEditable(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_isEditable(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","isEditable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXbool)((FXText const *)arg1)->isEditable();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_overstrikee___(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setOverstrike", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->setOverstrike(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_overstrikeq___(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","isOverstrike", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXbool)((FXText const *)arg1)->isOverstrike();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setStyled(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setStyled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->setStyled(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_isStyled(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","isStyled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXbool)((FXText const *)arg1)->isStyled();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setDelimiters(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXchar *arg2 = (FXchar *) FXText::textDelimiters ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setDelimiters", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  if (argc > 0) {
+    arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  }
+  (arg1)->setDelimiters((FXchar const *)arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getDelimiters(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getDelimiters", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXchar *)((FXText const *)arg1)->getDelimiters();
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setFont(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  (arg1)->setFont(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getFont(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXFont *)((FXText const *)arg1)->getFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setTextColor(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getTextColor(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXColor)((FXText const *)arg1)->getTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelBackColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXColor)((FXText const *)arg1)->getSelBackColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXColor)((FXText const *)arg1)->getSelTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setHiliteTextColor(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setHiliteTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setHiliteTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getHiliteTextColor(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getHiliteTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXColor)((FXText const *)arg1)->getHiliteTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setHiliteBackColor(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setHiliteBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setHiliteBackColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getHiliteBackColor(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getHiliteBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXColor)((FXText const *)arg1)->getHiliteBackColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setActiveBackColor(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setActiveBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setActiveBackColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getActiveBackColor(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getActiveBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXColor)((FXText const *)arg1)->getActiveBackColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setCursorColor(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setCursorColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setCursorColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getCursorColor(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getCursorColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXColor)((FXText const *)arg1)->getCursorColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setNumberColor(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setNumberColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setNumberColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getNumberColor(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getNumberColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXColor)((FXText const *)arg1)->getNumberColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setBarColor(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setBarColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setBarColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getBarColor(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getBarColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXColor)((FXText const *)arg1)->getBarColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = ((FXText const *)arg1)->getHelpText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setTipText(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getTipText(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = ((FXText const *)arg1)->getTipText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getByte(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getByte", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)((FXText const *)arg1)->getByte(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getChar(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXwchar result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getChar", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXwchar)((FXText const *)arg1)->getChar(arg2);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getCharLen(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getCharLen", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)((FXText const *)arg1)->getCharLen(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getStyle(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)((FXText const *)arg1)->getStyle(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_extractText(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","extractText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (VALUE)FXText_extractText((FXText const *)arg1,arg2,arg3);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_extractStyle(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","extractStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (VALUE)FXText_extractStyle((FXText const *)arg1,arg2,arg3);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getText(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = ((FXText const *)arg1)->getText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getLength(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getLength", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)((FXText const *)arg1)->getLength();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_numRows(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getNumRows", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)((FXText const *)arg1)->getNumRows();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_shiftText(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXbool arg5 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","shiftText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  if (argc > 3) {
+    arg5 = to_FXbool(argv[3]);
+  }
+  result = (FXint)(arg1)->shiftText(arg2,arg3,arg4,arg5);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_findText(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXString *arg2 = 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXuint arg4 = (FXuint) SEARCH_FORWARD|SEARCH_WRAP|SEARCH_EXACT ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","findText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2UINT(argv[2]);
+  }
+  result = (VALUE)FXText_findText(arg1,(FXString const &)*arg2,arg3,arg4);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_isPosSelected(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","isPosSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXbool)((FXText const *)arg1)->isPosSelected(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_isPosVisible(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","isPosVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXbool)((FXText const *)arg1)->isPosVisible(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getPosAt(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getPosAt", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXint)((FXText const *)arg1)->getPosAt(arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_countRows(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","countRows", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXint)((FXText const *)arg1)->countRows(arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_countCols(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","countCols", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXint)((FXText const *)arg1)->countCols(arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_countLines(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","countLines", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXint)((FXText const *)arg1)->countLines(arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_lineStart(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","lineStart", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)((FXText const *)arg1)->lineStart(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_lineEnd(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","lineEnd", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)((FXText const *)arg1)->lineEnd(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_nextLine(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXint arg3 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","nextLine", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  result = (FXint)((FXText const *)arg1)->nextLine(arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_prevLine(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXint arg3 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","prevLine", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  result = (FXint)((FXText const *)arg1)->prevLine(arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_rowStart(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","rowStart", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)((FXText const *)arg1)->rowStart(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_rowEnd(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","rowEnd", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)((FXText const *)arg1)->rowEnd(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_nextRow(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXint arg3 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","nextRow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  result = (FXint)((FXText const *)arg1)->nextRow(arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_prevRow(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXint arg3 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","prevRow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  result = (FXint)((FXText const *)arg1)->prevRow(arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_leftWord(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","leftWord", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)((FXText const *)arg1)->leftWord(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_rightWord(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","rightWord", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)((FXText const *)arg1)->rightWord(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_wordStart(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","wordStart", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)((FXText const *)arg1)->wordStart(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_wordEnd(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","wordEnd", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)((FXText const *)arg1)->wordEnd(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_validPos(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","validPos", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)((FXText const *)arg1)->validPos(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_dec(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","dec", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)((FXText const *)arg1)->dec(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_inc(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","inc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)((FXText const *)arg1)->inc(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setTopLine(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setTopLine", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setTopLine(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getTopLine(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getTopLine", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)((FXText const *)arg1)->getTopLine();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setBottomLine(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setBottomLine", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setBottomLine(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getBottomLine(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getBottomLine", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)((FXText const *)arg1)->getBottomLine();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setCenterLine(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setCenterLine", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setCenterLine(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setAnchorPos(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setAnchorPos", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setAnchorPos(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getAnchorPos(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getAnchorPos", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)((FXText const *)arg1)->getAnchorPos();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setCursorRow(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setCursorRow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setCursorRow(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getCursorRow(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getCursorRow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)((FXText const *)arg1)->getCursorRow();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setCursorColumn(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setCursorColumn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setCursorColumn(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getCursorColumn(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getCursorColumn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)((FXText const *)arg1)->getCursorColumn();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getCursorPos(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getCursorPos", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)((FXText const *)arg1)->getCursorPos();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getSelStartPos(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getSelStartPos", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)((FXText const *)arg1)->getSelStartPos();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getSelEndPos(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getSelEndPos", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)((FXText const *)arg1)->getSelEndPos();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_selectAll(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","selectAll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)(arg1)->selectAll(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setSelection(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  result = (FXbool)(arg1)->setSelection(arg2,arg3,arg4);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setHighlight(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setHighlight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXbool)(arg1)->setHighlight(arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_killHighlight(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","killHighlight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXbool)(arg1)->killHighlight();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_makePositionVisible(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","makePositionVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->makePositionVisible(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setTextStyle(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setTextStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setTextStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getTextStyle(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getTextStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXuint)((FXText const *)arg1)->getTextStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setVisibleRows(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setVisibleRows", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setVisibleRows(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getVisibleRows(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getVisibleRows", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)((FXText const *)arg1)->getVisibleRows();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setVisibleColumns(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setVisibleColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setVisibleColumns(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getVisibleColumns(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getVisibleColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)((FXText const *)arg1)->getVisibleColumns();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setHiliteMatchTime(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setHiliteMatchTime", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setHiliteMatchTime(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getHiliteMatchTime(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getHiliteMatchTime", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXuint)((FXText const *)arg1)->getHiliteMatchTime();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setHiliteStyles(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setHiliteStyles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = argv[0];
+  FXText_setHiliteStyles(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getHiliteStyles(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","getHiliteStyles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (VALUE)FXText_getHiliteStyles((FXText const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_save(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXText_save((FXText const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_load(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXText_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_create(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  FXText_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_detach(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  FXText_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_destroy(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  FXText_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_resize(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXText_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)FXText_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)FXText_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXText_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXText_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (bool)FXText_canFocus((FXText const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  FXText_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  FXText_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXText_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXText_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_enable(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  FXText_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_disable(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  FXText_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  FXText_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_lower(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  FXText_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_move(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXText_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXText_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_layout(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  FXText_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_recalc(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  FXText_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_reparent(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXText_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_show(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  FXText_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_hide(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  FXText_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (bool)FXText_isComposite((FXText const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_contains(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXText_contains((FXText const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (bool)FXText_doesSaveUnder((FXText const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXText_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_tr(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXText_tr((FXText const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  FXText_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  FXText_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXText_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXText_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXText_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXText_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXText, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXText_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXText, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXText_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXText, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXText_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  FXText_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getViewportHeight(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","getViewportHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)FXText_getViewportHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getViewportWidth(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","getViewportWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)FXText_getViewportWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getContentHeight(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","getContentHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)FXText_getContentHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_getContentWidth(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","getContentWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (FXint)FXText_getContentWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText const *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  result = (VALUE)FXText_position__SWIG_1((FXText const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXText_position(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXText, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXText_position__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXText, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXText_position__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "position", 
+    "    void position(FXint x, FXint y, FXint w, FXint h)\n"
+    "    VALUE position()\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_eraseCursorOverhang(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","eraseCursorOverhang", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  FXText_eraseCursorOverhang(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_drawCursor(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","drawCursor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  FXText_drawCursor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_style(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","style", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  result = (FXuint)FXText_style(arg1,arg2,arg3,arg4,arg5);
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_drawBufferText(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXDCWindow *arg2 = 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXint arg7 ;
+  FXint arg8 ;
+  FXuint arg9 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 8) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","drawBufferText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXDCWindow,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDCWindow &","drawBufferText", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDCWindow &","drawBufferText", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXDCWindow * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2INT(argv[5]);
+  arg8 = NUM2INT(argv[6]);
+  arg9 = NUM2UINT(argv[7]);
+  FXText_drawBufferText(arg1,*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_fillBufferRect(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXDCWindow *arg2 = 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  FXuint arg7 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 6) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","fillBufferRect", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXDCWindow,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDCWindow &","fillBufferRect", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDCWindow &","fillBufferRect", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXDCWindow * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  arg7 = NUM2UINT(argv[5]);
+  FXText_fillBufferRect(arg1,*arg2,arg3,arg4,arg5,arg6,arg7);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_drawTextRow(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXDCWindow *arg2 = 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","drawTextRow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXDCWindow,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDCWindow &","drawTextRow", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDCWindow &","drawTextRow", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXDCWindow * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXText_drawTextRow(arg1,*arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_drawContents(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXDCWindow *arg2 = 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 5) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","drawContents", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXDCWindow,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDCWindow &","drawContents", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDCWindow &","drawContents", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXDCWindow * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  FXText_drawContents(arg1,*arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_drawNumbers(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXDCWindow *arg2 = 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  FXint arg6 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 5) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","drawNumbers", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXDCWindow,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDCWindow &","drawNumbers", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXDCWindow &","drawNumbers", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXDCWindow * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  arg6 = NUM2INT(argv[4]);
+  FXText_drawNumbers(arg1,*arg2,arg3,arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setCursorPos(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setCursorPos", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXText_setCursorPos(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_extendSelection(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXTextSelectionMode arg3 = (FXTextSelectionMode) SELECT_CHARS ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","extendSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    ecode3 = SWIG_AsVal_int(argv[1], &val3);
+    if (!SWIG_IsOK(ecode3)) {
+      SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "FXTextSelectionMode","extendSelection", 3, argv[1] ));
+    } 
+    arg3 = static_cast< FXTextSelectionMode >(val3);
+  }
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  result = (FXbool)FXText_extendSelection(arg1,arg2,arg3,arg4);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_killSelection(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","killSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXText_killSelection(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_replaceText(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXString *arg4 = 0 ;
+  FXbool arg5 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p4 ;
+  
+  if ((argc < 3) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","replaceText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  p4 = to_FXString(argv[2]); arg4 = &p4;
+  if (argc > 3) {
+    arg5 = to_FXbool(argv[3]);
+  }
+  FXText_replaceText(arg1,arg2,arg3,(FXString const &)*arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_replaceStyledText(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXString *arg4 = 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXbool arg6 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p4 ;
+  
+  if ((argc < 3) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","replaceStyledText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  p4 = to_FXString(argv[2]); arg4 = &p4;
+  if (argc > 3) {
+    arg5 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg6 = to_FXbool(argv[4]);
+  }
+  FXText_replaceStyledText(arg1,arg2,arg3,(FXString const &)*arg4,arg5,arg6);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_appendText(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXString *arg2 = 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","appendText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXText_appendText(arg1,(FXString const &)*arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_appendStyledText(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXString *arg2 = 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","appendStyledText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  FXText_appendStyledText(arg1,(FXString const &)*arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_insertText(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","insertText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  FXText_insertText(arg1,arg2,(FXString const &)*arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_insertStyledText(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXbool arg5 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  
+  if ((argc < 2) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","insertStyledText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg5 = to_FXbool(argv[3]);
+  }
+  FXText_insertStyledText(arg1,arg2,(FXString const &)*arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_removeText(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","removeText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  FXText_removeText(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_changeStyle__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","changeStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  FXText_changeStyle(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_changeStyle__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","changeStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  FXText_changeStyle(arg1,arg2,(FXString const &)*arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXText_changeStyle(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[5];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 5) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXText, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          return _wrap_FXText_changeStyle__SWIG_1(nargs, args, self);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXText, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_FXText_changeStyle__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 5, "changeStyle", 
+    "    void changeStyle(FXint pos, FXint n, FXint style)\n"
+    "    void changeStyle(FXint pos, FXString const &style)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setText(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXString *arg2 = 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXText_setText(arg1,(FXString const &)*arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXText_setStyledText(int argc, VALUE *argv, VALUE self) {
+  FXText *arg1 = (FXText *) 0 ;
+  FXString *arg2 = 0 ;
+  FXint arg3 = (FXint) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXText, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXText *","setStyledText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXText * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  FXText_setStyledText(arg1,(FXString const &)*arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_FXGradientBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShutterItemTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXTextTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXText *) x));
+}
+static void *_p_FXColorBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXMatrixTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXDrawableTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXDrawable *) x));
+}
+static void *_p_FXHeaderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXSplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSpringTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXProgressBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXToolTipTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXDockSiteTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXCanvasTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXColorWheelTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXVisualTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXVisual *) x));
+}
+static void *_p_FXScrollBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXFontTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXFont *) x));
+}
+static void *_p_FXComboBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStatusBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXCursor *) x));
+}
+static void *_p_FXKnobTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRulerViewTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXStatusLineTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXMainWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXDockBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXToolBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDirBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXDocumentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDocument *) x));
+}
+static void *_p_FXGradientBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXRegistryTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *)(FXSettings *) ((FXRegistry *) x));
+}
+static void *_p_FXHeaderItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXHeaderItem *) x));
+}
+static void *_p_FXShutterItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXTextTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXText *) x));
+}
+static void *_p_FXColorBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXIconDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXIconDict *) x));
+}
+static void *_p_FXMatrixTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXFileDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXFileDict *) x));
+}
+static void *_p_FXRecentFilesTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXRecentFiles *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXDrawableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXDrawable *) x));
+}
+static void *_p_FXAppTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXApp *) x));
+}
+static void *_p_FXHeaderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXTranslatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXTranslator *) x));
+}
+static void *_p_FX4SplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FXSpringTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXIdTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXId *) x));
+}
+static void *_p_FXProgressBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXToolTipTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXSettingsTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXSettings *) x));
+}
+static void *_p_FXDockSiteTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDebugTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDebugTarget *) x));
+}
+static void *_p_FXDataTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDataTarget *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXCanvasTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXListBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXColorWheelTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXVisualTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXVisual *) x));
+}
+static void *_p_FXScrollBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXFontTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXFont *) x));
+}
+static void *_p_FXComboBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStringDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXStringDict *) x));
+}
+static void *_p_FXStatusBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXDelegatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDelegator *) x));
+}
+static void *_p_FXAccelTableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXAccelTable *) x));
+}
+static void *_p_FXCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXKnobTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRulerViewTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXStatusLineTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXDockBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDict *) x));
+}
+static void *_p_FXShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXToolBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDirBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXTextTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXText *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXScrollWindow *) x));
+}
+static void *_p_FXImageViewTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXImageView *) x));
+}
+static void *_p_FXRulerViewTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXRulerView *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXToolBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXTextTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXText *) x));
+}
+static void *_p_FXCompositeTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXComposite *) x));
+}
+static void *_p_FXToolTipTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXTextFieldTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXTabBookTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXStatusBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXPopupTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXRulerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXCanvasTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXCanvas *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXScrollCorner *) x));
+}
+static void *_p_FXSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXStatusLineTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXComboBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXKnobTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FX4SplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FXPackerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXSpinnerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXScrollBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXScrollBar *) x));
+}
+static void *_p_FXColorWheelTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXGradientBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXDirBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXImageFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXDragCornerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXDragCorner *) x));
+}
+static void *_p_FXSwitcherTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXShutterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXProgressBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXDockSiteTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXDockTitleTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXRulerViewTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXListBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXHeaderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXMatrixTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXColorWellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXShutterItemTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXDialTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDockBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXFrame *) x));
+}
+static void *_p_FXTabBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FX7SegmentTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXImageViewTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXSliderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXRealSliderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSpringTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXColorRingTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXColorBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXToolBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXTextTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXText *) x));
+}
+static void *_p_FXToolTipTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXTabBookTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXShell *) x));
+}
+static void *_p_FXStatusBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXScrollArea *) x));
+}
+static void *_p_FXPopupTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXComboBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FX4SplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXSplitter *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXPackerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXPacker *) x));
+}
+static void *_p_FXDirBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXSwitcherTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXShutterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXDockSiteTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXRulerViewTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXMatrixTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXShutterItemTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXDockBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXImageViewTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXSpringTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXToolBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXTextTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXText *) x));
+}
+static void *_p_FXCompositeTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXToolTipTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXTextFieldTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXTabBookTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXStatusBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXPopupTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *)  ((FXWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXRulerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXCanvasTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXStatusLineTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXComboBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXKnobTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FX4SplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FXPackerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXSpinnerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXScrollBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXColorWheelTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXGradientBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXDirBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXImageFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXDragCornerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXSwitcherTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXShutterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXProgressBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXDockSiteTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXDockTitleTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXRulerViewTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXListBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXHeaderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXMatrixTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXColorWellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXShutterItemTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXDialTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDockBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FXTabBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FX7SegmentTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXImageViewTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXRealSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSpringTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXColorRingTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXColorBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXFileStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXFileStream *) x));
+}
+static void *_p_FXMemoryStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXMemoryStream *) x));
+}
+static swig_type_info _swigt__p_FXBitmap = {"_p_FXBitmap", "FXBitmap *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXComposite = {"_p_FXComposite", "FXComposite *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDriveBox = {"_p_FXDriveBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBar = {"_p_FXToolBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolTip = {"_p_FXToolTip", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTabBook = {"_p_FXTabBook", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGroupBox = {"_p_FXGroupBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShell = {"_p_FXShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusBar = {"_p_FXStatusBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPopup = {"_p_FXPopup", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTopWindow = {"_p_FXTopWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRootWindow = {"_p_FXRootWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMainWindow = {"_p_FXMainWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplashWindow = {"_p_FXSplashWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollWindow = {"_p_FXScrollWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXComboBox = {"_p_FXComboBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalFrame = {"_p_FXHorizontalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalFrame = {"_p_FXVerticalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FX4Splitter = {"_p_FX4Splitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplitter = {"_p_FXSplitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRealSpinner = {"_p_FXRealSpinner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSpinner = {"_p_FXSpinner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPacker = {"_p_FXPacker", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDirBox = {"_p_FXDirBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSwitcher = {"_p_FXSwitcher", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDirSelector = {"_p_FXDirSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileSelector = {"_p_FXFileSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorSelector = {"_p_FXColorSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFontSelector = {"_p_FXFontSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutter = {"_p_FXShutter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockSite = {"_p_FXDockSite", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRulerView = {"_p_FXRulerView", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTreeListBox = {"_p_FXTreeListBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXListBox = {"_p_FXListBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMatrix = {"_p_FXMatrix", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutterItem = {"_p_FXShutterItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockBar = {"_p_FXDockBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTabBar = {"_p_FXTabBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImageView = {"_p_FXImageView", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSpring = {"_p_FXSpring", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarShell = {"_p_FXToolBarShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDCWindow = {"_p_FXDCWindow", "FXDCWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDrawable = {"_p_FXDrawable", "FXDrawable *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGradientBar = {"_p_FXGradientBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorBar = {"_p_FXColorBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTextField = {"_p_FXTextField", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarTab = {"_p_FXToolBarTab", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollCorner = {"_p_FXScrollCorner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXArrowButton = {"_p_FXArrowButton", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHeader = {"_p_FXHeader", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImageFrame = {"_p_FXImageFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSeparator = {"_p_FXSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalSeparator = {"_p_FXHorizontalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalSeparator = {"_p_FXVerticalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXKnob = {"_p_FXKnob", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXProgressBar = {"_p_FXProgressBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXBitmapFrame = {"_p_FXBitmapFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSlider = {"_p_FXSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRealSlider = {"_p_FXRealSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorRing = {"_p_FXColorRing", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockHandler = {"_p_FXDockHandler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCanvas = {"_p_FXCanvas", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWheel = {"_p_FXColorWheel", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDial = {"_p_FXDial", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarGrip = {"_p_FXToolBarGrip", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollBar = {"_p_FXScrollBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFrame = {"_p_FXFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FX7Segment = {"_p_FX7Segment", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockTitle = {"_p_FXDockTitle", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusLine = {"_p_FXStatusLine", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWell = {"_p_FXColorWell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDragCorner = {"_p_FXDragCorner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRuler = {"_p_FXRuler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFont = {"_p_FXFont", "FXFont *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXHiliteStyle = {"_p_FXHiliteStyle", "FXHiliteStyle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXIcon = {"_p_FXIcon", "FXIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXId = {"_p_FXId", "FXId *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXVisual = {"_p_FXVisual", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCursor = {"_p_FXCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCURCursor = {"_p_FXCURCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGIFCursor = {"_p_FXGIFCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXObject = {"_p_FXObject", "FXObject *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDocument = {"_p_FXDocument", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRegistry = {"_p_FXRegistry", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHeaderItem = {"_p_FXHeaderItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXIconDict = {"_p_FXIconDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileDict = {"_p_FXFileDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRecentFiles = {"_p_FXRecentFiles", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTranslator = {"_p_FXTranslator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXApp = {"_p_FXApp", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDict = {"_p_FXDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSettings = {"_p_FXSettings", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDataTarget = {"_p_FXDataTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDebugTarget = {"_p_FXDebugTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStringDict = {"_p_FXStringDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDelegator = {"_p_FXDelegator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXAccelTable = {"_p_FXAccelTable", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRegion = {"_p_FXRegion", "FXRegion *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXScrollArea = {"_p_FXScrollArea", "FXScrollArea *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXStream = {"_p_FXStream", "FXStream *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFileStream = {"_p_FXFileStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMemoryStream = {"_p_FXMemoryStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXText = {"_p_FXText", "FXText *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXTextChange = {"_p_FXTextChange", "FXTextChange *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXWindow = {"_p_FXWindow", "FXWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_char = {"_p_char", "char *|FXchar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "double *|FXdouble *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_float = {"_p_float", "float *|FXfloat *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "FXint *|int *|FXInputHandle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_long = {"_p_long", "long *|FXTime *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_short = {"_p_short", "short *|FXshort *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "FXuchar *|unsigned char *|FXbool *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "FXwchar *|FXDragType *|unsigned int *|FXuint *|FXColor *|FXSelector *|FXHotKey *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|FXuval *|FXPixel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|FXushort *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_FX4Splitter,
+  &_swigt__p_FX7Segment,
+  &_swigt__p_FXAccelTable,
+  &_swigt__p_FXApp,
+  &_swigt__p_FXArrowButton,
+  &_swigt__p_FXBitmap,
+  &_swigt__p_FXBitmapFrame,
+  &_swigt__p_FXCURCursor,
+  &_swigt__p_FXCanvas,
+  &_swigt__p_FXColorBar,
+  &_swigt__p_FXColorRing,
+  &_swigt__p_FXColorSelector,
+  &_swigt__p_FXColorWell,
+  &_swigt__p_FXColorWheel,
+  &_swigt__p_FXComboBox,
+  &_swigt__p_FXComposite,
+  &_swigt__p_FXCursor,
+  &_swigt__p_FXDCWindow,
+  &_swigt__p_FXDataTarget,
+  &_swigt__p_FXDebugTarget,
+  &_swigt__p_FXDelegator,
+  &_swigt__p_FXDial,
+  &_swigt__p_FXDict,
+  &_swigt__p_FXDirBox,
+  &_swigt__p_FXDirSelector,
+  &_swigt__p_FXDockBar,
+  &_swigt__p_FXDockHandler,
+  &_swigt__p_FXDockSite,
+  &_swigt__p_FXDockTitle,
+  &_swigt__p_FXDocument,
+  &_swigt__p_FXDragCorner,
+  &_swigt__p_FXDrawable,
+  &_swigt__p_FXDriveBox,
+  &_swigt__p_FXFileDict,
+  &_swigt__p_FXFileSelector,
+  &_swigt__p_FXFileStream,
+  &_swigt__p_FXFont,
+  &_swigt__p_FXFontSelector,
+  &_swigt__p_FXFrame,
+  &_swigt__p_FXGIFCursor,
+  &_swigt__p_FXGradientBar,
+  &_swigt__p_FXGroupBox,
+  &_swigt__p_FXHeader,
+  &_swigt__p_FXHeaderItem,
+  &_swigt__p_FXHiliteStyle,
+  &_swigt__p_FXHorizontalFrame,
+  &_swigt__p_FXHorizontalSeparator,
+  &_swigt__p_FXIcon,
+  &_swigt__p_FXIconDict,
+  &_swigt__p_FXId,
+  &_swigt__p_FXImageFrame,
+  &_swigt__p_FXImageView,
+  &_swigt__p_FXKnob,
+  &_swigt__p_FXListBox,
+  &_swigt__p_FXMainWindow,
+  &_swigt__p_FXMatrix,
+  &_swigt__p_FXMemoryStream,
+  &_swigt__p_FXObject,
+  &_swigt__p_FXPacker,
+  &_swigt__p_FXPopup,
+  &_swigt__p_FXProgressBar,
+  &_swigt__p_FXRealSlider,
+  &_swigt__p_FXRealSpinner,
+  &_swigt__p_FXRecentFiles,
+  &_swigt__p_FXRegion,
+  &_swigt__p_FXRegistry,
+  &_swigt__p_FXRootWindow,
+  &_swigt__p_FXRuler,
+  &_swigt__p_FXRulerView,
+  &_swigt__p_FXScrollArea,
+  &_swigt__p_FXScrollBar,
+  &_swigt__p_FXScrollCorner,
+  &_swigt__p_FXScrollWindow,
+  &_swigt__p_FXSeparator,
+  &_swigt__p_FXSettings,
+  &_swigt__p_FXShell,
+  &_swigt__p_FXShutter,
+  &_swigt__p_FXShutterItem,
+  &_swigt__p_FXSlider,
+  &_swigt__p_FXSpinner,
+  &_swigt__p_FXSplashWindow,
+  &_swigt__p_FXSplitter,
+  &_swigt__p_FXSpring,
+  &_swigt__p_FXStatusBar,
+  &_swigt__p_FXStatusLine,
+  &_swigt__p_FXStream,
+  &_swigt__p_FXStringDict,
+  &_swigt__p_FXSwitcher,
+  &_swigt__p_FXTabBar,
+  &_swigt__p_FXTabBook,
+  &_swigt__p_FXText,
+  &_swigt__p_FXTextChange,
+  &_swigt__p_FXTextField,
+  &_swigt__p_FXToolBar,
+  &_swigt__p_FXToolBarGrip,
+  &_swigt__p_FXToolBarShell,
+  &_swigt__p_FXToolBarTab,
+  &_swigt__p_FXToolTip,
+  &_swigt__p_FXTopWindow,
+  &_swigt__p_FXTranslator,
+  &_swigt__p_FXTreeListBox,
+  &_swigt__p_FXVerticalFrame,
+  &_swigt__p_FXVerticalSeparator,
+  &_swigt__p_FXVisual,
+  &_swigt__p_FXWindow,
+  &_swigt__p_char,
+  &_swigt__p_double,
+  &_swigt__p_float,
+  &_swigt__p_int,
+  &_swigt__p_long,
+  &_swigt__p_short,
+  &_swigt__p_unsigned_char,
+  &_swigt__p_unsigned_int,
+  &_swigt__p_unsigned_long,
+  &_swigt__p_unsigned_short,
+};
+
+static swig_cast_info _swigc__p_FXBitmap[] = {  {&_swigt__p_FXBitmap, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDriveBox[] = {{&_swigt__p_FXDriveBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBar[] = {{&_swigt__p_FXToolBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolTip[] = {{&_swigt__p_FXToolTip, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabBook[] = {{&_swigt__p_FXTabBook, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGroupBox[] = {{&_swigt__p_FXGroupBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShell[] = {{&_swigt__p_FXShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusBar[] = {{&_swigt__p_FXStatusBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPopup[] = {{&_swigt__p_FXPopup, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTopWindow[] = {{&_swigt__p_FXTopWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRootWindow[] = {{&_swigt__p_FXRootWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMainWindow[] = {{&_swigt__p_FXMainWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplashWindow[] = {{&_swigt__p_FXSplashWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollWindow[] = {{&_swigt__p_FXScrollWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComboBox[] = {{&_swigt__p_FXComboBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalFrame[] = {{&_swigt__p_FXHorizontalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalFrame[] = {{&_swigt__p_FXVerticalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FX4Splitter[] = {{&_swigt__p_FX4Splitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplitter[] = {{&_swigt__p_FXSplitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSpinner[] = {{&_swigt__p_FXRealSpinner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpinner[] = {{&_swigt__p_FXSpinner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPacker[] = {{&_swigt__p_FXPacker, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirBox[] = {{&_swigt__p_FXDirBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSwitcher[] = {{&_swigt__p_FXSwitcher, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirSelector[] = {{&_swigt__p_FXDirSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileSelector[] = {{&_swigt__p_FXFileSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorSelector[] = {{&_swigt__p_FXColorSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFontSelector[] = {{&_swigt__p_FXFontSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutter[] = {{&_swigt__p_FXShutter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockSite[] = {{&_swigt__p_FXDockSite, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRulerView[] = {{&_swigt__p_FXRulerView, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTreeListBox[] = {{&_swigt__p_FXTreeListBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXListBox[] = {{&_swigt__p_FXListBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMatrix[] = {{&_swigt__p_FXMatrix, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutterItem[] = {{&_swigt__p_FXShutterItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockBar[] = {{&_swigt__p_FXDockBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabBar[] = {{&_swigt__p_FXTabBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageView[] = {{&_swigt__p_FXImageView, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpring[] = {{&_swigt__p_FXSpring, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarShell[] = {{&_swigt__p_FXToolBarShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComposite[] = {  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXComposite, 0, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXComposite, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXComposite, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXText, _p_FXTextTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXComposite, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXComposite, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDCWindow[] = {  {&_swigt__p_FXDCWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGradientBar[] = {{&_swigt__p_FXGradientBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorBar[] = {{&_swigt__p_FXColorBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTextField[] = {{&_swigt__p_FXTextField, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarTab[] = {{&_swigt__p_FXToolBarTab, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollCorner[] = {{&_swigt__p_FXScrollCorner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXArrowButton[] = {{&_swigt__p_FXArrowButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeader[] = {{&_swigt__p_FXHeader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageFrame[] = {{&_swigt__p_FXImageFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSeparator[] = {{&_swigt__p_FXSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalSeparator[] = {{&_swigt__p_FXHorizontalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalSeparator[] = {{&_swigt__p_FXVerticalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXKnob[] = {{&_swigt__p_FXKnob, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXProgressBar[] = {{&_swigt__p_FXProgressBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBitmapFrame[] = {{&_swigt__p_FXBitmapFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSlider[] = {{&_swigt__p_FXSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSlider[] = {{&_swigt__p_FXRealSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorRing[] = {{&_swigt__p_FXColorRing, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockHandler[] = {{&_swigt__p_FXDockHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCanvas[] = {{&_swigt__p_FXCanvas, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWheel[] = {{&_swigt__p_FXColorWheel, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDial[] = {{&_swigt__p_FXDial, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarGrip[] = {{&_swigt__p_FXToolBarGrip, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollBar[] = {{&_swigt__p_FXScrollBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFrame[] = {{&_swigt__p_FXFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FX7Segment[] = {{&_swigt__p_FX7Segment, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockTitle[] = {{&_swigt__p_FXDockTitle, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusLine[] = {{&_swigt__p_FXStatusLine, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWell[] = {{&_swigt__p_FXColorWell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDragCorner[] = {{&_swigt__p_FXDragCorner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRuler[] = {{&_swigt__p_FXRuler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDrawable[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDrawable, 0, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXText, _p_FXTextTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXDrawable, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFont[] = {  {&_swigt__p_FXFont, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHiliteStyle[] = {  {&_swigt__p_FXHiliteStyle, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIcon[] = {  {&_swigt__p_FXIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVisual[] = {{&_swigt__p_FXVisual, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCursor[] = {{&_swigt__p_FXCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCURCursor[] = {{&_swigt__p_FXCURCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGIFCursor[] = {{&_swigt__p_FXGIFCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXId[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXId, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXId, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXId, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXId, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXId, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXId, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXId, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXId, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXId, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXId, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXId, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXId, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXId, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXId, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXId, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXId, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXId, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXId, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXId, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXId, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXId, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXId, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXId, 0, 0},  {&_swigt__p_FXId, 0, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXId, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXId, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXId, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXId, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXId, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXId, 0, 0},  {&_swigt__p_FXText, _p_FXTextTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXId, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXId, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXId, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXId, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXId, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXId, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXId, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXId, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXId, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDocument[] = {{&_swigt__p_FXDocument, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegistry[] = {{&_swigt__p_FXRegistry, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeaderItem[] = {{&_swigt__p_FXHeaderItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIconDict[] = {{&_swigt__p_FXIconDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileDict[] = {{&_swigt__p_FXFileDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRecentFiles[] = {{&_swigt__p_FXRecentFiles, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTranslator[] = {{&_swigt__p_FXTranslator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXApp[] = {{&_swigt__p_FXApp, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDict[] = {{&_swigt__p_FXDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSettings[] = {{&_swigt__p_FXSettings, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDataTarget[] = {{&_swigt__p_FXDataTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDebugTarget[] = {{&_swigt__p_FXDebugTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStringDict[] = {{&_swigt__p_FXStringDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDelegator[] = {{&_swigt__p_FXDelegator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXAccelTable[] = {{&_swigt__p_FXAccelTable, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXObject[] = {  {&_swigt__p_FXDocument, _p_FXDocumentTo_p_FXObject, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXRegistry, _p_FXRegistryTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeaderItem, _p_FXHeaderItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXObject, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXObject, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXIconDict, _p_FXIconDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileDict, _p_FXFileDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXRecentFiles, _p_FXRecentFilesTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXObject, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXObject, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXObject, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXObject, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FXTranslator, _p_FXTranslatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXObject, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXObject, 0, 0},  {&_swigt__p_FXApp, _p_FXAppTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXObject, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXObject, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXObject, 0, 0},  {&_swigt__p_FXDict, _p_FXDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXSettings, _p_FXSettingsTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXObject, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXObject, 0, 0},  {&_swigt__p_FXDataTarget, _p_FXDataTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDebugTarget, _p_FXDebugTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXObject, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXObject, 0, 0},  {&_swigt__p_FXId, _p_FXIdTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXObject, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXObject, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXObject, 0, 0},  {&_swigt__p_FXText, _p_FXTextTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXStringDict, _p_FXStringDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXDelegator, _p_FXDelegatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXAccelTable, _p_FXAccelTableTo_p_FXObject, 0, 0},  {&_swigt__p_FXObject, 0, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXObject, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXObject, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXObject, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXObject, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXObject, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegion[] = {  {&_swigt__p_FXRegion, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollArea[] = {  {&_swigt__p_FXText, _p_FXTextTo_p_FXScrollArea, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXScrollArea, 0, 0},  {&_swigt__p_FXScrollArea, 0, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXScrollArea, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXScrollArea, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileStream[] = {{&_swigt__p_FXFileStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMemoryStream[] = {{&_swigt__p_FXMemoryStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStream[] = {  {&_swigt__p_FXFileStream, _p_FXFileStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXMemoryStream, _p_FXMemoryStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXText[] = {  {&_swigt__p_FXText, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTextChange[] = {  {&_swigt__p_FXTextChange, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXWindow[] = {  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXWindow, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXWindow, 0, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXWindow, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXText, _p_FXTextTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXWindow, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXWindow, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXWindow, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXWindow, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXWindow, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
+
+static swig_cast_info *swig_cast_initial[] = {
+  _swigc__p_FX4Splitter,
+  _swigc__p_FX7Segment,
+  _swigc__p_FXAccelTable,
+  _swigc__p_FXApp,
+  _swigc__p_FXArrowButton,
+  _swigc__p_FXBitmap,
+  _swigc__p_FXBitmapFrame,
+  _swigc__p_FXCURCursor,
+  _swigc__p_FXCanvas,
+  _swigc__p_FXColorBar,
+  _swigc__p_FXColorRing,
+  _swigc__p_FXColorSelector,
+  _swigc__p_FXColorWell,
+  _swigc__p_FXColorWheel,
+  _swigc__p_FXComboBox,
+  _swigc__p_FXComposite,
+  _swigc__p_FXCursor,
+  _swigc__p_FXDCWindow,
+  _swigc__p_FXDataTarget,
+  _swigc__p_FXDebugTarget,
+  _swigc__p_FXDelegator,
+  _swigc__p_FXDial,
+  _swigc__p_FXDict,
+  _swigc__p_FXDirBox,
+  _swigc__p_FXDirSelector,
+  _swigc__p_FXDockBar,
+  _swigc__p_FXDockHandler,
+  _swigc__p_FXDockSite,
+  _swigc__p_FXDockTitle,
+  _swigc__p_FXDocument,
+  _swigc__p_FXDragCorner,
+  _swigc__p_FXDrawable,
+  _swigc__p_FXDriveBox,
+  _swigc__p_FXFileDict,
+  _swigc__p_FXFileSelector,
+  _swigc__p_FXFileStream,
+  _swigc__p_FXFont,
+  _swigc__p_FXFontSelector,
+  _swigc__p_FXFrame,
+  _swigc__p_FXGIFCursor,
+  _swigc__p_FXGradientBar,
+  _swigc__p_FXGroupBox,
+  _swigc__p_FXHeader,
+  _swigc__p_FXHeaderItem,
+  _swigc__p_FXHiliteStyle,
+  _swigc__p_FXHorizontalFrame,
+  _swigc__p_FXHorizontalSeparator,
+  _swigc__p_FXIcon,
+  _swigc__p_FXIconDict,
+  _swigc__p_FXId,
+  _swigc__p_FXImageFrame,
+  _swigc__p_FXImageView,
+  _swigc__p_FXKnob,
+  _swigc__p_FXListBox,
+  _swigc__p_FXMainWindow,
+  _swigc__p_FXMatrix,
+  _swigc__p_FXMemoryStream,
+  _swigc__p_FXObject,
+  _swigc__p_FXPacker,
+  _swigc__p_FXPopup,
+  _swigc__p_FXProgressBar,
+  _swigc__p_FXRealSlider,
+  _swigc__p_FXRealSpinner,
+  _swigc__p_FXRecentFiles,
+  _swigc__p_FXRegion,
+  _swigc__p_FXRegistry,
+  _swigc__p_FXRootWindow,
+  _swigc__p_FXRuler,
+  _swigc__p_FXRulerView,
+  _swigc__p_FXScrollArea,
+  _swigc__p_FXScrollBar,
+  _swigc__p_FXScrollCorner,
+  _swigc__p_FXScrollWindow,
+  _swigc__p_FXSeparator,
+  _swigc__p_FXSettings,
+  _swigc__p_FXShell,
+  _swigc__p_FXShutter,
+  _swigc__p_FXShutterItem,
+  _swigc__p_FXSlider,
+  _swigc__p_FXSpinner,
+  _swigc__p_FXSplashWindow,
+  _swigc__p_FXSplitter,
+  _swigc__p_FXSpring,
+  _swigc__p_FXStatusBar,
+  _swigc__p_FXStatusLine,
+  _swigc__p_FXStream,
+  _swigc__p_FXStringDict,
+  _swigc__p_FXSwitcher,
+  _swigc__p_FXTabBar,
+  _swigc__p_FXTabBook,
+  _swigc__p_FXText,
+  _swigc__p_FXTextChange,
+  _swigc__p_FXTextField,
+  _swigc__p_FXToolBar,
+  _swigc__p_FXToolBarGrip,
+  _swigc__p_FXToolBarShell,
+  _swigc__p_FXToolBarTab,
+  _swigc__p_FXToolTip,
+  _swigc__p_FXTopWindow,
+  _swigc__p_FXTranslator,
+  _swigc__p_FXTreeListBox,
+  _swigc__p_FXVerticalFrame,
+  _swigc__p_FXVerticalSeparator,
+  _swigc__p_FXVisual,
+  _swigc__p_FXWindow,
+  _swigc__p_char,
+  _swigc__p_double,
+  _swigc__p_float,
+  _swigc__p_int,
+  _swigc__p_long,
+  _swigc__p_short,
+  _swigc__p_unsigned_char,
+  _swigc__p_unsigned_int,
+  _swigc__p_unsigned_long,
+  _swigc__p_unsigned_short,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned statically to an initial
+ * array. We just loop through that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded.
+ * There are three cases to handle:
+ *  1) If the cast->type has already been loaded AND the type we are adding
+ *     casting info to has not been loaded (it is in this module), THEN we
+ *     replace the cast->type pointer with the type pointer that has already
+ *     been loaded.
+ *  2) If BOTH types (the one we are adding casting info to, and the
+ *     cast->type) are loaded, THEN the cast info has already been loaded by
+ *     the previous module so we just ignore it.
+ *  3) Finally, if cast->type has not already been loaded, then we add that
+ *     swig_cast_info to the linked list (because the cast->type) pointer will
+ *     be correct.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* c-mode */
+#endif
+#endif
+
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+  size_t i;
+  swig_module_info *module_head, *iter;
+  int init;
+
+  /* check to see if the circular list has been setup, if not, set it up */
+  if (swig_module.next==0) {
+    /* Initialize the swig_module */
+    swig_module.type_initial = swig_type_initial;
+    swig_module.cast_initial = swig_cast_initial;
+    swig_module.next = &swig_module;
+    init = 1;
+  } else {
+    init = 0;
+  }
+
+  /* Try and load any already created modules */
+  module_head = SWIG_GetModule(clientdata);
+  if (!module_head) {
+    /* This is the first module loaded for this interpreter */
+    /* so set the swig module into the interpreter */
+    SWIG_SetModule(clientdata, &swig_module);
+  } else {
+    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+    iter=module_head;
+    do {
+      if (iter==&swig_module) {
+        /* Our module is already in the list, so there's nothing more to do. */
+        return;
+      }
+      iter=iter->next;
+    } while (iter!= module_head);
+
+    /* otherwise we must add our module into the list */
+    swig_module.next = module_head->next;
+    module_head->next = &swig_module;
+  }
+
+  /* When multiple interpreters are used, a module could have already been initialized in
+     a different interpreter, but not yet have a pointer in this interpreter.
+     In this case, we do not want to continue adding types... everything should be
+     set up already */
+  if (init == 0) return;
+
+  /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+  for (i = 0; i < swig_module.size; ++i) {
+    swig_type_info *type = 0;
+    swig_type_info *ret;
+    swig_cast_info *cast;
+
+#ifdef SWIGRUNTIME_DEBUG
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+
+    /* if there is another module already loaded */
+    if (swig_module.next != &swig_module) {
+      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
+    }
+    if (type) {
+      /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+      if (swig_module.type_initial[i]->clientdata) {
+	type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+      }
+    } else {
+      type = swig_module.type_initial[i];
+    }
+
+    /* Insert casting types */
+    cast = swig_module.cast_initial[i];
+    while (cast->type) {
+
+      /* Don't need to add information already in the list */
+      ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+      if (swig_module.next != &swig_module) {
+        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+      }
+      if (ret) {
+	if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+	  cast->type = ret;
+	  ret = 0;
+	} else {
+	  /* Check for casting already in the list */
+	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+	  if (!ocast) ret = 0;
+	}
+      }
+
+      if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+        if (type->cast) {
+          type->cast->prev = cast;
+          cast->next = type->cast;
+        }
+        type->cast = cast;
+      }
+      cast++;
+    }
+    /* Set entry in modules->types array equal to the type */
+    swig_module.types[i] = type;
+  }
+  swig_module.types[i] = 0;
+
+#ifdef SWIGRUNTIME_DEBUG
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+  for (i = 0; i < swig_module.size; ++i) {
+    int j = 0;
+    swig_cast_info *cast = swig_module.cast_initial[i];
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    while (cast->type) {
+      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+      cast++;
+      ++j;
+    }
+  printf("---- Total casts: %d\n",j);
+  }
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types.  It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+  size_t i;
+  swig_cast_info *equiv;
+  static int init_run = 0;
+
+  if (init_run) return;
+  init_run = 1;
+
+  for (i = 0; i < swig_module.size; i++) {
+    if (swig_module.types[i]->clientdata) {
+      equiv = swig_module.types[i]->cast;
+      while (equiv) {
+        if (!equiv->converter) {
+          if (equiv->type && !equiv->type->clientdata)
+            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+        }
+        equiv = equiv->next;
+      }
+    }
+  }
+}
+
+#ifdef __cplusplus
+#if 0
+{ /* c-mode */
+#endif
+}
+#endif
+
+/*
+
+*/
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void Init_text(void) {
+  size_t i;
+  
+  SWIG_InitRuntime();
+  
+  
+  SWIG_InitializeModule(0);
+  for (i = 0; i < swig_module.size; i++) {
+    SWIG_define_class(swig_module.types[i]);
+  }
+  
+  SWIG_RubyInitializeTrackings();
+  
+  
+  
+  
+  rb_define_const(mFox, "TEXT_READONLY", SWIG_From_int(static_cast< int >(TEXT_READONLY)));
+  rb_define_const(mFox, "TEXT_WORDWRAP", SWIG_From_int(static_cast< int >(TEXT_WORDWRAP)));
+  rb_define_const(mFox, "TEXT_OVERSTRIKE", SWIG_From_int(static_cast< int >(TEXT_OVERSTRIKE)));
+  rb_define_const(mFox, "TEXT_FIXEDWRAP", SWIG_From_int(static_cast< int >(TEXT_FIXEDWRAP)));
+  rb_define_const(mFox, "TEXT_NO_TABS", SWIG_From_int(static_cast< int >(TEXT_NO_TABS)));
+  rb_define_const(mFox, "TEXT_AUTOINDENT", SWIG_From_int(static_cast< int >(TEXT_AUTOINDENT)));
+  rb_define_const(mFox, "TEXT_SHOWACTIVE", SWIG_From_int(static_cast< int >(TEXT_SHOWACTIVE)));
+  rb_define_const(mFox, "TEXT_AUTOSCROLL", SWIG_From_int(static_cast< int >(TEXT_AUTOSCROLL)));
+  rb_define_const(mFox, "SELECT_CHARS", SWIG_From_int(static_cast< int >(SELECT_CHARS)));
+  rb_define_const(mFox, "SELECT_WORDS", SWIG_From_int(static_cast< int >(SELECT_WORDS)));
+  rb_define_const(mFox, "SELECT_LINES", SWIG_From_int(static_cast< int >(SELECT_LINES)));
+  
+  SwigClassFXHiliteStyle.klass = rb_define_class_under(mFox, "FXHiliteStyle", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXHiliteStyle, (void *) &SwigClassFXHiliteStyle);
+  rb_define_alloc_func(SwigClassFXHiliteStyle.klass, _wrap_FXHiliteStyle_allocate);
+  rb_define_method(SwigClassFXHiliteStyle.klass, "initialize", VALUEFUNC(_wrap_new_FXHiliteStyle), -1);
+  rb_define_method(SwigClassFXHiliteStyle.klass, "normalForeColor=", VALUEFUNC(_wrap_FXHiliteStyle_normalForeColor_set), -1);
+  rb_define_method(SwigClassFXHiliteStyle.klass, "normalForeColor", VALUEFUNC(_wrap_FXHiliteStyle_normalForeColor_get), -1);
+  rb_define_method(SwigClassFXHiliteStyle.klass, "normalBackColor=", VALUEFUNC(_wrap_FXHiliteStyle_normalBackColor_set), -1);
+  rb_define_method(SwigClassFXHiliteStyle.klass, "normalBackColor", VALUEFUNC(_wrap_FXHiliteStyle_normalBackColor_get), -1);
+  rb_define_method(SwigClassFXHiliteStyle.klass, "selectForeColor=", VALUEFUNC(_wrap_FXHiliteStyle_selectForeColor_set), -1);
+  rb_define_method(SwigClassFXHiliteStyle.klass, "selectForeColor", VALUEFUNC(_wrap_FXHiliteStyle_selectForeColor_get), -1);
+  rb_define_method(SwigClassFXHiliteStyle.klass, "selectBackColor=", VALUEFUNC(_wrap_FXHiliteStyle_selectBackColor_set), -1);
+  rb_define_method(SwigClassFXHiliteStyle.klass, "selectBackColor", VALUEFUNC(_wrap_FXHiliteStyle_selectBackColor_get), -1);
+  rb_define_method(SwigClassFXHiliteStyle.klass, "hiliteForeColor=", VALUEFUNC(_wrap_FXHiliteStyle_hiliteForeColor_set), -1);
+  rb_define_method(SwigClassFXHiliteStyle.klass, "hiliteForeColor", VALUEFUNC(_wrap_FXHiliteStyle_hiliteForeColor_get), -1);
+  rb_define_method(SwigClassFXHiliteStyle.klass, "hiliteBackColor=", VALUEFUNC(_wrap_FXHiliteStyle_hiliteBackColor_set), -1);
+  rb_define_method(SwigClassFXHiliteStyle.klass, "hiliteBackColor", VALUEFUNC(_wrap_FXHiliteStyle_hiliteBackColor_get), -1);
+  rb_define_method(SwigClassFXHiliteStyle.klass, "activeBackColor=", VALUEFUNC(_wrap_FXHiliteStyle_activeBackColor_set), -1);
+  rb_define_method(SwigClassFXHiliteStyle.klass, "activeBackColor", VALUEFUNC(_wrap_FXHiliteStyle_activeBackColor_get), -1);
+  rb_define_method(SwigClassFXHiliteStyle.klass, "style=", VALUEFUNC(_wrap_FXHiliteStyle_style_set), -1);
+  rb_define_method(SwigClassFXHiliteStyle.klass, "style", VALUEFUNC(_wrap_FXHiliteStyle_style_get), -1);
+  SwigClassFXHiliteStyle.mark = 0;
+  SwigClassFXHiliteStyle.destroy = (void (*)(void *)) free_FXHiliteStyle;
+  SwigClassFXHiliteStyle.trackObjects = 0;
+  
+  SwigClassFXTextChange.klass = rb_define_class_under(mFox, "FXTextChange", rb_cObject);
+  SWIG_TypeClientData(SWIGTYPE_p_FXTextChange, (void *) &SwigClassFXTextChange);
+  rb_undef_alloc_func(SwigClassFXTextChange.klass);
+  rb_define_method(SwigClassFXTextChange.klass, "pos=", VALUEFUNC(_wrap_FXTextChange_pos_set), -1);
+  rb_define_method(SwigClassFXTextChange.klass, "pos", VALUEFUNC(_wrap_FXTextChange_pos_get), -1);
+  rb_define_method(SwigClassFXTextChange.klass, "ndel=", VALUEFUNC(_wrap_FXTextChange_ndel_set), -1);
+  rb_define_method(SwigClassFXTextChange.klass, "ndel", VALUEFUNC(_wrap_FXTextChange_ndel_get), -1);
+  rb_define_method(SwigClassFXTextChange.klass, "nins=", VALUEFUNC(_wrap_FXTextChange_nins_set), -1);
+  rb_define_method(SwigClassFXTextChange.klass, "nins", VALUEFUNC(_wrap_FXTextChange_nins_get), -1);
+  rb_define_method(SwigClassFXTextChange.klass, "ins", VALUEFUNC(_wrap_FXTextChange_ins), -1);
+  rb_define_method(SwigClassFXTextChange.klass, "del", VALUEFUNC(_wrap_FXTextChange_del), -1);
+  SwigClassFXTextChange.mark = 0;
+  SwigClassFXTextChange.trackObjects = 0;
+  
+  SwigClassFXText.klass = rb_define_class_under(mFox, "FXText", ((swig_class *) SWIGTYPE_p_FXScrollArea->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXText, (void *) &SwigClassFXText);
+  rb_define_alloc_func(SwigClassFXText.klass, _wrap_FXText_allocate);
+  rb_define_method(SwigClassFXText.klass, "initialize", VALUEFUNC(_wrap_new_FXText), -1);
+  rb_define_const(SwigClassFXText.klass, "STYLE_UNDERLINE", SWIG_From_int(static_cast< int >(FXText::STYLE_UNDERLINE)));
+  rb_define_const(SwigClassFXText.klass, "STYLE_STRIKEOUT", SWIG_From_int(static_cast< int >(FXText::STYLE_STRIKEOUT)));
+  rb_define_const(SwigClassFXText.klass, "STYLE_BOLD", SWIG_From_int(static_cast< int >(FXText::STYLE_BOLD)));
+  rb_define_method(SwigClassFXText.klass, "onPaint", VALUEFUNC(_wrap_FXText_onPaint), -1);
+  rb_define_method(SwigClassFXText.klass, "onFocusIn", VALUEFUNC(_wrap_FXText_onFocusIn), -1);
+  rb_define_method(SwigClassFXText.klass, "onFocusOut", VALUEFUNC(_wrap_FXText_onFocusOut), -1);
+  rb_define_method(SwigClassFXText.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXText_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXText.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXText_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXText.klass, "onMiddleBtnPress", VALUEFUNC(_wrap_FXText_onMiddleBtnPress), -1);
+  rb_define_method(SwigClassFXText.klass, "onMiddleBtnRelease", VALUEFUNC(_wrap_FXText_onMiddleBtnRelease), -1);
+  rb_define_method(SwigClassFXText.klass, "onRightBtnPress", VALUEFUNC(_wrap_FXText_onRightBtnPress), -1);
+  rb_define_method(SwigClassFXText.klass, "onRightBtnRelease", VALUEFUNC(_wrap_FXText_onRightBtnRelease), -1);
+  rb_define_method(SwigClassFXText.klass, "onUngrabbed", VALUEFUNC(_wrap_FXText_onUngrabbed), -1);
+  rb_define_method(SwigClassFXText.klass, "onMotion", VALUEFUNC(_wrap_FXText_onMotion), -1);
+  rb_define_method(SwigClassFXText.klass, "onBeginDrag", VALUEFUNC(_wrap_FXText_onBeginDrag), -1);
+  rb_define_method(SwigClassFXText.klass, "onEndDrag", VALUEFUNC(_wrap_FXText_onEndDrag), -1);
+  rb_define_method(SwigClassFXText.klass, "onDragged", VALUEFUNC(_wrap_FXText_onDragged), -1);
+  rb_define_method(SwigClassFXText.klass, "onDNDEnter", VALUEFUNC(_wrap_FXText_onDNDEnter), -1);
+  rb_define_method(SwigClassFXText.klass, "onDNDLeave", VALUEFUNC(_wrap_FXText_onDNDLeave), -1);
+  rb_define_method(SwigClassFXText.klass, "onDNDMotion", VALUEFUNC(_wrap_FXText_onDNDMotion), -1);
+  rb_define_method(SwigClassFXText.klass, "onDNDDrop", VALUEFUNC(_wrap_FXText_onDNDDrop), -1);
+  rb_define_method(SwigClassFXText.klass, "onDNDRequest", VALUEFUNC(_wrap_FXText_onDNDRequest), -1);
+  rb_define_method(SwigClassFXText.klass, "onSelectionLost", VALUEFUNC(_wrap_FXText_onSelectionLost), -1);
+  rb_define_method(SwigClassFXText.klass, "onSelectionGained", VALUEFUNC(_wrap_FXText_onSelectionGained), -1);
+  rb_define_method(SwigClassFXText.klass, "onSelectionRequest", VALUEFUNC(_wrap_FXText_onSelectionRequest), -1);
+  rb_define_method(SwigClassFXText.klass, "onClipboardLost", VALUEFUNC(_wrap_FXText_onClipboardLost), -1);
+  rb_define_method(SwigClassFXText.klass, "onClipboardGained", VALUEFUNC(_wrap_FXText_onClipboardGained), -1);
+  rb_define_method(SwigClassFXText.klass, "onClipboardRequest", VALUEFUNC(_wrap_FXText_onClipboardRequest), -1);
+  rb_define_method(SwigClassFXText.klass, "onKeyPress", VALUEFUNC(_wrap_FXText_onKeyPress), -1);
+  rb_define_method(SwigClassFXText.klass, "onKeyRelease", VALUEFUNC(_wrap_FXText_onKeyRelease), -1);
+  rb_define_method(SwigClassFXText.klass, "onBlink", VALUEFUNC(_wrap_FXText_onBlink), -1);
+  rb_define_method(SwigClassFXText.klass, "onFlash", VALUEFUNC(_wrap_FXText_onFlash), -1);
+  rb_define_method(SwigClassFXText.klass, "onAutoScroll", VALUEFUNC(_wrap_FXText_onAutoScroll), -1);
+  rb_define_method(SwigClassFXText.klass, "onQueryHelp", VALUEFUNC(_wrap_FXText_onQueryHelp), -1);
+  rb_define_method(SwigClassFXText.klass, "onQueryTip", VALUEFUNC(_wrap_FXText_onQueryTip), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdToggleEditable", VALUEFUNC(_wrap_FXText_onCmdToggleEditable), -1);
+  rb_define_method(SwigClassFXText.klass, "onUpdToggleEditable", VALUEFUNC(_wrap_FXText_onUpdToggleEditable), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdToggleOverstrike", VALUEFUNC(_wrap_FXText_onCmdToggleOverstrike), -1);
+  rb_define_method(SwigClassFXText.klass, "onUpdToggleOverstrike", VALUEFUNC(_wrap_FXText_onUpdToggleOverstrike), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdCursorRow", VALUEFUNC(_wrap_FXText_onCmdCursorRow), -1);
+  rb_define_method(SwigClassFXText.klass, "onUpdCursorRow", VALUEFUNC(_wrap_FXText_onUpdCursorRow), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdCursorColumn", VALUEFUNC(_wrap_FXText_onCmdCursorColumn), -1);
+  rb_define_method(SwigClassFXText.klass, "onUpdCursorColumn", VALUEFUNC(_wrap_FXText_onUpdCursorColumn), -1);
+  rb_define_method(SwigClassFXText.klass, "onUpdHaveSelection", VALUEFUNC(_wrap_FXText_onUpdHaveSelection), -1);
+  rb_define_method(SwigClassFXText.klass, "onUpdSelectAll", VALUEFUNC(_wrap_FXText_onUpdSelectAll), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdSetStringValue", VALUEFUNC(_wrap_FXText_onCmdSetStringValue), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdGetStringValue", VALUEFUNC(_wrap_FXText_onCmdGetStringValue), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdSearch", VALUEFUNC(_wrap_FXText_onCmdSearch), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdReplace", VALUEFUNC(_wrap_FXText_onCmdReplace), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdSearchNext", VALUEFUNC(_wrap_FXText_onCmdSearchNext), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdSearchSel", VALUEFUNC(_wrap_FXText_onCmdSearchSel), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdCursorTop", VALUEFUNC(_wrap_FXText_onCmdCursorTop), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdCursorBottom", VALUEFUNC(_wrap_FXText_onCmdCursorBottom), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdCursorHome", VALUEFUNC(_wrap_FXText_onCmdCursorHome), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdCursorEnd", VALUEFUNC(_wrap_FXText_onCmdCursorEnd), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdCursorRight", VALUEFUNC(_wrap_FXText_onCmdCursorRight), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdCursorLeft", VALUEFUNC(_wrap_FXText_onCmdCursorLeft), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdCursorUp", VALUEFUNC(_wrap_FXText_onCmdCursorUp), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdCursorDown", VALUEFUNC(_wrap_FXText_onCmdCursorDown), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdCursorWordLeft", VALUEFUNC(_wrap_FXText_onCmdCursorWordLeft), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdCursorWordRight", VALUEFUNC(_wrap_FXText_onCmdCursorWordRight), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdCursorWordStart", VALUEFUNC(_wrap_FXText_onCmdCursorWordStart), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdCursorWordEnd", VALUEFUNC(_wrap_FXText_onCmdCursorWordEnd), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdCursorPageDown", VALUEFUNC(_wrap_FXText_onCmdCursorPageDown), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdCursorPageUp", VALUEFUNC(_wrap_FXText_onCmdCursorPageUp), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdCursorScreenTop", VALUEFUNC(_wrap_FXText_onCmdCursorScreenTop), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdCursorScreenBottom", VALUEFUNC(_wrap_FXText_onCmdCursorScreenBottom), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdCursorScreenCenter", VALUEFUNC(_wrap_FXText_onCmdCursorScreenCenter), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdCursorParHome", VALUEFUNC(_wrap_FXText_onCmdCursorParHome), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdCursorParEnd", VALUEFUNC(_wrap_FXText_onCmdCursorParEnd), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdBlockBeg", VALUEFUNC(_wrap_FXText_onCmdBlockBeg), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdBlockEnd", VALUEFUNC(_wrap_FXText_onCmdBlockEnd), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdGotoMatching", VALUEFUNC(_wrap_FXText_onCmdGotoMatching), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdGotoSelected", VALUEFUNC(_wrap_FXText_onCmdGotoSelected), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdGotoLine", VALUEFUNC(_wrap_FXText_onCmdGotoLine), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdScrollUp", VALUEFUNC(_wrap_FXText_onCmdScrollUp), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdScrollDown", VALUEFUNC(_wrap_FXText_onCmdScrollDown), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdMark", VALUEFUNC(_wrap_FXText_onCmdMark), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdExtend", VALUEFUNC(_wrap_FXText_onCmdExtend), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdOverstString", VALUEFUNC(_wrap_FXText_onCmdOverstString), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdInsertString", VALUEFUNC(_wrap_FXText_onCmdInsertString), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdInsertNewline", VALUEFUNC(_wrap_FXText_onCmdInsertNewline), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdInsertTab", VALUEFUNC(_wrap_FXText_onCmdInsertTab), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdCutSel", VALUEFUNC(_wrap_FXText_onCmdCutSel), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdCopySel", VALUEFUNC(_wrap_FXText_onCmdCopySel), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdPasteSel", VALUEFUNC(_wrap_FXText_onCmdPasteSel), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdDeleteSel", VALUEFUNC(_wrap_FXText_onCmdDeleteSel), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdChangeCase", VALUEFUNC(_wrap_FXText_onCmdChangeCase), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdShiftText", VALUEFUNC(_wrap_FXText_onCmdShiftText), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdPasteMiddle", VALUEFUNC(_wrap_FXText_onCmdPasteMiddle), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdSelectChar", VALUEFUNC(_wrap_FXText_onCmdSelectChar), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdSelectWord", VALUEFUNC(_wrap_FXText_onCmdSelectWord), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdSelectLine", VALUEFUNC(_wrap_FXText_onCmdSelectLine), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdSelectAll", VALUEFUNC(_wrap_FXText_onCmdSelectAll), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdSelectMatching", VALUEFUNC(_wrap_FXText_onCmdSelectMatching), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdSelectBlock", VALUEFUNC(_wrap_FXText_onCmdSelectBlock), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdDeselectAll", VALUEFUNC(_wrap_FXText_onCmdDeselectAll), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdBackspace", VALUEFUNC(_wrap_FXText_onCmdBackspace), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdBackspaceWord", VALUEFUNC(_wrap_FXText_onCmdBackspaceWord), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdBackspaceBol", VALUEFUNC(_wrap_FXText_onCmdBackspaceBol), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdDelete", VALUEFUNC(_wrap_FXText_onCmdDelete), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdDeleteWord", VALUEFUNC(_wrap_FXText_onCmdDeleteWord), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdDeleteEol", VALUEFUNC(_wrap_FXText_onCmdDeleteEol), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdDeleteAll", VALUEFUNC(_wrap_FXText_onCmdDeleteAll), -1);
+  rb_define_method(SwigClassFXText.klass, "onCmdDeleteLine", VALUEFUNC(_wrap_FXText_onCmdDeleteLine), -1);
+  rb_define_singleton_method(SwigClassFXText.klass, "textDelimiters", VALUEFUNC(_wrap_FXText_textDelimiters_get), 0);
+  rb_define_const(SwigClassFXText.klass, "ID_CURSOR_TOP", SWIG_From_int(static_cast< int >(FXText::ID_CURSOR_TOP)));
+  rb_define_const(SwigClassFXText.klass, "ID_CURSOR_BOTTOM", SWIG_From_int(static_cast< int >(FXText::ID_CURSOR_BOTTOM)));
+  rb_define_const(SwigClassFXText.klass, "ID_CURSOR_HOME", SWIG_From_int(static_cast< int >(FXText::ID_CURSOR_HOME)));
+  rb_define_const(SwigClassFXText.klass, "ID_CURSOR_END", SWIG_From_int(static_cast< int >(FXText::ID_CURSOR_END)));
+  rb_define_const(SwigClassFXText.klass, "ID_CURSOR_RIGHT", SWIG_From_int(static_cast< int >(FXText::ID_CURSOR_RIGHT)));
+  rb_define_const(SwigClassFXText.klass, "ID_CURSOR_LEFT", SWIG_From_int(static_cast< int >(FXText::ID_CURSOR_LEFT)));
+  rb_define_const(SwigClassFXText.klass, "ID_CURSOR_UP", SWIG_From_int(static_cast< int >(FXText::ID_CURSOR_UP)));
+  rb_define_const(SwigClassFXText.klass, "ID_CURSOR_DOWN", SWIG_From_int(static_cast< int >(FXText::ID_CURSOR_DOWN)));
+  rb_define_const(SwigClassFXText.klass, "ID_CURSOR_WORD_LEFT", SWIG_From_int(static_cast< int >(FXText::ID_CURSOR_WORD_LEFT)));
+  rb_define_const(SwigClassFXText.klass, "ID_CURSOR_WORD_RIGHT", SWIG_From_int(static_cast< int >(FXText::ID_CURSOR_WORD_RIGHT)));
+  rb_define_const(SwigClassFXText.klass, "ID_CURSOR_WORD_START", SWIG_From_int(static_cast< int >(FXText::ID_CURSOR_WORD_START)));
+  rb_define_const(SwigClassFXText.klass, "ID_CURSOR_WORD_END", SWIG_From_int(static_cast< int >(FXText::ID_CURSOR_WORD_END)));
+  rb_define_const(SwigClassFXText.klass, "ID_CURSOR_PAGEDOWN", SWIG_From_int(static_cast< int >(FXText::ID_CURSOR_PAGEDOWN)));
+  rb_define_const(SwigClassFXText.klass, "ID_CURSOR_PAGEUP", SWIG_From_int(static_cast< int >(FXText::ID_CURSOR_PAGEUP)));
+  rb_define_const(SwigClassFXText.klass, "ID_CURSOR_SCRNTOP", SWIG_From_int(static_cast< int >(FXText::ID_CURSOR_SCRNTOP)));
+  rb_define_const(SwigClassFXText.klass, "ID_CURSOR_SCRNBTM", SWIG_From_int(static_cast< int >(FXText::ID_CURSOR_SCRNBTM)));
+  rb_define_const(SwigClassFXText.klass, "ID_CURSOR_SCRNCTR", SWIG_From_int(static_cast< int >(FXText::ID_CURSOR_SCRNCTR)));
+  rb_define_const(SwigClassFXText.klass, "ID_CURSOR_PAR_HOME", SWIG_From_int(static_cast< int >(FXText::ID_CURSOR_PAR_HOME)));
+  rb_define_const(SwigClassFXText.klass, "ID_CURSOR_PAR_END", SWIG_From_int(static_cast< int >(FXText::ID_CURSOR_PAR_END)));
+  rb_define_const(SwigClassFXText.klass, "ID_SCROLL_UP", SWIG_From_int(static_cast< int >(FXText::ID_SCROLL_UP)));
+  rb_define_const(SwigClassFXText.klass, "ID_SCROLL_DOWN", SWIG_From_int(static_cast< int >(FXText::ID_SCROLL_DOWN)));
+  rb_define_const(SwigClassFXText.klass, "ID_MARK", SWIG_From_int(static_cast< int >(FXText::ID_MARK)));
+  rb_define_const(SwigClassFXText.klass, "ID_EXTEND", SWIG_From_int(static_cast< int >(FXText::ID_EXTEND)));
+  rb_define_const(SwigClassFXText.klass, "ID_OVERST_STRING", SWIG_From_int(static_cast< int >(FXText::ID_OVERST_STRING)));
+  rb_define_const(SwigClassFXText.klass, "ID_INSERT_STRING", SWIG_From_int(static_cast< int >(FXText::ID_INSERT_STRING)));
+  rb_define_const(SwigClassFXText.klass, "ID_INSERT_NEWLINE", SWIG_From_int(static_cast< int >(FXText::ID_INSERT_NEWLINE)));
+  rb_define_const(SwigClassFXText.klass, "ID_INSERT_TAB", SWIG_From_int(static_cast< int >(FXText::ID_INSERT_TAB)));
+  rb_define_const(SwigClassFXText.klass, "ID_CUT_SEL", SWIG_From_int(static_cast< int >(FXText::ID_CUT_SEL)));
+  rb_define_const(SwigClassFXText.klass, "ID_COPY_SEL", SWIG_From_int(static_cast< int >(FXText::ID_COPY_SEL)));
+  rb_define_const(SwigClassFXText.klass, "ID_DELETE_SEL", SWIG_From_int(static_cast< int >(FXText::ID_DELETE_SEL)));
+  rb_define_const(SwigClassFXText.klass, "ID_PASTE_SEL", SWIG_From_int(static_cast< int >(FXText::ID_PASTE_SEL)));
+  rb_define_const(SwigClassFXText.klass, "ID_PASTE_MIDDLE", SWIG_From_int(static_cast< int >(FXText::ID_PASTE_MIDDLE)));
+  rb_define_const(SwigClassFXText.klass, "ID_SELECT_CHAR", SWIG_From_int(static_cast< int >(FXText::ID_SELECT_CHAR)));
+  rb_define_const(SwigClassFXText.klass, "ID_SELECT_WORD", SWIG_From_int(static_cast< int >(FXText::ID_SELECT_WORD)));
+  rb_define_const(SwigClassFXText.klass, "ID_SELECT_LINE", SWIG_From_int(static_cast< int >(FXText::ID_SELECT_LINE)));
+  rb_define_const(SwigClassFXText.klass, "ID_SELECT_ALL", SWIG_From_int(static_cast< int >(FXText::ID_SELECT_ALL)));
+  rb_define_const(SwigClassFXText.klass, "ID_SELECT_MATCHING", SWIG_From_int(static_cast< int >(FXText::ID_SELECT_MATCHING)));
+  rb_define_const(SwigClassFXText.klass, "ID_SELECT_BRACE", SWIG_From_int(static_cast< int >(FXText::ID_SELECT_BRACE)));
+  rb_define_const(SwigClassFXText.klass, "ID_SELECT_BRACK", SWIG_From_int(static_cast< int >(FXText::ID_SELECT_BRACK)));
+  rb_define_const(SwigClassFXText.klass, "ID_SELECT_PAREN", SWIG_From_int(static_cast< int >(FXText::ID_SELECT_PAREN)));
+  rb_define_const(SwigClassFXText.klass, "ID_SELECT_ANG", SWIG_From_int(static_cast< int >(FXText::ID_SELECT_ANG)));
+  rb_define_const(SwigClassFXText.klass, "ID_DESELECT_ALL", SWIG_From_int(static_cast< int >(FXText::ID_DESELECT_ALL)));
+  rb_define_const(SwigClassFXText.klass, "ID_BACKSPACE", SWIG_From_int(static_cast< int >(FXText::ID_BACKSPACE)));
+  rb_define_const(SwigClassFXText.klass, "ID_BACKSPACE_WORD", SWIG_From_int(static_cast< int >(FXText::ID_BACKSPACE_WORD)));
+  rb_define_const(SwigClassFXText.klass, "ID_BACKSPACE_BOL", SWIG_From_int(static_cast< int >(FXText::ID_BACKSPACE_BOL)));
+  rb_define_const(SwigClassFXText.klass, "ID_DELETE", SWIG_From_int(static_cast< int >(FXText::ID_DELETE)));
+  rb_define_const(SwigClassFXText.klass, "ID_DELETE_WORD", SWIG_From_int(static_cast< int >(FXText::ID_DELETE_WORD)));
+  rb_define_const(SwigClassFXText.klass, "ID_DELETE_EOL", SWIG_From_int(static_cast< int >(FXText::ID_DELETE_EOL)));
+  rb_define_const(SwigClassFXText.klass, "ID_DELETE_ALL", SWIG_From_int(static_cast< int >(FXText::ID_DELETE_ALL)));
+  rb_define_const(SwigClassFXText.klass, "ID_DELETE_LINE", SWIG_From_int(static_cast< int >(FXText::ID_DELETE_LINE)));
+  rb_define_const(SwigClassFXText.klass, "ID_TOGGLE_EDITABLE", SWIG_From_int(static_cast< int >(FXText::ID_TOGGLE_EDITABLE)));
+  rb_define_const(SwigClassFXText.klass, "ID_TOGGLE_OVERSTRIKE", SWIG_From_int(static_cast< int >(FXText::ID_TOGGLE_OVERSTRIKE)));
+  rb_define_const(SwigClassFXText.klass, "ID_CURSOR_ROW", SWIG_From_int(static_cast< int >(FXText::ID_CURSOR_ROW)));
+  rb_define_const(SwigClassFXText.klass, "ID_CURSOR_COLUMN", SWIG_From_int(static_cast< int >(FXText::ID_CURSOR_COLUMN)));
+  rb_define_const(SwigClassFXText.klass, "ID_CLEAN_INDENT", SWIG_From_int(static_cast< int >(FXText::ID_CLEAN_INDENT)));
+  rb_define_const(SwigClassFXText.klass, "ID_SHIFT_LEFT", SWIG_From_int(static_cast< int >(FXText::ID_SHIFT_LEFT)));
+  rb_define_const(SwigClassFXText.klass, "ID_SHIFT_RIGHT", SWIG_From_int(static_cast< int >(FXText::ID_SHIFT_RIGHT)));
+  rb_define_const(SwigClassFXText.klass, "ID_SHIFT_TABLEFT", SWIG_From_int(static_cast< int >(FXText::ID_SHIFT_TABLEFT)));
+  rb_define_const(SwigClassFXText.klass, "ID_SHIFT_TABRIGHT", SWIG_From_int(static_cast< int >(FXText::ID_SHIFT_TABRIGHT)));
+  rb_define_const(SwigClassFXText.klass, "ID_UPPER_CASE", SWIG_From_int(static_cast< int >(FXText::ID_UPPER_CASE)));
+  rb_define_const(SwigClassFXText.klass, "ID_LOWER_CASE", SWIG_From_int(static_cast< int >(FXText::ID_LOWER_CASE)));
+  rb_define_const(SwigClassFXText.klass, "ID_GOTO_MATCHING", SWIG_From_int(static_cast< int >(FXText::ID_GOTO_MATCHING)));
+  rb_define_const(SwigClassFXText.klass, "ID_GOTO_SELECTED", SWIG_From_int(static_cast< int >(FXText::ID_GOTO_SELECTED)));
+  rb_define_const(SwigClassFXText.klass, "ID_GOTO_LINE", SWIG_From_int(static_cast< int >(FXText::ID_GOTO_LINE)));
+  rb_define_const(SwigClassFXText.klass, "ID_SEARCH_FORW_SEL", SWIG_From_int(static_cast< int >(FXText::ID_SEARCH_FORW_SEL)));
+  rb_define_const(SwigClassFXText.klass, "ID_SEARCH_BACK_SEL", SWIG_From_int(static_cast< int >(FXText::ID_SEARCH_BACK_SEL)));
+  rb_define_const(SwigClassFXText.klass, "ID_SEARCH_FORW", SWIG_From_int(static_cast< int >(FXText::ID_SEARCH_FORW)));
+  rb_define_const(SwigClassFXText.klass, "ID_SEARCH_BACK", SWIG_From_int(static_cast< int >(FXText::ID_SEARCH_BACK)));
+  rb_define_const(SwigClassFXText.klass, "ID_SEARCH", SWIG_From_int(static_cast< int >(FXText::ID_SEARCH)));
+  rb_define_const(SwigClassFXText.klass, "ID_REPLACE", SWIG_From_int(static_cast< int >(FXText::ID_REPLACE)));
+  rb_define_const(SwigClassFXText.klass, "ID_LEFT_BRACE", SWIG_From_int(static_cast< int >(FXText::ID_LEFT_BRACE)));
+  rb_define_const(SwigClassFXText.klass, "ID_LEFT_BRACK", SWIG_From_int(static_cast< int >(FXText::ID_LEFT_BRACK)));
+  rb_define_const(SwigClassFXText.klass, "ID_LEFT_PAREN", SWIG_From_int(static_cast< int >(FXText::ID_LEFT_PAREN)));
+  rb_define_const(SwigClassFXText.klass, "ID_LEFT_ANG", SWIG_From_int(static_cast< int >(FXText::ID_LEFT_ANG)));
+  rb_define_const(SwigClassFXText.klass, "ID_RIGHT_BRACE", SWIG_From_int(static_cast< int >(FXText::ID_RIGHT_BRACE)));
+  rb_define_const(SwigClassFXText.klass, "ID_RIGHT_BRACK", SWIG_From_int(static_cast< int >(FXText::ID_RIGHT_BRACK)));
+  rb_define_const(SwigClassFXText.klass, "ID_RIGHT_PAREN", SWIG_From_int(static_cast< int >(FXText::ID_RIGHT_PAREN)));
+  rb_define_const(SwigClassFXText.klass, "ID_RIGHT_ANG", SWIG_From_int(static_cast< int >(FXText::ID_RIGHT_ANG)));
+  rb_define_const(SwigClassFXText.klass, "ID_BLINK", SWIG_From_int(static_cast< int >(FXText::ID_BLINK)));
+  rb_define_const(SwigClassFXText.klass, "ID_FLASH", SWIG_From_int(static_cast< int >(FXText::ID_FLASH)));
+  rb_define_const(SwigClassFXText.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXText::ID_LAST)));
+  rb_define_method(SwigClassFXText.klass, "setMarginTop", VALUEFUNC(_wrap_FXText_setMarginTop), -1);
+  rb_define_method(SwigClassFXText.klass, "getMarginTop", VALUEFUNC(_wrap_FXText_getMarginTop), -1);
+  rb_define_method(SwigClassFXText.klass, "setMarginBottom", VALUEFUNC(_wrap_FXText_setMarginBottom), -1);
+  rb_define_method(SwigClassFXText.klass, "getMarginBottom", VALUEFUNC(_wrap_FXText_getMarginBottom), -1);
+  rb_define_method(SwigClassFXText.klass, "setMarginLeft", VALUEFUNC(_wrap_FXText_setMarginLeft), -1);
+  rb_define_method(SwigClassFXText.klass, "getMarginLeft", VALUEFUNC(_wrap_FXText_getMarginLeft), -1);
+  rb_define_method(SwigClassFXText.klass, "setMarginRight", VALUEFUNC(_wrap_FXText_setMarginRight), -1);
+  rb_define_method(SwigClassFXText.klass, "getMarginRight", VALUEFUNC(_wrap_FXText_getMarginRight), -1);
+  rb_define_method(SwigClassFXText.klass, "getWrapColumns", VALUEFUNC(_wrap_FXText_getWrapColumns), -1);
+  rb_define_method(SwigClassFXText.klass, "setWrapColumns", VALUEFUNC(_wrap_FXText_setWrapColumns), -1);
+  rb_define_method(SwigClassFXText.klass, "getTabColumns", VALUEFUNC(_wrap_FXText_getTabColumns), -1);
+  rb_define_method(SwigClassFXText.klass, "setTabColumns", VALUEFUNC(_wrap_FXText_setTabColumns), -1);
+  rb_define_method(SwigClassFXText.klass, "getBarColumns", VALUEFUNC(_wrap_FXText_getBarColumns), -1);
+  rb_define_method(SwigClassFXText.klass, "setBarColumns", VALUEFUNC(_wrap_FXText_setBarColumns), -1);
+  rb_define_method(SwigClassFXText.klass, "isModified", VALUEFUNC(_wrap_FXText_isModified), -1);
+  rb_define_method(SwigClassFXText.klass, "setModified", VALUEFUNC(_wrap_FXText_setModified), -1);
+  rb_define_method(SwigClassFXText.klass, "setEditable", VALUEFUNC(_wrap_FXText_setEditable), -1);
+  rb_define_method(SwigClassFXText.klass, "isEditable", VALUEFUNC(_wrap_FXText_isEditable), -1);
+  rb_define_method(SwigClassFXText.klass, "overstrike=", VALUEFUNC(_wrap_FXText_overstrikee___), -1);
+  rb_define_method(SwigClassFXText.klass, "overstrike?", VALUEFUNC(_wrap_FXText_overstrikeq___), -1);
+  rb_define_method(SwigClassFXText.klass, "setStyled", VALUEFUNC(_wrap_FXText_setStyled), -1);
+  rb_define_method(SwigClassFXText.klass, "isStyled", VALUEFUNC(_wrap_FXText_isStyled), -1);
+  rb_define_method(SwigClassFXText.klass, "setDelimiters", VALUEFUNC(_wrap_FXText_setDelimiters), -1);
+  rb_define_method(SwigClassFXText.klass, "getDelimiters", VALUEFUNC(_wrap_FXText_getDelimiters), -1);
+  rb_define_method(SwigClassFXText.klass, "setFont", VALUEFUNC(_wrap_FXText_setFont), -1);
+  rb_define_method(SwigClassFXText.klass, "getFont", VALUEFUNC(_wrap_FXText_getFont), -1);
+  rb_define_method(SwigClassFXText.klass, "setTextColor", VALUEFUNC(_wrap_FXText_setTextColor), -1);
+  rb_define_method(SwigClassFXText.klass, "getTextColor", VALUEFUNC(_wrap_FXText_getTextColor), -1);
+  rb_define_method(SwigClassFXText.klass, "setSelBackColor", VALUEFUNC(_wrap_FXText_setSelBackColor), -1);
+  rb_define_method(SwigClassFXText.klass, "getSelBackColor", VALUEFUNC(_wrap_FXText_getSelBackColor), -1);
+  rb_define_method(SwigClassFXText.klass, "setSelTextColor", VALUEFUNC(_wrap_FXText_setSelTextColor), -1);
+  rb_define_method(SwigClassFXText.klass, "getSelTextColor", VALUEFUNC(_wrap_FXText_getSelTextColor), -1);
+  rb_define_method(SwigClassFXText.klass, "setHiliteTextColor", VALUEFUNC(_wrap_FXText_setHiliteTextColor), -1);
+  rb_define_method(SwigClassFXText.klass, "getHiliteTextColor", VALUEFUNC(_wrap_FXText_getHiliteTextColor), -1);
+  rb_define_method(SwigClassFXText.klass, "setHiliteBackColor", VALUEFUNC(_wrap_FXText_setHiliteBackColor), -1);
+  rb_define_method(SwigClassFXText.klass, "getHiliteBackColor", VALUEFUNC(_wrap_FXText_getHiliteBackColor), -1);
+  rb_define_method(SwigClassFXText.klass, "setActiveBackColor", VALUEFUNC(_wrap_FXText_setActiveBackColor), -1);
+  rb_define_method(SwigClassFXText.klass, "getActiveBackColor", VALUEFUNC(_wrap_FXText_getActiveBackColor), -1);
+  rb_define_method(SwigClassFXText.klass, "setCursorColor", VALUEFUNC(_wrap_FXText_setCursorColor), -1);
+  rb_define_method(SwigClassFXText.klass, "getCursorColor", VALUEFUNC(_wrap_FXText_getCursorColor), -1);
+  rb_define_method(SwigClassFXText.klass, "setNumberColor", VALUEFUNC(_wrap_FXText_setNumberColor), -1);
+  rb_define_method(SwigClassFXText.klass, "getNumberColor", VALUEFUNC(_wrap_FXText_getNumberColor), -1);
+  rb_define_method(SwigClassFXText.klass, "setBarColor", VALUEFUNC(_wrap_FXText_setBarColor), -1);
+  rb_define_method(SwigClassFXText.klass, "getBarColor", VALUEFUNC(_wrap_FXText_getBarColor), -1);
+  rb_define_method(SwigClassFXText.klass, "setHelpText", VALUEFUNC(_wrap_FXText_setHelpText), -1);
+  rb_define_method(SwigClassFXText.klass, "getHelpText", VALUEFUNC(_wrap_FXText_getHelpText), -1);
+  rb_define_method(SwigClassFXText.klass, "setTipText", VALUEFUNC(_wrap_FXText_setTipText), -1);
+  rb_define_method(SwigClassFXText.klass, "getTipText", VALUEFUNC(_wrap_FXText_getTipText), -1);
+  rb_define_method(SwigClassFXText.klass, "getByte", VALUEFUNC(_wrap_FXText_getByte), -1);
+  rb_define_method(SwigClassFXText.klass, "getChar", VALUEFUNC(_wrap_FXText_getChar), -1);
+  rb_define_method(SwigClassFXText.klass, "getCharLen", VALUEFUNC(_wrap_FXText_getCharLen), -1);
+  rb_define_method(SwigClassFXText.klass, "getStyle", VALUEFUNC(_wrap_FXText_getStyle), -1);
+  rb_define_method(SwigClassFXText.klass, "extractText", VALUEFUNC(_wrap_FXText_extractText), -1);
+  rb_define_method(SwigClassFXText.klass, "extractStyle", VALUEFUNC(_wrap_FXText_extractStyle), -1);
+  rb_define_method(SwigClassFXText.klass, "getText", VALUEFUNC(_wrap_FXText_getText), -1);
+  rb_define_method(SwigClassFXText.klass, "getLength", VALUEFUNC(_wrap_FXText_getLength), -1);
+  rb_define_method(SwigClassFXText.klass, "numRows", VALUEFUNC(_wrap_FXText_numRows), -1);
+  rb_define_method(SwigClassFXText.klass, "shiftText", VALUEFUNC(_wrap_FXText_shiftText), -1);
+  rb_define_method(SwigClassFXText.klass, "findText", VALUEFUNC(_wrap_FXText_findText), -1);
+  rb_define_method(SwigClassFXText.klass, "isPosSelected", VALUEFUNC(_wrap_FXText_isPosSelected), -1);
+  rb_define_method(SwigClassFXText.klass, "isPosVisible", VALUEFUNC(_wrap_FXText_isPosVisible), -1);
+  rb_define_method(SwigClassFXText.klass, "getPosAt", VALUEFUNC(_wrap_FXText_getPosAt), -1);
+  rb_define_method(SwigClassFXText.klass, "countRows", VALUEFUNC(_wrap_FXText_countRows), -1);
+  rb_define_method(SwigClassFXText.klass, "countCols", VALUEFUNC(_wrap_FXText_countCols), -1);
+  rb_define_method(SwigClassFXText.klass, "countLines", VALUEFUNC(_wrap_FXText_countLines), -1);
+  rb_define_method(SwigClassFXText.klass, "lineStart", VALUEFUNC(_wrap_FXText_lineStart), -1);
+  rb_define_method(SwigClassFXText.klass, "lineEnd", VALUEFUNC(_wrap_FXText_lineEnd), -1);
+  rb_define_method(SwigClassFXText.klass, "nextLine", VALUEFUNC(_wrap_FXText_nextLine), -1);
+  rb_define_method(SwigClassFXText.klass, "prevLine", VALUEFUNC(_wrap_FXText_prevLine), -1);
+  rb_define_method(SwigClassFXText.klass, "rowStart", VALUEFUNC(_wrap_FXText_rowStart), -1);
+  rb_define_method(SwigClassFXText.klass, "rowEnd", VALUEFUNC(_wrap_FXText_rowEnd), -1);
+  rb_define_method(SwigClassFXText.klass, "nextRow", VALUEFUNC(_wrap_FXText_nextRow), -1);
+  rb_define_method(SwigClassFXText.klass, "prevRow", VALUEFUNC(_wrap_FXText_prevRow), -1);
+  rb_define_method(SwigClassFXText.klass, "leftWord", VALUEFUNC(_wrap_FXText_leftWord), -1);
+  rb_define_method(SwigClassFXText.klass, "rightWord", VALUEFUNC(_wrap_FXText_rightWord), -1);
+  rb_define_method(SwigClassFXText.klass, "wordStart", VALUEFUNC(_wrap_FXText_wordStart), -1);
+  rb_define_method(SwigClassFXText.klass, "wordEnd", VALUEFUNC(_wrap_FXText_wordEnd), -1);
+  rb_define_method(SwigClassFXText.klass, "validPos", VALUEFUNC(_wrap_FXText_validPos), -1);
+  rb_define_method(SwigClassFXText.klass, "dec", VALUEFUNC(_wrap_FXText_dec), -1);
+  rb_define_method(SwigClassFXText.klass, "inc", VALUEFUNC(_wrap_FXText_inc), -1);
+  rb_define_method(SwigClassFXText.klass, "setTopLine", VALUEFUNC(_wrap_FXText_setTopLine), -1);
+  rb_define_method(SwigClassFXText.klass, "getTopLine", VALUEFUNC(_wrap_FXText_getTopLine), -1);
+  rb_define_method(SwigClassFXText.klass, "setBottomLine", VALUEFUNC(_wrap_FXText_setBottomLine), -1);
+  rb_define_method(SwigClassFXText.klass, "getBottomLine", VALUEFUNC(_wrap_FXText_getBottomLine), -1);
+  rb_define_method(SwigClassFXText.klass, "setCenterLine", VALUEFUNC(_wrap_FXText_setCenterLine), -1);
+  rb_define_method(SwigClassFXText.klass, "setAnchorPos", VALUEFUNC(_wrap_FXText_setAnchorPos), -1);
+  rb_define_method(SwigClassFXText.klass, "getAnchorPos", VALUEFUNC(_wrap_FXText_getAnchorPos), -1);
+  rb_define_method(SwigClassFXText.klass, "setCursorRow", VALUEFUNC(_wrap_FXText_setCursorRow), -1);
+  rb_define_method(SwigClassFXText.klass, "getCursorRow", VALUEFUNC(_wrap_FXText_getCursorRow), -1);
+  rb_define_method(SwigClassFXText.klass, "setCursorColumn", VALUEFUNC(_wrap_FXText_setCursorColumn), -1);
+  rb_define_method(SwigClassFXText.klass, "getCursorColumn", VALUEFUNC(_wrap_FXText_getCursorColumn), -1);
+  rb_define_method(SwigClassFXText.klass, "getCursorPos", VALUEFUNC(_wrap_FXText_getCursorPos), -1);
+  rb_define_method(SwigClassFXText.klass, "getSelStartPos", VALUEFUNC(_wrap_FXText_getSelStartPos), -1);
+  rb_define_method(SwigClassFXText.klass, "getSelEndPos", VALUEFUNC(_wrap_FXText_getSelEndPos), -1);
+  rb_define_method(SwigClassFXText.klass, "selectAll", VALUEFUNC(_wrap_FXText_selectAll), -1);
+  rb_define_method(SwigClassFXText.klass, "setSelection", VALUEFUNC(_wrap_FXText_setSelection), -1);
+  rb_define_method(SwigClassFXText.klass, "setHighlight", VALUEFUNC(_wrap_FXText_setHighlight), -1);
+  rb_define_method(SwigClassFXText.klass, "killHighlight", VALUEFUNC(_wrap_FXText_killHighlight), -1);
+  rb_define_method(SwigClassFXText.klass, "makePositionVisible", VALUEFUNC(_wrap_FXText_makePositionVisible), -1);
+  rb_define_method(SwigClassFXText.klass, "setTextStyle", VALUEFUNC(_wrap_FXText_setTextStyle), -1);
+  rb_define_method(SwigClassFXText.klass, "getTextStyle", VALUEFUNC(_wrap_FXText_getTextStyle), -1);
+  rb_define_method(SwigClassFXText.klass, "setVisibleRows", VALUEFUNC(_wrap_FXText_setVisibleRows), -1);
+  rb_define_method(SwigClassFXText.klass, "getVisibleRows", VALUEFUNC(_wrap_FXText_getVisibleRows), -1);
+  rb_define_method(SwigClassFXText.klass, "setVisibleColumns", VALUEFUNC(_wrap_FXText_setVisibleColumns), -1);
+  rb_define_method(SwigClassFXText.klass, "getVisibleColumns", VALUEFUNC(_wrap_FXText_getVisibleColumns), -1);
+  rb_define_method(SwigClassFXText.klass, "setHiliteMatchTime", VALUEFUNC(_wrap_FXText_setHiliteMatchTime), -1);
+  rb_define_method(SwigClassFXText.klass, "getHiliteMatchTime", VALUEFUNC(_wrap_FXText_getHiliteMatchTime), -1);
+  rb_define_method(SwigClassFXText.klass, "setHiliteStyles", VALUEFUNC(_wrap_FXText_setHiliteStyles), -1);
+  rb_define_method(SwigClassFXText.klass, "getHiliteStyles", VALUEFUNC(_wrap_FXText_getHiliteStyles), -1);
+  rb_define_method(SwigClassFXText.klass, "save", VALUEFUNC(_wrap_FXText_save), -1);
+  rb_define_method(SwigClassFXText.klass, "load", VALUEFUNC(_wrap_FXText_load), -1);
+  rb_define_method(SwigClassFXText.klass, "create", VALUEFUNC(_wrap_FXText_create), -1);
+  rb_define_method(SwigClassFXText.klass, "detach", VALUEFUNC(_wrap_FXText_detach), -1);
+  rb_define_method(SwigClassFXText.klass, "destroy", VALUEFUNC(_wrap_FXText_destroy), -1);
+  rb_define_method(SwigClassFXText.klass, "resize", VALUEFUNC(_wrap_FXText_resize), -1);
+  rb_define_method(SwigClassFXText.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXText_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXText.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXText_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXText.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXText_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXText.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXText_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXText.klass, "canFocus", VALUEFUNC(_wrap_FXText_canFocus), -1);
+  rb_define_method(SwigClassFXText.klass, "setFocus", VALUEFUNC(_wrap_FXText_setFocus), -1);
+  rb_define_method(SwigClassFXText.klass, "killFocus", VALUEFUNC(_wrap_FXText_killFocus), -1);
+  rb_define_method(SwigClassFXText.klass, "changeFocus", VALUEFUNC(_wrap_FXText_changeFocus), -1);
+  rb_define_method(SwigClassFXText.klass, "setDefault", VALUEFUNC(_wrap_FXText_setDefault), -1);
+  rb_define_method(SwigClassFXText.klass, "enable", VALUEFUNC(_wrap_FXText_enable), -1);
+  rb_define_method(SwigClassFXText.klass, "disable", VALUEFUNC(_wrap_FXText_disable), -1);
+  rb_define_method(SwigClassFXText.klass, "raiseWindow", VALUEFUNC(_wrap_FXText_raiseWindow), -1);
+  rb_define_method(SwigClassFXText.klass, "lower", VALUEFUNC(_wrap_FXText_lower), -1);
+  rb_define_method(SwigClassFXText.klass, "move", VALUEFUNC(_wrap_FXText_move), -1);
+  rb_define_method(SwigClassFXText.klass, "layout", VALUEFUNC(_wrap_FXText_layout), -1);
+  rb_define_method(SwigClassFXText.klass, "recalc", VALUEFUNC(_wrap_FXText_recalc), -1);
+  rb_define_method(SwigClassFXText.klass, "reparent", VALUEFUNC(_wrap_FXText_reparent), -1);
+  rb_define_method(SwigClassFXText.klass, "show", VALUEFUNC(_wrap_FXText_show), -1);
+  rb_define_method(SwigClassFXText.klass, "hide", VALUEFUNC(_wrap_FXText_hide), -1);
+  rb_define_method(SwigClassFXText.klass, "isComposite", VALUEFUNC(_wrap_FXText_isComposite), -1);
+  rb_define_method(SwigClassFXText.klass, "contains", VALUEFUNC(_wrap_FXText_contains), -1);
+  rb_define_method(SwigClassFXText.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXText_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXText.klass, "setBackColor", VALUEFUNC(_wrap_FXText_setBackColor), -1);
+  rb_define_method(SwigClassFXText.klass, "tr", VALUEFUNC(_wrap_FXText_tr), -1);
+  rb_define_method(SwigClassFXText.klass, "dropEnable", VALUEFUNC(_wrap_FXText_dropEnable), -1);
+  rb_define_method(SwigClassFXText.klass, "dropDisable", VALUEFUNC(_wrap_FXText_dropDisable), -1);
+  rb_define_method(SwigClassFXText.klass, "setShape", VALUEFUNC(_wrap_FXText_setShape), -1);
+  rb_define_method(SwigClassFXText.klass, "clearShape", VALUEFUNC(_wrap_FXText_clearShape), -1);
+  rb_define_method(SwigClassFXText.klass, "getViewportHeight", VALUEFUNC(_wrap_FXText_getViewportHeight), -1);
+  rb_define_method(SwigClassFXText.klass, "getViewportWidth", VALUEFUNC(_wrap_FXText_getViewportWidth), -1);
+  rb_define_method(SwigClassFXText.klass, "getContentHeight", VALUEFUNC(_wrap_FXText_getContentHeight), -1);
+  rb_define_method(SwigClassFXText.klass, "getContentWidth", VALUEFUNC(_wrap_FXText_getContentWidth), -1);
+  rb_define_method(SwigClassFXText.klass, "position", VALUEFUNC(_wrap_FXText_position), -1);
+  rb_define_method(SwigClassFXText.klass, "eraseCursorOverhang", VALUEFUNC(_wrap_FXText_eraseCursorOverhang), -1);
+  rb_define_method(SwigClassFXText.klass, "drawCursor", VALUEFUNC(_wrap_FXText_drawCursor), -1);
+  rb_define_method(SwigClassFXText.klass, "style", VALUEFUNC(_wrap_FXText_style), -1);
+  rb_define_method(SwigClassFXText.klass, "drawBufferText", VALUEFUNC(_wrap_FXText_drawBufferText), -1);
+  rb_define_method(SwigClassFXText.klass, "fillBufferRect", VALUEFUNC(_wrap_FXText_fillBufferRect), -1);
+  rb_define_method(SwigClassFXText.klass, "drawTextRow", VALUEFUNC(_wrap_FXText_drawTextRow), -1);
+  rb_define_method(SwigClassFXText.klass, "drawContents", VALUEFUNC(_wrap_FXText_drawContents), -1);
+  rb_define_method(SwigClassFXText.klass, "drawNumbers", VALUEFUNC(_wrap_FXText_drawNumbers), -1);
+  rb_define_method(SwigClassFXText.klass, "setCursorPos", VALUEFUNC(_wrap_FXText_setCursorPos), -1);
+  rb_define_method(SwigClassFXText.klass, "extendSelection", VALUEFUNC(_wrap_FXText_extendSelection), -1);
+  rb_define_method(SwigClassFXText.klass, "killSelection", VALUEFUNC(_wrap_FXText_killSelection), -1);
+  rb_define_method(SwigClassFXText.klass, "replaceText", VALUEFUNC(_wrap_FXText_replaceText), -1);
+  rb_define_method(SwigClassFXText.klass, "replaceStyledText", VALUEFUNC(_wrap_FXText_replaceStyledText), -1);
+  rb_define_method(SwigClassFXText.klass, "appendText", VALUEFUNC(_wrap_FXText_appendText), -1);
+  rb_define_method(SwigClassFXText.klass, "appendStyledText", VALUEFUNC(_wrap_FXText_appendStyledText), -1);
+  rb_define_method(SwigClassFXText.klass, "insertText", VALUEFUNC(_wrap_FXText_insertText), -1);
+  rb_define_method(SwigClassFXText.klass, "insertStyledText", VALUEFUNC(_wrap_FXText_insertStyledText), -1);
+  rb_define_method(SwigClassFXText.klass, "removeText", VALUEFUNC(_wrap_FXText_removeText), -1);
+  rb_define_method(SwigClassFXText.klass, "changeStyle", VALUEFUNC(_wrap_FXText_changeStyle), -1);
+  rb_define_method(SwigClassFXText.klass, "setText", VALUEFUNC(_wrap_FXText_setText), -1);
+  rb_define_method(SwigClassFXText.klass, "setStyledText", VALUEFUNC(_wrap_FXText_setStyledText), -1);
+  SwigClassFXText.mark = (void (*)(void *)) FXRbText::markfunc;
+  SwigClassFXText.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXText.trackObjects = 0;
+}
+
diff --git a/ext/fox16_c/treelist_wrap.cpp b/ext/fox16_c/treelist_wrap.cpp
new file mode 100644
index 00000000..ea465667
--- /dev/null
+++ b/ext/fox16_c/treelist_wrap.cpp
@@ -0,0 +1,21634 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 3.0.12
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+
+#ifndef SWIGRUBY
+#define SWIGRUBY
+#endif
+
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
+};
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic C API SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "4"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/*  Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN           0x1
+
+
+/*
+   Flags/methods for returning states.
+
+   The SWIG conversion methods, as ConvertPtr, return an integer
+   that tells if the conversion was successful or not. And if not,
+   an error code can be returned (see swigerrors.swg for the codes).
+
+   Use the following macros/flags to set or process the returning
+   states.
+
+   In old versions of SWIG, code such as the following was usually written:
+
+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+       // success code
+     } else {
+       //fail code
+     }
+
+   Now you can be more explicit:
+
+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+    } else {
+      // fail code
+    }
+
+   which is the same really, but now you can also do
+
+    Type *ptr;
+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+      if (SWIG_IsNewObj(res) {
+        ...
+	delete *ptr;
+      } else {
+        ...
+      }
+    } else {
+      // fail code
+    }
+
+   I.e., now SWIG_ConvertPtr can return new objects and you can
+   identify the case and take care of the deallocation. Of course that
+   also requires SWIG_ConvertPtr to return new result values, such as
+
+      int SWIG_ConvertPtr(obj, ptr,...) {
+        if (<obj is ok>) {
+          if (<need new object>) {
+            *ptr = <ptr to new allocated object>;
+            return SWIG_NEWOBJ;
+          } else {
+            *ptr = <ptr to old object>;
+            return SWIG_OLDOBJ;
+          }
+        } else {
+          return SWIG_BADOBJ;
+        }
+      }
+
+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+   SWIG errors code.
+
+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+   allows to return the 'cast rank', for example, if you have this
+
+       int food(double)
+       int fooi(int);
+
+   and you call
+
+      food(1)   // cast rank '1'  (1 -> 1.0)
+      fooi(1)   // cast rank '0'
+
+   just use the SWIG_AddCast()/SWIG_CheckState()
+*/
+
+#define SWIG_OK                    (0)
+#define SWIG_ERROR                 (-1)
+#define SWIG_IsOK(r)               (r >= 0)
+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT         (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ                (SWIG_ERROR)
+#define SWIG_OLDOBJ                (SWIG_OK)
+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+#  ifndef SWIG_TypeRank
+#    define SWIG_TypeRank             unsigned long
+#  endif
+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
+#    define SWIG_MAXCASTRANK          (2)
+#  endif
+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+#  define SWIG_AddCast(r) (r)
+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *, int *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store information on one type */
+typedef struct swig_type_info {
+  const char             *name;			/* mangled name of this type */
+  const char             *str;			/* human readable name of this type */
+  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
+  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
+  void                   *clientdata;		/* language specific type data */
+  int                    owndata;		/* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
+  swig_converter_func     converter;		/* function to cast the void pointers */
+  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
+  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
+  size_t                 size;		        /* Number of types in this module */
+  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
+  swig_type_info         **type_initial;	/* Array of initially generated type structures */
+  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
+  void                    *clientdata;		/* Language specific module data */
+} swig_module_info;
+
+/*
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+  }
+  return (int)((l1 - f1) - (l2 - f2));
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCmp(const char *nb, const char *tb) {
+  int equiv = 1;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (equiv != 0 && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
+}
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
+}
+
+/*
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+  swig_type_info *lastty = ty;
+  if (!ty || !ty->dcast) return ty;
+  while (ty && (ty->dcast)) {
+    ty = (*ty->dcast)(ptr);
+    if (ty) lastty = ty;
+  }
+  return lastty;
+}
+
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+  return ty->name;
+}
+
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (!type) return NULL;
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
+  }
+  else
+    return type->name;
+}
+
+/*
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+  swig_cast_info *cast = ti->cast;
+  /* if (ti->clientdata == clientdata) return; */
+  ti->clientdata = clientdata;
+
+  while (cast) {
+    if (!cast->converter) {
+      swig_type_info *tc = cast->type;
+      if (!tc->clientdata) {
+	SWIG_TypeClientData(tc, clientdata);
+      }
+    }
+    cast = cast->next;
+  }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientData(ti, clientdata);
+  ti->owndata = 1;
+}
+
+/*
+  Search for a swig_type_info structure only by mangled name
+  Search is a O(log #types)
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+                            swig_module_info *end,
+		            const char *name) {
+  swig_module_info *iter = start;
+  do {
+    if (iter->size) {
+      size_t l = 0;
+      size_t r = iter->size - 1;
+      do {
+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
+	size_t i = (l + r) >> 1;
+	const char *iname = iter->types[i]->name;
+	if (iname) {
+	  int compare = strcmp(name, iname);
+	  if (compare == 0) {
+	    return iter->types[i];
+	  } else if (compare < 0) {
+	    if (i) {
+	      r = i - 1;
+	    } else {
+	      break;
+	    }
+	  } else if (compare > 0) {
+	    l = i + 1;
+	  }
+	} else {
+	  break; /* should never happen */
+	}
+      } while (l <= r);
+    }
+    iter = iter->next;
+  } while (iter != end);
+  return 0;
+}
+
+/*
+  Search for a swig_type_info structure for either a mangled name or a human readable name.
+  It first searches the mangled names of the types, which is a O(log #types)
+  If a type is not found it then searches the human readable names, which is O(#types).
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+                     swig_module_info *end,
+		     const char *name) {
+  /* STEP 1: Search the name field using binary search */
+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+  if (ret) {
+    return ret;
+  } else {
+    /* STEP 2: If the type hasn't been found, do a complete search
+       of the str field (the human readable name) */
+    swig_module_info *iter = start;
+    do {
+      size_t i = 0;
+      for (; i < iter->size; ++i) {
+	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+	  return iter->types[i];
+      }
+      iter = iter->next;
+    } while (iter != end);
+  }
+
+  /* neither found a match */
+  return 0;
+}
+
+/*
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+
+/*
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = (unsigned char)((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = (unsigned char)((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (unsigned char)(d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (unsigned char)(d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/*
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/*  Errors in SWIG */
+#define  SWIG_UnknownError    	   -1
+#define  SWIG_IOError        	   -2
+#define  SWIG_RuntimeError   	   -3
+#define  SWIG_IndexError     	   -4
+#define  SWIG_TypeError      	   -5
+#define  SWIG_DivisionByZero 	   -6
+#define  SWIG_OverflowError  	   -7
+#define  SWIG_SyntaxError    	   -8
+#define  SWIG_ValueError     	   -9
+#define  SWIG_SystemError    	   -10
+#define  SWIG_AttributeError 	   -11
+#define  SWIG_MemoryError    	   -12
+#define  SWIG_NullReferenceError   -13
+
+
+
+      #include <ruby.h>
+
+      #if defined(RB_METHOD_DEFINITION_DECL)
+      # define RUBY_VALUE_METHOD_FUNC(func) (func)
+      # define RUBY_INT_METHOD_FUNC(func) (func)
+      # define RUBY_VOID_METHOD_FUNC(func) (func)
+      # define RUBY_VOIDP_METHOD_FUNC(func) (func)
+      #else
+      # define RUBY_VALUE_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
+      # define RUBY_INT_METHOD_FUNC(func) ((int (*)(ANYARGS))(func))
+      # define RUBY_VOID_METHOD_FUNC(func) ((void (*)(ANYARGS))(func))
+      # define RUBY_VOIDP_METHOD_FUNC(func) ((void *(*)(ANYARGS))(func))
+      #endif
+
+
+/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
+ * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
+ * issue for now by disabling this.
+ * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
+ */
+#ifdef rb_intern
+# undef rb_intern
+#endif
+
+/* Remove global macros defined in Ruby's win32.h */
+#ifdef write
+# undef write
+#endif
+#ifdef read
+# undef read
+#endif
+#ifdef bind
+# undef bind
+#endif
+#ifdef close
+# undef close
+#endif
+#ifdef connect
+# undef connect
+#endif
+
+
+/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
+#ifndef NUM2LL
+#define NUM2LL(x) NUM2LONG((x))
+#endif
+#ifndef LL2NUM
+#define LL2NUM(x) INT2NUM((long) (x))
+#endif
+#ifndef ULL2NUM
+#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
+#endif
+
+/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
+#ifndef NUM2ULL
+#ifdef HAVE_LONG_LONG
+#define NUM2ULL(x) rb_num2ull((x))
+#else
+#define NUM2ULL(x) NUM2ULONG(x)
+#endif
+#endif
+
+/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
+/* Define these for older versions so we can just write code the new way */
+#ifndef RSTRING_LEN
+# define RSTRING_LEN(x) RSTRING(x)->len
+#endif
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(x) RSTRING(x)->ptr
+#endif
+#ifndef RSTRING_END
+# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
+#endif
+#ifndef RARRAY_LEN
+# define RARRAY_LEN(x) RARRAY(x)->len
+#endif
+#ifndef RARRAY_PTR
+# define RARRAY_PTR(x) RARRAY(x)->ptr
+#endif
+#ifndef RFLOAT_VALUE
+# define RFLOAT_VALUE(x) RFLOAT(x)->value
+#endif
+#ifndef DOUBLE2NUM
+# define DOUBLE2NUM(x) rb_float_new(x)
+#endif
+#ifndef RHASH_TBL
+# define RHASH_TBL(x) (RHASH(x)->tbl)
+#endif
+#ifndef RHASH_ITER_LEV
+# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
+#endif
+#ifndef RHASH_IFNONE
+# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
+#endif
+#ifndef RHASH_SIZE
+# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
+#endif
+#ifndef RHASH_EMPTY_P
+# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
+#endif
+#ifndef RSTRUCT_LEN
+# define RSTRUCT_LEN(x) RSTRUCT(x)->len
+#endif
+#ifndef RSTRUCT_PTR
+# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
+#endif
+
+
+
+/*
+ * Need to be very careful about how these macros are defined, especially
+ * when compiling C++ code or C code with an ANSI C compiler.
+ *
+ * VALUEFUNC(f) is a macro used to typecast a C function that implements
+ * a Ruby method so that it can be passed as an argument to API functions
+ * like rb_define_method() and rb_define_singleton_method().
+ *
+ * VOIDFUNC(f) is a macro used to typecast a C function that implements
+ * either the "mark" or "free" stuff for a Ruby Data object, so that it
+ * can be passed as an argument to API functions like Data_Wrap_Struct()
+ * and Data_Make_Struct().
+ */
+ 
+#ifdef __cplusplus
+#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
+#    define PROTECTFUNC(f) ((VALUE (*)()) f)
+#    define VALUEFUNC(f) ((VALUE (*)()) f)
+#    define VOIDFUNC(f)  ((void (*)()) f)
+#  else
+#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
+#      define PROTECTFUNC(f) ((VALUE (*)()) f)
+#      define VALUEFUNC(f) ((VALUE (*)()) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    else /* These definitions should work for Ruby 1.7+ */
+#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
+#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    endif
+#  endif
+#else
+#  define VALUEFUNC(f) (f)
+#  define VOIDFUNC(f) (f)
+#endif
+
+/* Don't use for expressions have side effect */
+#ifndef RB_STRING_VALUE
+#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
+#endif
+#ifndef StringValue
+#define StringValue(s) RB_STRING_VALUE(s)
+#endif
+#ifndef StringValuePtr
+#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
+#endif
+#ifndef StringValueLen
+#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
+#endif
+#ifndef SafeStringValue
+#define SafeStringValue(v) do {\
+    StringValue(v);\
+    rb_check_safe_str(v);\
+} while (0)
+#endif
+
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
+#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
+#endif
+
+static VALUE _mSWIG = Qnil;
+
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+
+/* Define some additional error types */
+#define SWIG_ObjectPreviouslyDeletedError  -100
+
+
+/* Define custom exceptions for errors that do not map to existing Ruby
+   exceptions.  Note this only works for C++ since a global cannot be
+   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/
+
+SWIGINTERN VALUE 
+getNullReferenceError(void) {
+  static int init = 0;
+  static VALUE rb_eNullReferenceError ;
+  if (!init) {
+    init = 1;
+    rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
+  }
+  return rb_eNullReferenceError;
+} 
+
+SWIGINTERN VALUE 
+getObjectPreviouslyDeletedError(void) {
+  static int init = 0;
+  static VALUE rb_eObjectPreviouslyDeleted ;
+  if (!init) {
+    init = 1;
+    rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
+  }
+  return rb_eObjectPreviouslyDeleted;
+} 
+
+
+SWIGINTERN VALUE
+SWIG_Ruby_ErrorType(int SWIG_code) {
+  VALUE type;
+  switch (SWIG_code) {
+  case SWIG_MemoryError:
+    type = rb_eNoMemError;
+    break;
+  case SWIG_IOError:
+    type = rb_eIOError;
+    break;
+  case SWIG_RuntimeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_IndexError:
+    type = rb_eIndexError;
+    break;
+  case SWIG_TypeError:
+    type = rb_eTypeError;
+    break;
+  case SWIG_DivisionByZero:
+    type = rb_eZeroDivError;
+    break;
+  case SWIG_OverflowError:
+    type = rb_eRangeError;
+    break;
+  case SWIG_SyntaxError:
+    type = rb_eSyntaxError;
+    break;
+  case SWIG_ValueError:
+    type = rb_eArgError;
+    break;
+  case SWIG_SystemError:
+    type = rb_eFatal;
+    break;
+  case SWIG_AttributeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_NullReferenceError:
+    type = getNullReferenceError();
+    break;
+  case SWIG_ObjectPreviouslyDeletedError:
+    type = getObjectPreviouslyDeletedError();
+    break;
+  case SWIG_UnknownError:
+    type = rb_eRuntimeError;
+    break;
+  default:
+    type = rb_eRuntimeError;
+  }
+  return type;
+}
+
+
+/* This function is called when a user inputs a wrong argument to
+   a method.
+ */
+SWIGINTERN 
+const char* Ruby_Format_TypeError( const char* msg,
+				   const char* type, 
+				   const char* name, 
+				   const int argn,
+				   VALUE input )
+{
+  char buf[128];
+  VALUE str;
+  VALUE asStr;
+  if ( msg && *msg )
+    {
+      str = rb_str_new2(msg);
+    }
+  else
+    {
+      str = rb_str_new(NULL, 0);
+    }
+
+  str = rb_str_cat2( str, "Expected argument " );
+  sprintf( buf, "%d of type ", argn-1 );
+  str = rb_str_cat2( str, buf );
+  str = rb_str_cat2( str, type );
+  str = rb_str_cat2( str, ", but got " );
+  str = rb_str_cat2( str, rb_obj_classname(input) );
+  str = rb_str_cat2( str, " " );
+  asStr = rb_inspect(input);
+  if ( RSTRING_LEN(asStr) > 30 )
+    {
+      str = rb_str_cat( str, StringValuePtr(asStr), 30 );
+      str = rb_str_cat2( str, "..." );
+    }
+  else
+    {
+      str = rb_str_append( str, asStr );
+    }
+
+  if ( name )
+    {
+      str = rb_str_cat2( str, "\n\tin SWIG method '" );
+      str = rb_str_cat2( str, name );
+      str = rb_str_cat2( str, "'" );
+    }
+
+  return StringValuePtr( str );
+}
+
+/* This function is called when an overloaded method fails */
+SWIGINTERN 
+void Ruby_Format_OverloadedError(
+				 const int argc,
+				 const int maxargs,
+				 const char* method, 
+				 const char* prototypes 
+				 )
+{
+  const char* msg = "Wrong # of arguments";
+  if ( argc <= maxargs ) msg = "Wrong arguments";
+  rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
+	   "Possible C/C++ prototypes are:\n%s",
+	   msg, method, prototypes);
+}
+
+/* -----------------------------------------------------------------------------
+ * rubytracking.swg
+ *
+ * This file contains support for tracking mappings from 
+ * Ruby objects to C++ objects.  This functionality is needed
+ * to implement mark functions for Ruby's mark and sweep
+ * garbage collector.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(ST_DATA_T_DEFINED)
+/* Needs to be explicitly included for Ruby 1.8 and earlier */
+#include <st.h>
+#endif
+
+/* Ruby 1.8 actually assumes the first case. */
+#if SIZEOF_VOIDP == SIZEOF_LONG
+#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
+#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
+#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
+#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
+#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
+#else
+#  error sizeof(void*) is not the same as long or long long
+#endif
+
+/* Global hash table to store Trackings from C/C++
+   structs to Ruby Objects. 
+*/
+static st_table* swig_ruby_trackings = NULL;
+
+static VALUE swig_ruby_trackings_count(ID id, VALUE *var) {
+  return SWIG2NUM(swig_ruby_trackings->num_entries);
+}
+
+
+/* Setup a hash table to store Trackings */
+SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
+  /* Create a hash table to store Trackings from C++
+     objects to Ruby objects. */
+
+  /* Try to see if some other .so has already created a 
+     tracking hash table, which we keep hidden in an instance var
+     in the SWIG module.
+     This is done to allow multiple DSOs to share the same
+     tracking table.
+  */
+  VALUE trackings_value = Qnil;
+  /* change the variable name so that we can mix modules
+     compiled with older SWIG's - this used to be called "@__trackings__" */
+  ID trackings_id = rb_intern( "@__safetrackings__" );
+  VALUE verbose = rb_gv_get("VERBOSE");
+  rb_gv_set("VERBOSE", Qfalse);
+  trackings_value = rb_ivar_get( _mSWIG, trackings_id );
+  rb_gv_set("VERBOSE", verbose);
+
+  /* The trick here is that we have to store the hash table
+  pointer in a Ruby variable. We do not want Ruby's GC to
+  treat this pointer as a Ruby object, so we convert it to
+  a Ruby numeric value. */
+  if (trackings_value == Qnil) {
+    /* No, it hasn't.  Create one ourselves */
+    swig_ruby_trackings = st_init_numtable();
+    rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
+  } else {
+    swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
+  }
+
+        rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", RUBY_VALUE_METHOD_FUNC(swig_ruby_trackings_count), RUBY_VOID_METHOD_FUNC((rb_gvar_setter_t*)NULL))
+;
+}
+
+/* Add a Tracking from a C/C++ struct to a Ruby object */
+SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
+  /* Store the mapping to the global hash table. */
+  st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
+}
+
+/* Get the Ruby object that owns the specified C/C++ struct */
+SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
+  /* Now lookup the value stored in the global hash table */
+  VALUE value;
+
+  if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
+    return value;
+  } else {
+    return Qnil;
+  }
+}
+
+/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
+   is very important to remove objects once they are destroyed
+   since the same memory address may be reused later to create
+   a new object. */
+SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
+  /* Delete the object from the hash table */
+  st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
+}
+
+/* This is a helper method that unlinks a Ruby object from its
+   underlying C++ object.  This is needed if the lifetime of the
+   Ruby object is longer than the C++ object */
+SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
+  VALUE object = SWIG_RubyInstanceFor(ptr);
+
+  if (object != Qnil) {
+    if (TYPE(object) != T_DATA)
+      abort();
+    DATA_PTR(object) = 0;
+  }
+}
+
+/* This is a helper method that iterates over all the trackings
+   passing the C++ object pointer and its related Ruby object
+   to the passed callback function. */
+
+/* Proxy method to abstract the internal trackings datatype */
+      static int swig_ruby_internal_iterate_callback(st_data_t ptr, st_data_t obj, st_data_t meth) {
+        ((void(*)(void*, VALUE))meth)((void*)ptr, (VALUE)obj);
+
+  return ST_CONTINUE;
+}
+
+SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
+  st_foreach(swig_ruby_trackings, RUBY_INT_METHOD_FUNC(swig_ruby_internal_iterate_callback), (st_data_t)meth);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Ruby API portion that goes into the runtime
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGINTERN VALUE
+SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
+  if (NIL_P(target)) {
+    target = o;
+  } else {
+    if (TYPE(target) != T_ARRAY) {
+      VALUE o2 = target;
+      target = rb_ary_new();
+      rb_ary_push(target, o2);
+    }
+    rb_ary_push(target, o);
+  }
+  return target;
+}
+
+/* For ruby1.8.4 and earlier. */
+#ifndef RUBY_INIT_STACK
+   RUBY_EXTERN void Init_stack(VALUE* addr);
+#  define RUBY_INIT_STACK \
+   VALUE variable_in_this_stack_frame; \
+   Init_stack(&variable_in_this_stack_frame);
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* -----------------------------------------------------------------------------
+ * rubyrun.swg
+ *
+ * This file contains the runtime support for Ruby modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
+#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
+#define swig_owntype                                    swig_ruby_owntype
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) 		SWIG_Ruby_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
+#define SWIG_Error(code, msg)            		rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
+#define SWIG_fail                        		goto fail				 
+
+
+/* Ruby-specific SWIG API */
+
+#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
+#define SWIG_define_class(ty)                        	SWIG_Ruby_define_class(ty)
+#define SWIG_NewClassInstance(value, ty)             	SWIG_Ruby_NewClassInstance(value, ty)
+#define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
+#define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  
+
+#include "assert.h"
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  VALUE klass;
+  VALUE mImpl;
+  void  (*mark)(void *);
+  void  (*destroy)(void *);
+  int trackObjects;
+} swig_class;
+
+
+/* Global pointer used to keep some internal SWIG stuff */
+static VALUE _cSWIG_Pointer = Qnil;
+static VALUE swig_runtime_data_type_pointer = Qnil;
+
+/* Global IDs used to keep some internal SWIG stuff */
+static ID swig_arity_id = 0;
+static ID swig_call_id  = 0;
+
+/*
+  If your swig extension is to be run within an embedded ruby and has
+  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
+  This will reset ruby's stack frame on each entry point from the main 
+  program the first time a virtual director function is invoked (in a 
+  non-recursive way).
+  If this is not done, you run the risk of Ruby trashing the stack.
+*/
+
+#ifdef RUBY_EMBEDDED
+
+#  define SWIG_INIT_STACK                            \
+      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
+      ++swig_virtual_calls;
+#  define SWIG_RELEASE_STACK --swig_virtual_calls;
+#  define Ruby_DirectorTypeMismatchException(x) \
+          rb_raise( rb_eTypeError, "%s", x ); return c_result;
+
+      static unsigned int swig_virtual_calls = 0;
+
+#else  /* normal non-embedded extension */
+
+#  define SWIG_INIT_STACK
+#  define SWIG_RELEASE_STACK
+#  define Ruby_DirectorTypeMismatchException(x) \
+          throw Swig::DirectorTypeMismatchException( x );
+
+#endif  /* RUBY_EMBEDDED */
+
+
+SWIGRUNTIME VALUE 
+getExceptionClass(void) {
+  static int init = 0;
+  static VALUE rubyExceptionClass ;
+  if (!init) {
+    init = 1;
+    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
+  }
+  return rubyExceptionClass;
+} 
+
+/* This code checks to see if the Ruby object being raised as part
+   of an exception inherits from the Ruby class Exception.  If so,
+   the object is simply returned.  If not, then a new Ruby exception
+   object is created and that will be returned to Ruby.*/
+SWIGRUNTIME VALUE
+SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
+  VALUE exceptionClass = getExceptionClass();
+  if (rb_obj_is_kind_of(obj, exceptionClass)) {
+    return obj;
+  }  else {
+    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
+  }
+}
+
+/* Initialize Ruby runtime support */
+SWIGRUNTIME void
+SWIG_Ruby_InitRuntime(void)
+{
+  if (_mSWIG == Qnil) {
+    _mSWIG = rb_define_module("SWIG");
+    swig_call_id  = rb_intern("call");
+    swig_arity_id = rb_intern("arity");
+  }
+}
+
+/* Define Ruby class for C type */
+SWIGRUNTIME void
+SWIG_Ruby_define_class(swig_type_info *type)
+{
+  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+  sprintf(klass_name, "TYPE%s", type->name);
+  if (NIL_P(_cSWIG_Pointer)) {
+    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
+    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
+  }
+  rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
+  free((void *) klass_name);
+}
+
+/* Create a new pointer object */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
+{
+  int own =  flags & SWIG_POINTER_OWN; 
+  int track;
+  char *klass_name;
+  swig_class *sklass;
+  VALUE klass;
+  VALUE obj;
+  
+  if (!ptr)
+    return Qnil;
+  
+  if (type->clientdata) {
+    sklass = (swig_class *) type->clientdata;
+		
+    /* Are we tracking this class and have we already returned this Ruby object? */
+    track = sklass->trackObjects;
+    if (track) {
+      obj = SWIG_RubyInstanceFor(ptr);
+      
+      /* Check the object's type and make sure it has the correct type.
+        It might not in cases where methods do things like 
+        downcast methods. */
+      if (obj != Qnil) {
+        VALUE value = rb_iv_get(obj, "@__swigtype__");
+        const char* type_name = RSTRING_PTR(value);
+				
+        if (strcmp(type->name, type_name) == 0) {
+          return obj;
+        }
+      }
+    }
+
+    /* Create a new Ruby object */
+    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
+			   ( own ? VOIDFUNC(sklass->destroy) : 
+			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
+			     ), ptr);
+
+    /* If tracking is on for this class then track this object. */
+    if (track) {
+      SWIG_RubyAddTracking(ptr, obj);
+    }
+  } else {
+    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+    sprintf(klass_name, "TYPE%s", type->name);
+    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
+    free((void *) klass_name);
+    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
+  }
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  
+  return obj;
+}
+
+/* Create a new class instance (always owned) */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
+{
+  VALUE obj;
+  swig_class *sklass = (swig_class *) type->clientdata;
+  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  return obj;
+}
+
+/* Get type mangle from class name */
+SWIGRUNTIMEINLINE char *
+SWIG_Ruby_MangleStr(VALUE obj)
+{
+  VALUE stype = rb_iv_get(obj, "@__swigtype__");
+  return StringValuePtr(stype);
+}
+
+/* Acquire a pointer value */
+typedef struct {
+  void (*datafree)(void *);
+  int own;
+} swig_ruby_owntype;
+
+SWIGRUNTIME swig_ruby_owntype
+SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
+  swig_ruby_owntype oldown = {0, 0};
+  if (obj) {
+    oldown.datafree = RDATA(obj)->dfree;
+    RDATA(obj)->dfree = own.datafree;
+  }
+  return oldown;
+}
+
+/* Convert a pointer value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
+{
+  char *c;
+  swig_cast_info *tc;
+  void *vptr = 0;
+
+  /* Grab the pointer */
+  if (NIL_P(obj)) {
+    if (ptr)
+      *ptr = 0;
+    return SWIG_OK;
+  } else {
+    if (TYPE(obj) != T_DATA) {
+      return SWIG_ERROR;
+    }
+    Data_Get_Struct(obj, void, vptr);
+  }
+  
+  if (own) {
+    own->datafree = RDATA(obj)->dfree;
+    own->own = 0;
+  }
+    
+  /* Check to see if the input object is giving up ownership
+     of the underlying C struct or C++ object.  If so then we
+     need to reset the destructor since the Ruby object no 
+     longer owns the underlying C++ object.*/ 
+  if (flags & SWIG_POINTER_DISOWN) {
+    /* Is tracking on for this class? */
+    int track = 0;
+    if (ty && ty->clientdata) {
+      swig_class *sklass = (swig_class *) ty->clientdata;
+      track = sklass->trackObjects;
+    }
+		
+    if (track) {
+      /* We are tracking objects for this class.  Thus we change the destructor
+       * to SWIG_RubyRemoveTracking.  This allows us to
+       * remove the mapping from the C++ to Ruby object
+       * when the Ruby object is garbage collected.  If we don't
+       * do this, then it is possible we will return a reference 
+       * to a Ruby object that no longer exists thereby crashing Ruby. */
+      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
+    } else {    
+      RDATA(obj)->dfree = 0;
+    }
+  }
+
+  /* Do type-checking if type info was provided */
+  if (ty) {
+    if (ty->clientdata) {
+      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
+        if (vptr == 0) {
+          /* The object has already been deleted */
+          return SWIG_ObjectPreviouslyDeletedError;
+        }
+      }
+    }
+    if ((c = SWIG_MangleStr(obj)) == NULL) {
+      return SWIG_ERROR;
+    }
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) {
+      return SWIG_ERROR;
+    } else {
+      if (ptr) {
+        if (tc->type == ty) {
+          *ptr = vptr;
+        } else {
+          int newmemory = 0;
+          *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
+          if (newmemory == SWIG_CAST_NEW_MEMORY) {
+            assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+            if (own)
+              own->own = own->own | SWIG_CAST_NEW_MEMORY;
+          }
+        }
+      }
+    }
+  } else {
+    if (ptr)
+      *ptr = vptr;
+  }
+  
+  return SWIG_OK;
+}
+
+/* Check convert */
+SWIGRUNTIMEINLINE int
+SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
+{
+  char *c = SWIG_MangleStr(obj);
+  if (!c) return 0;
+  return SWIG_TypeCheck(c,ty) != 0;
+}
+
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r, ptr, sz);
+  strcpy(r, type->name);
+  return rb_str_new2(result);
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c;
+
+  if (TYPE(obj) != T_STRING) goto type_error;
+  c = StringValuePtr(obj);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') goto type_error;
+  c++;
+  c = SWIG_UnpackData(c, ptr, sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) goto type_error;
+  }
+  return SWIG_OK;
+
+ type_error:
+  return SWIG_ERROR;
+}
+
+SWIGRUNTIME swig_module_info *
+SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
+{
+  VALUE pointer;
+  swig_module_info *ret = 0;
+  VALUE verbose = rb_gv_get("VERBOSE");
+
+ /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
+  rb_gv_set("VERBOSE", Qfalse);
+  
+  /* first check if pointer already created */
+  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  if (pointer != Qnil) {
+    Data_Get_Struct(pointer, swig_module_info, ret);
+  }
+
+  /* reinstate warnings */
+  rb_gv_set("VERBOSE", verbose);
+  return ret;
+}
+
+SWIGRUNTIME void 
+SWIG_Ruby_SetModule(swig_module_info *pointer)
+{
+  /* register a new class */
+  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
+  /* create and store the structure pointer to a global variable */
+  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
+  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
+}
+
+/* This function can be used to check whether a proc or method or similarly
+   callable function has been passed.  Usually used in a %typecheck, like:
+
+   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
+        $result = SWIG_Ruby_isCallable( $input );
+   }
+ */
+SWIGINTERN
+int SWIG_Ruby_isCallable( VALUE proc )
+{
+  if ( rb_respond_to( proc, swig_call_id ) )
+    return 1;
+  return 0;
+}
+
+/* This function can be used to check the arity (number of arguments)
+   a proc or method can take.  Usually used in a %typecheck.
+   Valid arities will be that equal to minimal or those < 0
+   which indicate a variable number of parameters at the end.
+ */
+SWIGINTERN
+int SWIG_Ruby_arity( VALUE proc, int minimal )
+{
+  if ( rb_respond_to( proc, swig_arity_id ) )
+    {
+      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
+      int arity = NUM2INT(num);
+      if ( arity < 0 && (arity+1) < -minimal ) return 1;
+      if ( arity == minimal ) return 1;
+      return 1;
+    }
+  return 0;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
+
+
+
+  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) 
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_p_FX4Splitter swig_types[0]
+#define SWIGTYPE_p_FX7Segment swig_types[1]
+#define SWIGTYPE_p_FXAccelTable swig_types[2]
+#define SWIGTYPE_p_FXApp swig_types[3]
+#define SWIGTYPE_p_FXArrowButton swig_types[4]
+#define SWIGTYPE_p_FXBitmap swig_types[5]
+#define SWIGTYPE_p_FXBitmapFrame swig_types[6]
+#define SWIGTYPE_p_FXCURCursor swig_types[7]
+#define SWIGTYPE_p_FXCanvas swig_types[8]
+#define SWIGTYPE_p_FXColorBar swig_types[9]
+#define SWIGTYPE_p_FXColorRing swig_types[10]
+#define SWIGTYPE_p_FXColorSelector swig_types[11]
+#define SWIGTYPE_p_FXColorWell swig_types[12]
+#define SWIGTYPE_p_FXColorWheel swig_types[13]
+#define SWIGTYPE_p_FXComboBox swig_types[14]
+#define SWIGTYPE_p_FXComposite swig_types[15]
+#define SWIGTYPE_p_FXCursor swig_types[16]
+#define SWIGTYPE_p_FXDataTarget swig_types[17]
+#define SWIGTYPE_p_FXDebugTarget swig_types[18]
+#define SWIGTYPE_p_FXDelegator swig_types[19]
+#define SWIGTYPE_p_FXDial swig_types[20]
+#define SWIGTYPE_p_FXDict swig_types[21]
+#define SWIGTYPE_p_FXDirBox swig_types[22]
+#define SWIGTYPE_p_FXDirItem swig_types[23]
+#define SWIGTYPE_p_FXDirList swig_types[24]
+#define SWIGTYPE_p_FXDirSelector swig_types[25]
+#define SWIGTYPE_p_FXDockBar swig_types[26]
+#define SWIGTYPE_p_FXDockHandler swig_types[27]
+#define SWIGTYPE_p_FXDockSite swig_types[28]
+#define SWIGTYPE_p_FXDockTitle swig_types[29]
+#define SWIGTYPE_p_FXDocument swig_types[30]
+#define SWIGTYPE_p_FXDragCorner swig_types[31]
+#define SWIGTYPE_p_FXDrawable swig_types[32]
+#define SWIGTYPE_p_FXDriveBox swig_types[33]
+#define SWIGTYPE_p_FXFileDict swig_types[34]
+#define SWIGTYPE_p_FXFileSelector swig_types[35]
+#define SWIGTYPE_p_FXFileStream swig_types[36]
+#define SWIGTYPE_p_FXFoldingItem swig_types[37]
+#define SWIGTYPE_p_FXFoldingList swig_types[38]
+#define SWIGTYPE_p_FXFoldingListSortFunc swig_types[39]
+#define SWIGTYPE_p_FXFont swig_types[40]
+#define SWIGTYPE_p_FXFontSelector swig_types[41]
+#define SWIGTYPE_p_FXFrame swig_types[42]
+#define SWIGTYPE_p_FXGIFCursor swig_types[43]
+#define SWIGTYPE_p_FXGradientBar swig_types[44]
+#define SWIGTYPE_p_FXGroupBox swig_types[45]
+#define SWIGTYPE_p_FXHeader swig_types[46]
+#define SWIGTYPE_p_FXHeaderItem swig_types[47]
+#define SWIGTYPE_p_FXHorizontalFrame swig_types[48]
+#define SWIGTYPE_p_FXHorizontalSeparator swig_types[49]
+#define SWIGTYPE_p_FXIcon swig_types[50]
+#define SWIGTYPE_p_FXIconDict swig_types[51]
+#define SWIGTYPE_p_FXId swig_types[52]
+#define SWIGTYPE_p_FXImageFrame swig_types[53]
+#define SWIGTYPE_p_FXImageView swig_types[54]
+#define SWIGTYPE_p_FXKnob swig_types[55]
+#define SWIGTYPE_p_FXListBox swig_types[56]
+#define SWIGTYPE_p_FXMainWindow swig_types[57]
+#define SWIGTYPE_p_FXMatrix swig_types[58]
+#define SWIGTYPE_p_FXMemoryStream swig_types[59]
+#define SWIGTYPE_p_FXObject swig_types[60]
+#define SWIGTYPE_p_FXPacker swig_types[61]
+#define SWIGTYPE_p_FXPopup swig_types[62]
+#define SWIGTYPE_p_FXProgressBar swig_types[63]
+#define SWIGTYPE_p_FXRealSlider swig_types[64]
+#define SWIGTYPE_p_FXRealSpinner swig_types[65]
+#define SWIGTYPE_p_FXRecentFiles swig_types[66]
+#define SWIGTYPE_p_FXRegion swig_types[67]
+#define SWIGTYPE_p_FXRegistry swig_types[68]
+#define SWIGTYPE_p_FXRootWindow swig_types[69]
+#define SWIGTYPE_p_FXRuler swig_types[70]
+#define SWIGTYPE_p_FXRulerView swig_types[71]
+#define SWIGTYPE_p_FXScrollArea swig_types[72]
+#define SWIGTYPE_p_FXScrollBar swig_types[73]
+#define SWIGTYPE_p_FXScrollCorner swig_types[74]
+#define SWIGTYPE_p_FXScrollWindow swig_types[75]
+#define SWIGTYPE_p_FXSeparator swig_types[76]
+#define SWIGTYPE_p_FXSettings swig_types[77]
+#define SWIGTYPE_p_FXShell swig_types[78]
+#define SWIGTYPE_p_FXShutter swig_types[79]
+#define SWIGTYPE_p_FXShutterItem swig_types[80]
+#define SWIGTYPE_p_FXSlider swig_types[81]
+#define SWIGTYPE_p_FXSpinner swig_types[82]
+#define SWIGTYPE_p_FXSplashWindow swig_types[83]
+#define SWIGTYPE_p_FXSplitter swig_types[84]
+#define SWIGTYPE_p_FXSpring swig_types[85]
+#define SWIGTYPE_p_FXStatusBar swig_types[86]
+#define SWIGTYPE_p_FXStatusLine swig_types[87]
+#define SWIGTYPE_p_FXStream swig_types[88]
+#define SWIGTYPE_p_FXStringDict swig_types[89]
+#define SWIGTYPE_p_FXSwitcher swig_types[90]
+#define SWIGTYPE_p_FXTabBar swig_types[91]
+#define SWIGTYPE_p_FXTabBook swig_types[92]
+#define SWIGTYPE_p_FXTextField swig_types[93]
+#define SWIGTYPE_p_FXToolBar swig_types[94]
+#define SWIGTYPE_p_FXToolBarGrip swig_types[95]
+#define SWIGTYPE_p_FXToolBarShell swig_types[96]
+#define SWIGTYPE_p_FXToolBarTab swig_types[97]
+#define SWIGTYPE_p_FXToolTip swig_types[98]
+#define SWIGTYPE_p_FXTopWindow swig_types[99]
+#define SWIGTYPE_p_FXTranslator swig_types[100]
+#define SWIGTYPE_p_FXTreeItem swig_types[101]
+#define SWIGTYPE_p_FXTreeList swig_types[102]
+#define SWIGTYPE_p_FXTreeListBox swig_types[103]
+#define SWIGTYPE_p_FXVerticalFrame swig_types[104]
+#define SWIGTYPE_p_FXVerticalSeparator swig_types[105]
+#define SWIGTYPE_p_FXVisual swig_types[106]
+#define SWIGTYPE_p_FXWindow swig_types[107]
+#define SWIGTYPE_p_char swig_types[108]
+#define SWIGTYPE_p_double swig_types[109]
+#define SWIGTYPE_p_float swig_types[110]
+#define SWIGTYPE_p_int swig_types[111]
+#define SWIGTYPE_p_long swig_types[112]
+#define SWIGTYPE_p_short swig_types[113]
+#define SWIGTYPE_p_unsigned_char swig_types[114]
+#define SWIGTYPE_p_unsigned_int swig_types[115]
+#define SWIGTYPE_p_unsigned_long swig_types[116]
+#define SWIGTYPE_p_unsigned_short swig_types[117]
+static swig_type_info *swig_types[119];
+static swig_module_info swig_module = {swig_types, 118, 0, 0, 0, 0};
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
+
+/* -------- TYPES TABLE (END) -------- */
+
+#define SWIG_init    Init_treelist
+#define SWIG_name    "Treelist"
+
+
+
+#define SWIG_RUBY_THREAD_BEGIN_BLOCK
+#define SWIG_RUBY_THREAD_END_BLOCK
+
+
+#define SWIGVERSION 0x030012 
+#define SWIG_VERSION SWIGVERSION
+
+
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
+
+
+#include <stdexcept>
+
+
+#include "FXRbCommon.h"
+
+
+inline FXColor to_FXColor(VALUE obj){
+  if(TYPE(obj)==T_STRING){
+    return fxcolorfromname(StringValuePtr(obj));
+    }
+  else if(TYPE(obj)==T_SYMBOL){
+    return fxcolorfromname(rb_id2name(SYM2ID(obj)));
+    }
+  else{
+    return NUM2ULONG(obj);
+    }
+  }
+
+
+inline FXString to_FXString(VALUE obj){
+  if(!NIL_P(obj)){
+    Check_Type(obj,T_STRING);
+    return FXString(StringValuePtr(obj));
+    }
+  else{
+    return FXString::null;
+    }
+  }
+
+
+inline FXbool to_FXbool(VALUE obj){
+  if (obj == Qtrue || obj == Qfalse){
+    return (obj == Qtrue) ? TRUE : FALSE;
+    }
+  else{
+    return static_cast<FXbool>(NUM2UINT(obj));
+    }
+  }
+
+
+static swig_type_info* FXEventTypeInfo=0;
+
+inline void* to_FXEvent(VALUE obj){
+  void* ptr;
+  if(!FXEventTypeInfo){
+    FXEventTypeInfo=SWIG_TypeQuery("FXEvent *");
+    FXASSERT(FXEventTypeInfo!=0);
+    }
+  SWIG_ConvertPtr(obj,&ptr,FXEventTypeInfo,1);
+  return ptr;
+  }
+
+
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
+
+
+  #define SWIG_From_long   LONG2NUM 
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_int  (int value)
+{    
+  return SWIG_From_long  (value);
+}
+
+SWIGINTERN FXFoldingItem *new_FXFoldingItem(FXString const &text,FXIcon *oi=0,FXIcon *ci=0,void *ITEMDATA=0){
+      return new FXRbFoldingItem(text,oi,ci,ITEMDATA);
+      }
+SWIGINTERN void FXFoldingItem_setData(FXFoldingItem *self,VALUE ptr){
+      self->setData(reinterpret_cast<void*>(ptr));
+      }
+SWIGINTERN VALUE FXFoldingItem_getData(FXFoldingItem const *self){
+      return self->getData() ? reinterpret_cast<VALUE>(self->getData()) : Qnil;
+      }
+SWIGINTERN FXFoldingList *new_FXFoldingList(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=FOLDINGLIST_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbFoldingList(p,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN void FXFoldingList_setHeaders(FXFoldingList *self,VALUE stringArray,FXint size=1){
+      Check_Type(stringArray,T_ARRAY);
+      long len=RARRAY_LEN(stringArray);
+      const FXchar **strings;
+      if(FXMALLOC(&strings,FXchar*,len+1)){
+        for(long i=0;i<len;i++){
+          VALUE s=rb_ary_entry(stringArray,i);
+          strings[i]=StringValuePtr(s);
+          }
+        strings[len]=0;
+        self->setHeaders(strings,size);
+        FXFREE(&strings);
+        }
+      }
+SWIGINTERN FXint FXFoldingList_fillItems(FXFoldingList *self,FXFoldingItem *father,FXchar const **strings,FXIcon *oi=0,FXIcon *ci=0,void *ITEMDATA=0,FXbool notify=0){
+      return self->fillItems(father,strings,oi,ci,ITEMDATA,notify);
+      }
+SWIGINTERN FXFoldingItem *FXFoldingList_insertItem__SWIG_0(FXFoldingList *self,FXFoldingItem *other,FXFoldingItem *father,FXFoldingItem *item,FXbool notify=0){
+      if(item->isMemberOf(FXMETACLASS(FXRbFoldingItem))){
+        dynamic_cast<FXRbFoldingItem*>(item)->owned=1;
+        }
+      return self->insertItem(other,father,item,notify);
+      }
+SWIGINTERN FXFoldingItem *FXFoldingList_appendItem__SWIG_0(FXFoldingList *self,FXFoldingItem *father,FXFoldingItem *item,FXbool notify=0){
+      if(item->isMemberOf(FXMETACLASS(FXRbFoldingItem))){
+        dynamic_cast<FXRbFoldingItem*>(item)->owned=1;
+        }
+      return self->appendItem(father,item,notify);
+      }
+SWIGINTERN FXFoldingItem *FXFoldingList_prependItem__SWIG_0(FXFoldingList *self,FXFoldingItem *father,FXFoldingItem *item,FXbool notify=0){
+      if(item->isMemberOf(FXMETACLASS(FXRbFoldingItem))){
+        dynamic_cast<FXRbFoldingItem*>(item)->owned=1;
+        }
+      return self->prependItem(father,item,notify);
+      }
+SWIGINTERN void FXFoldingList_removeItem(FXFoldingList *self,FXFoldingItem *item,FXbool notify=0){
+      // Save pointer(s) to the soon-to-be-destroyed items
+      FXObjectListOf<FXFoldingItem> items;
+      FXRbFoldingList::enumerateItem(item,items);
+
+      // Do the deed
+      self->removeItem(item,notify);
+
+      // Now zero-out pointers held by still-alive Ruby objects
+      for(FXint i=0;i<items.no();i++){
+        FXRbUnregisterRubyObj(items[i]);
+        }
+      }
+SWIGINTERN void FXFoldingList_removeItems(FXFoldingList *self,FXFoldingItem *fm,FXFoldingItem *to,FXbool notify=0){
+      // Save pointer(s) to the soon-to-be-destroyed items
+      FXObjectListOf<FXFoldingItem> items;
+      FXRbFoldingList::enumerateItems(fm,to,items);
+
+      // Do the deed
+      self->removeItems(fm,to,notify);
+
+      // Now zero-out pointers held by still-alive Ruby objects
+      for(FXint i=0;i<items.no();i++){
+        FXRbUnregisterRubyObj(items[i]);
+        }
+      }
+SWIGINTERN void FXFoldingList_clearItems(FXFoldingList *self,FXbool notify=0){
+      // Save pointer(s) to the soon-to-be-destroyed items
+      FXObjectListOf<FXFoldingItem> items;
+      FXRbFoldingList::enumerateItems(self->getFirstItem(),self->getLastItem(),items);
+
+      // Do the deed
+      self->clearItems(notify);
+
+      // Now zero-out pointers held by still-alive Ruby objects
+      for(FXint i=0;i<items.no();i++){
+        FXRbUnregisterRubyObj(items[i]);
+        }
+      }
+SWIGINTERN void FXFoldingList_setItemData(FXFoldingList *self,FXFoldingItem *item,VALUE ptr){
+      self->setItemData(item,reinterpret_cast<void*>(ptr));
+      }
+SWIGINTERN VALUE FXFoldingList_getItemData(FXFoldingList const *self,FXFoldingItem const *item){
+      return self->getItemData(item) ? reinterpret_cast<VALUE>(self->getItemData(item)) : Qnil;
+      }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_long  (unsigned long value)
+{
+  return ULONG2NUM(value); 
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_int  (unsigned int value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_bool  (bool value)
+{
+  return value ? Qtrue : Qfalse;
+}
+
+
+SWIGINTERN swig_type_info*
+SWIG_pchar_descriptor(void)
+{
+  static int init = 0;
+  static swig_type_info* info = 0;
+  if (!init) {
+    info = SWIG_TypeQuery("_p_char");
+    init = 1;
+  }
+  return info;
+}
+
+
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
+{
+  if (TYPE(obj) == T_STRING) {
+    char *cstr = StringValuePtr(obj); 
+    size_t size = RSTRING_LEN(obj) + 1;
+    if (cptr)  {
+      if (alloc) {
+	if (*alloc == SWIG_NEWOBJ) {
+	  *cptr = reinterpret_cast< char* >(memcpy(new char[size], cstr, sizeof(char)*(size)));
+	} else {
+	  *cptr = cstr;
+	  *alloc = SWIG_OLDOBJ;
+	}
+      }
+    }
+    if (psize) *psize = size;
+    return SWIG_OK;
+  } else {
+    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+    if (pchar_descriptor) {
+      void* vptr = 0;
+      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
+	if (cptr) *cptr = (char *)vptr;
+	if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
+	if (alloc) *alloc = SWIG_OLDOBJ;
+	return SWIG_OK;
+      }
+    }
+  }  
+  return SWIG_TypeError;
+}
+
+
+
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+  if (carray) {
+    if (size > LONG_MAX) {
+      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+      return pchar_descriptor ? 
+	SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : Qnil;
+    } else {
+      return rb_str_new(carray, static_cast< long >(size));
+    }
+  } else {
+    return Qnil;
+  }
+}
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtr(const char *cptr)
+{ 
+  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
+}
+
+SWIGINTERN VALUE FXFoldingList_position__SWIG_1(FXFoldingList const *self){
+    FXint x, y;
+    self->getPosition(x, y);
+    VALUE pos = rb_ary_new();
+    rb_ary_push(pos, INT2NUM(x));
+    rb_ary_push(pos, INT2NUM(y));
+    return pos;
+  }
+SWIGINTERN FXTreeItem *new_FXTreeItem(FXString const &text,FXIcon *oi=0,FXIcon *ci=0,void *ITEMDATA=0){
+      return new FXRbTreeItem(text,oi,ci,ITEMDATA);
+      }
+SWIGINTERN void FXTreeItem_setData(FXTreeItem *self,VALUE ptr){
+      self->setData((void*) ptr);
+      }
+SWIGINTERN VALUE FXTreeItem_getData(FXTreeItem const *self){
+      return self->getData() ? (VALUE) self->getData() : Qnil;
+      }
+
+static swig_type_info *FXTreeItem_dynamic_cast(void **ptr) {
+    FXTreeItem **ppTreeItem = reinterpret_cast<FXTreeItem **>(ptr);
+    FXDirItem *pDirItem=dynamic_cast<FXDirItem*>(*ppTreeItem);
+    if(pDirItem){
+      *ptr=reinterpret_cast<void*>(pDirItem);
+      return SWIG_TypeQuery("FXDirItem *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXTreeList *new_FXTreeList(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=TREELIST_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbTreeList(p,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN FXTreeItem *FXTreeList_insertItem__SWIG_0(FXTreeList *self,FXTreeItem *other,FXTreeItem *father,FXTreeItem *item,FXbool notify=0){
+      if(item->isMemberOf(FXMETACLASS(FXRbTreeItem))){
+        dynamic_cast<FXRbTreeItem*>(item)->owned=1;
+        }
+      return self->insertItem(other,father,item,notify);
+      }
+SWIGINTERN FXTreeItem *FXTreeList_appendItem__SWIG_0(FXTreeList *self,FXTreeItem *father,FXTreeItem *item,FXbool notify=0){
+      if(item->isMemberOf(FXMETACLASS(FXRbTreeItem))){
+        dynamic_cast<FXRbTreeItem*>(item)->owned=1;
+        }
+      return self->appendItem(father,item,notify);
+      }
+SWIGINTERN FXTreeItem *FXTreeList_prependItem__SWIG_0(FXTreeList *self,FXTreeItem *father,FXTreeItem *item,FXbool notify=0){
+      if(item->isMemberOf(FXMETACLASS(FXRbTreeItem))){
+        dynamic_cast<FXRbTreeItem*>(item)->owned=1;
+        }
+      return self->prependItem(father,item,notify);
+      }
+SWIGINTERN void FXTreeList_removeItem(FXTreeList *self,FXTreeItem *item,FXbool notify=0){
+      // Save pointer(s) to the soon-to-be-destroyed items
+      FXObjectListOf<FXTreeItem> items;
+      FXRbTreeList::enumerateItem(item,items);
+
+      // Do the deed
+      self->removeItem(item,notify);
+
+      // Now zero-out pointers held by still-alive Ruby objects
+      for(FXint i=0;i<items.no();i++){
+        FXRbUnregisterRubyObj(items[i]);
+        }
+      }
+SWIGINTERN void FXTreeList_removeItems(FXTreeList *self,FXTreeItem *fm,FXTreeItem *to,FXbool notify=0){
+      // Save pointer(s) to the soon-to-be-destroyed items
+      FXObjectListOf<FXTreeItem> items;
+      FXRbTreeList::enumerateItems(fm,to,items);
+
+      // Do the deed
+      self->removeItems(fm,to,notify);
+
+      // Now zero-out pointers held by still-alive Ruby objects
+      for(FXint i=0;i<items.no();i++){
+        FXRbUnregisterRubyObj(items[i]);
+        }
+      }
+SWIGINTERN void FXTreeList_clearItems(FXTreeList *self,FXbool notify=0){
+      // Save pointer(s) to the soon-to-be-destroyed items
+      FXObjectListOf<FXTreeItem> items;
+      FXRbTreeList::enumerateItems(self->getFirstItem(),self->getLastItem(),items);
+
+      // Do the deed
+      self->clearItems(notify);
+
+      // Now zero-out pointers held by still-alive Ruby objects
+      for(FXint i=0;i<items.no();i++){
+        FXRbUnregisterRubyObj(items[i]);
+        }
+      }
+SWIGINTERN void FXTreeList_setItemData(FXTreeList *self,FXTreeItem *item,VALUE ptr){
+      self->setItemData(item,(void*) ptr);
+      }
+SWIGINTERN VALUE FXTreeList_getItemData(FXTreeList const *self,FXTreeItem const *item){
+      return self->getItemData(item) ? (VALUE) self->getItemData(item) : Qnil;
+      }
+SWIGINTERN VALUE FXTreeList_position__SWIG_1(FXTreeList const *self){
+    FXint x, y;
+    self->getPosition(x, y);
+    VALUE pos = rb_ary_new();
+    rb_ary_push(pos, INT2NUM(x));
+    rb_ary_push(pos, INT2NUM(y));
+    return pos;
+  }
+
+static swig_type_info *FXTreeList_dynamic_cast(void **ptr) {
+    FXTreeList **ppTreeList = reinterpret_cast<FXTreeList **>(ptr);
+    FXDirList *pDirList=dynamic_cast<FXDirList*>(*ppTreeList);
+    if(pDirList){
+      *ptr=reinterpret_cast<void*>(pDirList);
+      return SWIG_TypeQuery("FXDirList *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXDirItem *new_FXDirItem(FXString const &text,FXIcon *oi=0,FXIcon *ci=0,void *ITEMDATA=0){
+      return new FXRbDirItem(text,oi,ci,ITEMDATA);
+      }
+SWIGINTERN FXDirList *new_FXDirList(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbDirList(p,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN VALUE FXDirList_position__SWIG_1(FXDirList const *self){
+    FXint x, y;
+    self->getPosition(x, y);
+    VALUE pos = rb_ary_new();
+    rb_ary_push(pos, INT2NUM(x));
+    rb_ary_push(pos, INT2NUM(y));
+    return pos;
+  }
+static swig_class SwigClassFXFoldingItem;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXFoldingItem_allocate(VALUE self)
+#else
+_wrap_FXFoldingItem_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXFoldingItem);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXFoldingItem(int argc, VALUE *argv, VALUE self) {
+  FXString *arg1 = 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  void *arg4 = (void *) 0 ;
+  SwigValueWrapper< FXString > p1 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXFoldingItem *result = 0 ;
+  
+  if ((argc < 1) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  p1 = to_FXString(argv[0]); arg1 = &p1;
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","FXFoldingItem", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXIcon * >(argp2);
+  }
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","FXFoldingItem", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = (argv[3] == Qnil) ? NULL : (void *) argv[3];
+  }
+  {
+    result = (FXFoldingItem *)new_FXFoldingItem((FXString const &)*arg1,arg2,arg3,arg4);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_getParent(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFoldingItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","getParent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  result = (FXFoldingItem *)((FXFoldingItem const *)arg1)->getParent();
+  vresult = FXRbGetRubyObj(result, "FXFoldingItem *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_getNext(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFoldingItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","getNext", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  result = (FXFoldingItem *)((FXFoldingItem const *)arg1)->getNext();
+  vresult = FXRbGetRubyObj(result, "FXFoldingItem *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_getPrev(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFoldingItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","getPrev", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  result = (FXFoldingItem *)((FXFoldingItem const *)arg1)->getPrev();
+  vresult = FXRbGetRubyObj(result, "FXFoldingItem *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_getFirst(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFoldingItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","getFirst", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  result = (FXFoldingItem *)((FXFoldingItem const *)arg1)->getFirst();
+  vresult = FXRbGetRubyObj(result, "FXFoldingItem *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_getLast(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFoldingItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","getLast", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  result = (FXFoldingItem *)((FXFoldingItem const *)arg1)->getLast();
+  vresult = FXRbGetRubyObj(result, "FXFoldingItem *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_getBelow(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFoldingItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","getBelow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  result = (FXFoldingItem *)((FXFoldingItem const *)arg1)->getBelow();
+  vresult = FXRbGetRubyObj(result, "FXFoldingItem *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_getAbove(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFoldingItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","getAbove", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  result = (FXFoldingItem *)((FXFoldingItem const *)arg1)->getAbove();
+  vresult = FXRbGetRubyObj(result, "FXFoldingItem *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_getNumChildren(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","getNumChildren", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  result = (FXint)((FXFoldingItem const *)arg1)->getNumChildren();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_getText(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","getText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  result = (FXString *) &((FXFoldingItem const *)arg1)->getText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_getOpenIcon(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","getOpenIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  result = (FXIcon *)((FXFoldingItem const *)arg1)->getOpenIcon();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_getClosedIcon(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","getClosedIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  result = (FXIcon *)((FXFoldingItem const *)arg1)->getClosedIcon();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_setData(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem *","setData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  arg2 = argv[0];
+  FXFoldingItem_setData(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_getData(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","getData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  result = (VALUE)FXFoldingItem_getData((FXFoldingItem const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_hasFocus(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","hasFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  result = (FXbool)((FXFoldingItem const *)arg1)->hasFocus();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_isSelected(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","isSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  result = (FXbool)((FXFoldingItem const *)arg1)->isSelected();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_isOpened(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","isOpened", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  result = (FXbool)((FXFoldingItem const *)arg1)->isOpened();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_isExpanded(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","isExpanded", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  result = (FXbool)((FXFoldingItem const *)arg1)->isExpanded();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_isEnabled(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","isEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  result = (FXbool)((FXFoldingItem const *)arg1)->isEnabled();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_isDraggable(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","isDraggable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  result = (FXbool)((FXFoldingItem const *)arg1)->isDraggable();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_hasItemsq___(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","hasItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  result = (FXbool)((FXFoldingItem const *)arg1)->hasItems();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_hasItemse___(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem *","setHasItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->setHasItems(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_isChildOf(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","isChildOf", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem const *","isChildOf", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  result = (FXbool)((FXFoldingItem const *)arg1)->isChildOf((FXFoldingItem const *)arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_isParentOf(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","isParentOf", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem const *","isParentOf", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  result = (FXbool)((FXFoldingItem const *)arg1)->isParentOf((FXFoldingItem const *)arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_save(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXFoldingItem_save((FXFoldingItem const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_load(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXFoldingItem_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_setText(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem *","setText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  FXFoldingItem_setText(arg1,(FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_setOpenIcon(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem *","setOpenIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setOpenIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXFoldingItem_setOpenIcon(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_setClosedIcon(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem *","setClosedIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setClosedIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXFoldingItem_setClosedIcon(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXFoldingItem_setFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_setSelected(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem *","setSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXFoldingItem_setSelected(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_setOpened(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem *","setOpened", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXFoldingItem_setOpened(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_setExpanded(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem *","setExpanded", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXFoldingItem_setExpanded(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_setEnabled(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem *","setEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXFoldingItem_setEnabled(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_setDraggable(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem *","setDraggable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXFoldingItem_setDraggable(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_getWidth(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  FXFoldingList *arg2 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","getWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingList const *","getWidth", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingList * >(argp2);
+  result = (FXint)FXFoldingItem_getWidth((FXFoldingItem const *)arg1,(FXFoldingList const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_getHeight(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  FXFoldingList *arg2 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","getHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingList const *","getHeight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingList * >(argp2);
+  result = (FXint)FXFoldingItem_getHeight((FXFoldingItem const *)arg1,(FXFoldingList const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_create(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  FXFoldingItem_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_detach(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  FXFoldingItem_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingItem_destroy(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  FXFoldingItem_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXFoldingList;
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onPaint", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_onEnter(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","onEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onEnter", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_onLeave(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","onLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onLeave", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onUngrabbed", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onMotion", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onKeyPress", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onKeyRelease", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onLeftBtnPress", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onLeftBtnRelease", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_onRightBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","onRightBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onRightBtnPress", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onRightBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_onRightBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","onRightBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onRightBtnRelease", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onRightBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_onHeaderChanged(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","onHeaderChanged", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onHeaderChanged", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onHeaderChanged", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onHeaderChanged(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onQueryTip", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onQueryHelp", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_onTipTimer(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","onTipTimer", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTipTimer", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onTipTimer", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onTipTimer(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_onFocusIn(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","onFocusIn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusIn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onFocusIn", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onFocusIn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_onFocusOut(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","onFocusOut", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusOut", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onFocusOut", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onFocusOut(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_onAutoScroll(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","onAutoScroll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onAutoScroll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onAutoScroll", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onAutoScroll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_onClicked(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","onClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onClicked", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_onDoubleClicked(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","onDoubleClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDoubleClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onDoubleClicked", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onDoubleClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_onTripleClicked(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","onTripleClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTripleClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onTripleClicked", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onTripleClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_onCommand(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","onCommand", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCommand", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCommand", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCommand(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_onLookupTimer(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","onLookupTimer", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLookupTimer", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onLookupTimer", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onLookupTimer(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_ascending(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","FXFoldingList::ascending", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem const *","FXFoldingList::ascending", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  result = (FXint)FXFoldingList::ascending((FXFoldingItem const *)arg1,(FXFoldingItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_descending(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","FXFoldingList::descending", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem const *","FXFoldingList::descending", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  result = (FXint)FXFoldingList::descending((FXFoldingItem const *)arg1,(FXFoldingItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_ascendingCase(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","FXFoldingList::ascendingCase", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem const *","FXFoldingList::ascendingCase", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  result = (FXint)FXFoldingList::ascendingCase((FXFoldingItem const *)arg1,(FXFoldingItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_descendingCase(int argc, VALUE *argv, VALUE self) {
+  FXFoldingItem *arg1 = (FXFoldingItem *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingItem const *","FXFoldingList::descendingCase", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem const *","FXFoldingList::descendingCase", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  result = (FXint)FXFoldingList::descendingCase((FXFoldingItem const *)arg1,(FXFoldingItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXFoldingList_allocate(VALUE self)
+#else
+_wrap_FXFoldingList_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXFoldingList);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXFoldingList(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) FOLDINGLIST_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXFoldingList *result = 0 ;
+  
+  if ((argc < 1) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXFoldingList", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXFoldingList", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXFoldingList *)new_FXFoldingList(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getHeader(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXHeader *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getHeader", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (FXHeader *)((FXFoldingList const *)arg1)->getHeader();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXHeader, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setHeaders(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  FXint arg3 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setHeaders", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = argv[0];
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  FXFoldingList_setHeaders(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_appendHeader(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXint arg4 = (FXint) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","appendHeader", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","appendHeader", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 2) {
+    arg4 = NUM2INT(argv[2]);
+  }
+  (arg1)->appendHeader((FXString const &)*arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_removeHeader(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","removeHeader", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->removeHeader(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setHeaderText(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setHeaderText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  (arg1)->setHeaderText(arg2,(FXString const &)*arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getHeaderText(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getHeaderText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = ((FXFoldingList const *)arg1)->getHeaderText(arg2);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setHeaderIcon(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXint arg2 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setHeaderIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","setHeaderIcon", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXIcon * >(argp3);
+  (arg1)->setHeaderIcon(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getHeaderIcon(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getHeaderIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXIcon *)((FXFoldingList const *)arg1)->getHeaderIcon(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setHeaderSize(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setHeaderSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  (arg1)->setHeaderSize(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getHeaderSize(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getHeaderSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)((FXFoldingList const *)arg1)->getHeaderSize(arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getNumHeaders(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getNumHeaders", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (FXint)((FXFoldingList const *)arg1)->getNumHeaders();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getNumItems(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getNumItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (FXint)((FXFoldingList const *)arg1)->getNumItems();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getNumVisible(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getNumVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (FXint)((FXFoldingList const *)arg1)->getNumVisible();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setNumVisible(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setNumVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setNumVisible(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getFirstItem(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFoldingItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getFirstItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (FXFoldingItem *)((FXFoldingList const *)arg1)->getFirstItem();
+  vresult = FXRbGetRubyObj(result, "FXFoldingItem *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getLastItem(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFoldingItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getLastItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (FXFoldingItem *)((FXFoldingList const *)arg1)->getLastItem();
+  vresult = FXRbGetRubyObj(result, "FXFoldingItem *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_fillItems(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXchar **arg3 = (FXchar **) 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  void *arg6 = (void *) 0 ;
+  FXbool arg7 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","fillItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","fillItems", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  {
+    arg3 = NULL;
+    if(!NIL_P(argv[1])){
+      Check_Type(argv[1], T_ARRAY);
+      if (FXMALLOC(&arg3, FXchar *, RARRAY_LEN(argv[1])+1)) {
+        for (long i = 0; i < RARRAY_LEN(argv[1]); i++) {
+          VALUE e = rb_ary_entry(argv[1], i);
+          arg3[i] = (FXchar *) StringValuePtr(e);
+        }
+        arg3[RARRAY_LEN(argv[1])] = 0;
+      }
+    }
+  }
+  if (argc > 2) {
+    res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","fillItems", 4, argv[2] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 3) {
+    res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","fillItems", 5, argv[3] )); 
+    }
+    arg5 = reinterpret_cast< FXIcon * >(argp5);
+  }
+  if (argc > 4) {
+    arg6 = (argv[4] == Qnil) ? NULL : (void *) argv[4];
+  }
+  if (argc > 5) {
+    arg7 = to_FXbool(argv[5]);
+  }
+  result = (FXint)FXFoldingList_fillItems(arg1,arg2,(char const **)arg3,arg4,arg5,arg6,arg7);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  FXFREE(&arg3);
+  return vresult;
+fail:
+  FXFREE(&arg3);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_insertItem__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXFoldingItem *arg3 = (FXFoldingItem *) 0 ;
+  FXFoldingItem *arg4 = (FXFoldingItem *) 0 ;
+  FXbool arg5 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXFoldingItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","insertItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","insertItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXFoldingItem *","insertItem", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXFoldingItem * >(argp3);
+  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXFoldingItem *","insertItem", 4, argv[2] )); 
+  }
+  arg4 = reinterpret_cast< FXFoldingItem * >(argp4);
+  if (argc > 3) {
+    arg5 = to_FXbool(argv[3]);
+  }
+  result = (FXFoldingItem *)FXFoldingList_insertItem__SWIG_0(arg1,arg2,arg3,arg4,arg5);
+  vresult = FXRbGetRubyObj(result, "FXFoldingItem *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_insertItem__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXFoldingItem *arg3 = (FXFoldingItem *) 0 ;
+  FXString *arg4 = 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  FXIcon *arg6 = (FXIcon *) 0 ;
+  void *arg7 = (void *) 0 ;
+  FXbool arg8 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  SwigValueWrapper< FXString > p4 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  void *argp6 = 0 ;
+  int res6 = 0 ;
+  FXFoldingItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 7)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","insertItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","insertItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXFoldingItem *","insertItem", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXFoldingItem * >(argp3);
+  p4 = to_FXString(argv[2]); arg4 = &p4;
+  if (argc > 3) {
+    res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","insertItem", 5, argv[3] )); 
+    }
+    arg5 = reinterpret_cast< FXIcon * >(argp5);
+  }
+  if (argc > 4) {
+    res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res6)) {
+      SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "FXIcon *","insertItem", 6, argv[4] )); 
+    }
+    arg6 = reinterpret_cast< FXIcon * >(argp6);
+  }
+  if (argc > 5) {
+    arg7 = (argv[5] == Qnil) ? NULL : (void *) argv[5];
+  }
+  if (argc > 6) {
+    arg8 = to_FXbool(argv[6]);
+  }
+  result = (FXFoldingItem *)(arg1)->insertItem(arg2,arg3,(FXString const &)*arg4,arg5,arg6,arg7,arg8);
+  vresult = FXRbGetRubyObj(result, "FXFoldingItem *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXFoldingList_insertItem(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[9];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 9) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 4) && (argc <= 5)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFoldingList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXFoldingItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXFoldingItem, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXFoldingItem, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXFoldingList_insertItem__SWIG_0(nargs, args, self);
+            }
+            {
+              _v = (argv[4] == Qtrue || argv[4] == Qfalse) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXFoldingList_insertItem__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 4) && (argc <= 8)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFoldingList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXFoldingItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXFoldingItem, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          {
+            _v = (NIL_P(argv[3]) || TYPE(argv[3]) == T_STRING) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXFoldingList_insertItem__SWIG_1(nargs, args, self);
+            }
+            void *vptr = 0;
+            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_FXIcon, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_FXFoldingList_insertItem__SWIG_1(nargs, args, self);
+              }
+              void *vptr = 0;
+              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_FXIcon, 0);
+              _v = SWIG_CheckState(res);
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_FXFoldingList_insertItem__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = 1;
+                }
+                if (_v) {
+                  if (argc <= 7) {
+                    return _wrap_FXFoldingList_insertItem__SWIG_1(nargs, args, self);
+                  }
+                  {
+                    _v = (argv[7] == Qtrue || argv[7] == Qfalse) ? 1 : 0;
+                  }
+                  if (_v) {
+                    return _wrap_FXFoldingList_insertItem__SWIG_1(nargs, args, self);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 9, "insertItem", 
+    "    FXFoldingItem insertItem(FXFoldingItem *other, FXFoldingItem *father, FXFoldingItem *item, FXbool notify)\n"
+    "    FXFoldingItem * insertItem(FXFoldingItem *other, FXFoldingItem *father, FXString const &text, FXIcon *oi, FXIcon *ci, void *ITEMDATA, FXbool notify)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_appendItem__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXFoldingItem *arg3 = (FXFoldingItem *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXFoldingItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","appendItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","appendItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXFoldingItem *","appendItem", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXFoldingItem * >(argp3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  result = (FXFoldingItem *)FXFoldingList_appendItem__SWIG_0(arg1,arg2,arg3,arg4);
+  vresult = FXRbGetRubyObj(result, "FXFoldingItem *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_appendItem__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXString *arg3 = 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  void *arg6 = (void *) 0 ;
+  FXbool arg7 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  FXFoldingItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","appendItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","appendItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  if (argc > 2) {
+    res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","appendItem", 4, argv[2] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 3) {
+    res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","appendItem", 5, argv[3] )); 
+    }
+    arg5 = reinterpret_cast< FXIcon * >(argp5);
+  }
+  if (argc > 4) {
+    arg6 = (argv[4] == Qnil) ? NULL : (void *) argv[4];
+  }
+  if (argc > 5) {
+    arg7 = to_FXbool(argv[5]);
+  }
+  result = (FXFoldingItem *)(arg1)->appendItem(arg2,(FXString const &)*arg3,arg4,arg5,arg6,arg7);
+  vresult = FXRbGetRubyObj(result, "FXFoldingItem *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXFoldingList_appendItem(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[8];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 8) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 3) && (argc <= 4)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFoldingList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXFoldingItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXFoldingItem, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXFoldingList_appendItem__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (argv[3] == Qtrue || argv[3] == Qfalse) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_FXFoldingList_appendItem__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 3) && (argc <= 7)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFoldingList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXFoldingItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXFoldingList_appendItem__SWIG_1(nargs, args, self);
+          }
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXFoldingList_appendItem__SWIG_1(nargs, args, self);
+            }
+            void *vptr = 0;
+            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_FXIcon, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_FXFoldingList_appendItem__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = 1;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_FXFoldingList_appendItem__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (argv[6] == Qtrue || argv[6] == Qfalse) ? 1 : 0;
+                }
+                if (_v) {
+                  return _wrap_FXFoldingList_appendItem__SWIG_1(nargs, args, self);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 8, "appendItem", 
+    "    FXFoldingItem appendItem(FXFoldingItem *father, FXFoldingItem *item, FXbool notify)\n"
+    "    FXFoldingItem * appendItem(FXFoldingItem *father, FXString const &text, FXIcon *oi, FXIcon *ci, void *ITEMDATA, FXbool notify)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_prependItem__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXFoldingItem *arg3 = (FXFoldingItem *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXFoldingItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","prependItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","prependItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXFoldingItem *","prependItem", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXFoldingItem * >(argp3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  result = (FXFoldingItem *)FXFoldingList_prependItem__SWIG_0(arg1,arg2,arg3,arg4);
+  vresult = FXRbGetRubyObj(result, "FXFoldingItem *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_prependItem__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXString *arg3 = 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  void *arg6 = (void *) 0 ;
+  FXbool arg7 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  FXFoldingItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","prependItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","prependItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  if (argc > 2) {
+    res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","prependItem", 4, argv[2] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 3) {
+    res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","prependItem", 5, argv[3] )); 
+    }
+    arg5 = reinterpret_cast< FXIcon * >(argp5);
+  }
+  if (argc > 4) {
+    arg6 = (argv[4] == Qnil) ? NULL : (void *) argv[4];
+  }
+  if (argc > 5) {
+    arg7 = to_FXbool(argv[5]);
+  }
+  result = (FXFoldingItem *)(arg1)->prependItem(arg2,(FXString const &)*arg3,arg4,arg5,arg6,arg7);
+  vresult = FXRbGetRubyObj(result, "FXFoldingItem *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXFoldingList_prependItem(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[8];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 8) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 3) && (argc <= 4)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFoldingList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXFoldingItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXFoldingItem, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXFoldingList_prependItem__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (argv[3] == Qtrue || argv[3] == Qfalse) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_FXFoldingList_prependItem__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 3) && (argc <= 7)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFoldingList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXFoldingItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXFoldingList_prependItem__SWIG_1(nargs, args, self);
+          }
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXFoldingList_prependItem__SWIG_1(nargs, args, self);
+            }
+            void *vptr = 0;
+            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_FXIcon, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_FXFoldingList_prependItem__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = 1;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_FXFoldingList_prependItem__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (argv[6] == Qtrue || argv[6] == Qfalse) ? 1 : 0;
+                }
+                if (_v) {
+                  return _wrap_FXFoldingList_prependItem__SWIG_1(nargs, args, self);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 8, "prependItem", 
+    "    FXFoldingItem prependItem(FXFoldingItem *father, FXFoldingItem *item, FXbool notify)\n"
+    "    FXFoldingItem * prependItem(FXFoldingItem *father, FXString const &text, FXIcon *oi, FXIcon *ci, void *ITEMDATA, FXbool notify)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_moveItem(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXFoldingItem *arg3 = (FXFoldingItem *) 0 ;
+  FXFoldingItem *arg4 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXFoldingItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","moveItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","moveItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXFoldingItem *","moveItem", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXFoldingItem * >(argp3);
+  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXFoldingItem *","moveItem", 4, argv[2] )); 
+  }
+  arg4 = reinterpret_cast< FXFoldingItem * >(argp4);
+  result = (FXFoldingItem *)(arg1)->moveItem(arg2,arg3,arg4);
+  vresult = FXRbGetRubyObj(result, "FXFoldingItem *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_extractItem(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXFoldingItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","extractItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","extractItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXFoldingItem *)(arg1)->extractItem(arg2,arg3);
+  vresult = FXRbGetRubyObj(result, "FXFoldingItem *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_removeItem(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","removeItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","removeItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXFoldingList_removeItem(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_removeItems(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXFoldingItem *arg3 = (FXFoldingItem *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","removeItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","removeItems", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXFoldingItem *","removeItems", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXFoldingItem * >(argp3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  FXFoldingList_removeItems(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_clearItems(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","clearItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXFoldingList_clearItems(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getItemWidth(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getItemWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem const *","getItemWidth", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  result = (FXint)((FXFoldingList const *)arg1)->getItemWidth((FXFoldingItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getItemHeight(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getItemHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem const *","getItemHeight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  result = (FXint)((FXFoldingList const *)arg1)->getItemHeight((FXFoldingItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_findItem(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXString *arg2 = 0 ;
+  FXFoldingItem *arg3 = (FXFoldingItem *) 0 ;
+  FXuint arg4 = (FXuint) SEARCH_FORWARD|SEARCH_WRAP ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXFoldingItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","findItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXFoldingItem *","findItem", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXFoldingItem * >(argp3);
+  }
+  if (argc > 2) {
+    arg4 = NUM2UINT(argv[2]);
+  }
+  result = (FXFoldingItem *)((FXFoldingList const *)arg1)->findItem((FXString const &)*arg2,arg3,arg4);
+  vresult = FXRbGetRubyObj(result, "FXFoldingItem *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_findItemByData(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXFoldingItem *arg3 = (FXFoldingItem *) 0 ;
+  FXuint arg4 = (FXuint) SEARCH_FORWARD|SEARCH_WRAP ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXFoldingItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","findItemByData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = (argv[0] == Qnil) ? NULL : (void *) argv[0];
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXFoldingItem *","findItemByData", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXFoldingItem * >(argp3);
+  }
+  if (argc > 2) {
+    arg4 = NUM2UINT(argv[2]);
+  }
+  result = (FXFoldingItem *)((FXFoldingList const *)arg1)->findItemByData((void const *)arg2,arg3,arg4);
+  vresult = FXRbGetRubyObj(result, "FXFoldingItem *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setItemText(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXString *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setItemText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","setItemText", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  (arg1)->setItemText(arg2,(FXString const &)*arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getItemText(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getItemText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem const *","getItemText", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  result = ((FXFoldingList const *)arg1)->getItemText((FXFoldingItem const *)arg2);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setItemOpenIcon(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setItemOpenIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","setItemOpenIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","setItemOpenIcon", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXIcon * >(argp3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  (arg1)->setItemOpenIcon(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getItemOpenIcon(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getItemOpenIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem const *","getItemOpenIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  result = (FXIcon *)((FXFoldingList const *)arg1)->getItemOpenIcon((FXFoldingItem const *)arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setItemClosedIcon(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setItemClosedIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","setItemClosedIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","setItemClosedIcon", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXIcon * >(argp3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  (arg1)->setItemClosedIcon(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getItemClosedIcon(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getItemClosedIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem const *","getItemClosedIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  result = (FXIcon *)((FXFoldingList const *)arg1)->getItemClosedIcon((FXFoldingItem const *)arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setItemData(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  VALUE arg3 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setItemData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","setItemData", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  arg3 = argv[1];
+  FXFoldingList_setItemData(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getItemData(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getItemData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem const *","getItemData", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  result = (VALUE)FXFoldingList_getItemData((FXFoldingList const *)arg1,(FXFoldingItem const *)arg2);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_isItemSelected(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","isItemSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem const *","isItemSelected", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  result = (FXbool)((FXFoldingList const *)arg1)->isItemSelected((FXFoldingItem const *)arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_isItemCurrent(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","isItemCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem const *","isItemCurrent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  result = (FXbool)((FXFoldingList const *)arg1)->isItemCurrent((FXFoldingItem const *)arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_isItemVisible(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","isItemVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem const *","isItemVisible", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  result = (FXbool)((FXFoldingList const *)arg1)->isItemVisible((FXFoldingItem const *)arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_isItemOpened(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","isItemOpened", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem const *","isItemOpened", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  result = (FXbool)((FXFoldingList const *)arg1)->isItemOpened((FXFoldingItem const *)arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_isItemExpanded(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","isItemExpanded", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem const *","isItemExpanded", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  result = (FXbool)((FXFoldingList const *)arg1)->isItemExpanded((FXFoldingItem const *)arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_isItemLeaf(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","isItemLeaf", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem const *","isItemLeaf", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  result = (FXbool)((FXFoldingList const *)arg1)->isItemLeaf((FXFoldingItem const *)arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_isItemEnabled(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","isItemEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem const *","isItemEnabled", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  result = (FXbool)((FXFoldingList const *)arg1)->isItemEnabled((FXFoldingItem const *)arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_hitItem(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","hitItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem const *","hitItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  result = (FXint)((FXFoldingList const *)arg1)->hitItem((FXFoldingItem const *)arg2,arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_updateItem(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","updateItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","updateItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  (arg1)->updateItem(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getCurrentItem(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFoldingItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getCurrentItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (FXFoldingItem *)((FXFoldingList const *)arg1)->getCurrentItem();
+  vresult = FXRbGetRubyObj(result, "FXFoldingItem *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setAnchorItem(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setAnchorItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","setAnchorItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  (arg1)->setAnchorItem(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getAnchorItem(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFoldingItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getAnchorItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (FXFoldingItem *)((FXFoldingList const *)arg1)->getAnchorItem();
+  vresult = FXRbGetRubyObj(result, "FXFoldingItem *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getCursorItem(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFoldingItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getCursorItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (FXFoldingItem *)((FXFoldingList const *)arg1)->getCursorItem();
+  vresult = FXRbGetRubyObj(result, "FXFoldingItem *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_sortItems(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","sortItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  (arg1)->sortItems();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_sortRootItems(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","sortRootItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  (arg1)->sortRootItems();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_sortChildItems(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","sortChildItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","sortChildItems", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  (arg1)->sortChildItems(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getSortFunc(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFoldingListSortFunc result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getSortFunc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = ((FXFoldingList const *)arg1)->getSortFunc();
+  vresult = SWIG_NewPointerObj((new FXFoldingListSortFunc(static_cast< const FXFoldingListSortFunc& >(result))), SWIGTYPE_p_FXFoldingListSortFunc, SWIG_POINTER_OWN |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setSortFunc(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingListSortFunc arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setSortFunc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXFoldingListSortFunc,  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingListSortFunc","setSortFunc", 2, argv[0] )); 
+    }  
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXFoldingListSortFunc","setSortFunc", 2, argv[0]));
+    } else {
+      arg2 = *(reinterpret_cast< FXFoldingListSortFunc * >(argp2));
+    }
+  }
+  (arg1)->setSortFunc(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setFont(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  (arg1)->setFont(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getFont(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (FXFont *)((FXFoldingList const *)arg1)->getFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setIndent(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setIndent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setIndent(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getIndent(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getIndent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (FXint)((FXFoldingList const *)arg1)->getIndent();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getTextColor(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (FXColor)((FXFoldingList const *)arg1)->getTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setTextColor(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (FXColor)((FXFoldingList const *)arg1)->getSelBackColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelBackColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (FXColor)((FXFoldingList const *)arg1)->getSelTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getLineColor(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getLineColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (FXColor)((FXFoldingList const *)arg1)->getLineColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setLineColor(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setLineColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setLineColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getListStyle(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getListStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (FXuint)((FXFoldingList const *)arg1)->getListStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setListStyle(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setListStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setListStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (FXString *) &((FXFoldingList const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_save(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXFoldingList_save((FXFoldingList const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_load(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXFoldingList_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_create(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  FXFoldingList_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_detach(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  FXFoldingList_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_destroy(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  FXFoldingList_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_resize(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXFoldingList_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (FXint)FXFoldingList_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (FXint)FXFoldingList_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXFoldingList_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXFoldingList_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (bool)FXFoldingList_canFocus((FXFoldingList const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  FXFoldingList_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  FXFoldingList_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXFoldingList_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXFoldingList_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_enable(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  FXFoldingList_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_disable(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  FXFoldingList_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  FXFoldingList_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_lower(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  FXFoldingList_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_move(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXFoldingList_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXFoldingList_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_layout(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  FXFoldingList_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_recalc(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  FXFoldingList_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_reparent(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXFoldingList_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_show(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  FXFoldingList_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_hide(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  FXFoldingList_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (bool)FXFoldingList_isComposite((FXFoldingList const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_contains(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXFoldingList_contains((FXFoldingList const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (bool)FXFoldingList_doesSaveUnder((FXFoldingList const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXFoldingList_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_tr(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXFoldingList_tr((FXFoldingList const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  FXFoldingList_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  FXFoldingList_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXFoldingList_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXFoldingList_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXFoldingList_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXFoldingList_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFoldingList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXFoldingList_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFoldingList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXFoldingList_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFoldingList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXFoldingList_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  FXFoldingList_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getViewportHeight(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","getViewportHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (FXint)FXFoldingList_getViewportHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getViewportWidth(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","getViewportWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (FXint)FXFoldingList_getViewportWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getContentHeight(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","getContentHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (FXint)FXFoldingList_getContentHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getContentWidth(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","getContentWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (FXint)FXFoldingList_getContentWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  result = (VALUE)FXFoldingList_position__SWIG_1((FXFoldingList const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXFoldingList_position(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFoldingList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXFoldingList_position__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFoldingList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXFoldingList_position__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "position", 
+    "    void position(FXint x, FXint y, FXint w, FXint h)\n"
+    "    VALUE position()\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_getItemAt(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFoldingItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList const *","getItemAt", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXFoldingItem *)FXFoldingList_getItemAt((FXFoldingList const *)arg1,arg2,arg3);
+  vresult = FXRbGetRubyObj(result, "FXFoldingItem *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_makeItemVisible(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","makeItemVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","makeItemVisible", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  FXFoldingList_makeItemVisible(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_enableItem(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","enableItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","enableItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  result = (FXbool)FXFoldingList_enableItem(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_disableItem(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","disableItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","disableItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  result = (FXbool)FXFoldingList_disableItem(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_selectItem(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","selectItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","selectItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXFoldingList_selectItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_deselectItem(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","deselectItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","deselectItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXFoldingList_deselectItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_toggleItem(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","toggleItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","toggleItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXFoldingList_toggleItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_extendSelection(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","extendSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","extendSelection", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXFoldingList_extendSelection(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_killSelection(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","killSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXFoldingList_killSelection(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_openItem(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","openItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","openItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXFoldingList_openItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_closeItem(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","closeItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","closeItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXFoldingList_closeItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_collapseTree(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","collapseTree", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","collapseTree", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXFoldingList_collapseTree(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_expandTree(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","expandTree", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","expandTree", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXFoldingList_expandTree(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFoldingList_setCurrentItem(int argc, VALUE *argv, VALUE self) {
+  FXFoldingList *arg1 = (FXFoldingList *) 0 ;
+  FXFoldingItem *arg2 = (FXFoldingItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFoldingList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFoldingList *","setCurrentItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFoldingList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFoldingItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFoldingItem *","setCurrentItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFoldingItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXFoldingList_setCurrentItem(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXTreeItem;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXTreeItem_allocate(VALUE self)
+#else
+_wrap_FXTreeItem_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXTreeItem);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXTreeItem(int argc, VALUE *argv, VALUE self) {
+  FXString *arg1 = 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  void *arg4 = (void *) 0 ;
+  SwigValueWrapper< FXString > p1 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXTreeItem *result = 0 ;
+  
+  if ((argc < 1) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  p1 = to_FXString(argv[0]); arg1 = &p1;
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","FXTreeItem", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXIcon * >(argp2);
+  }
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","FXTreeItem", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = (argv[3] == Qnil) ? NULL : (void *) argv[3];
+  }
+  {
+    result = (FXTreeItem *)new_FXTreeItem((FXString const &)*arg1,arg2,arg3,arg4);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_getText(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","getText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  result = (FXString *) &((FXTreeItem const *)arg1)->getText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_getOpenIcon(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","getOpenIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  result = (FXIcon *)((FXTreeItem const *)arg1)->getOpenIcon();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_getClosedIcon(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","getClosedIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  result = (FXIcon *)((FXTreeItem const *)arg1)->getClosedIcon();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_getParent(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","getParent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  result = (FXTreeItem *)((FXTreeItem const *)arg1)->getParent();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_getNext(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","getNext", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  result = (FXTreeItem *)((FXTreeItem const *)arg1)->getNext();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_getPrev(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","getPrev", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  result = (FXTreeItem *)((FXTreeItem const *)arg1)->getPrev();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_getFirst(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","getFirst", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  result = (FXTreeItem *)((FXTreeItem const *)arg1)->getFirst();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_getLast(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","getLast", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  result = (FXTreeItem *)((FXTreeItem const *)arg1)->getLast();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_getBelow(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","getBelow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  result = (FXTreeItem *)((FXTreeItem const *)arg1)->getBelow();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_getAbove(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","getAbove", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  result = (FXTreeItem *)((FXTreeItem const *)arg1)->getAbove();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_getNumChildren(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","getNumChildren", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  result = (FXint)((FXTreeItem const *)arg1)->getNumChildren();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_setData(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem *","setData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  arg2 = argv[0];
+  FXTreeItem_setData(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_getData(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","getData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  result = (VALUE)FXTreeItem_getData((FXTreeItem const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_hasFocus(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","hasFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  result = (FXbool)((FXTreeItem const *)arg1)->hasFocus();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_isSelected(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","isSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  result = (FXbool)((FXTreeItem const *)arg1)->isSelected();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_isOpened(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","isOpened", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  result = (FXbool)((FXTreeItem const *)arg1)->isOpened();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_isExpanded(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","isExpanded", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  result = (FXbool)((FXTreeItem const *)arg1)->isExpanded();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_isEnabled(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","isEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  result = (FXbool)((FXTreeItem const *)arg1)->isEnabled();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_isDraggable(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","isDraggable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  result = (FXbool)((FXTreeItem const *)arg1)->isDraggable();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_hasItemsq___(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","hasItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  result = (FXbool)((FXTreeItem const *)arg1)->hasItems();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_hasItemse___(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem *","setHasItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->setHasItems(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_isChildOf(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","isChildOf", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","isChildOf", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXbool)((FXTreeItem const *)arg1)->isChildOf((FXTreeItem const *)arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_isParentOf(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","isParentOf", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","isParentOf", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXbool)((FXTreeItem const *)arg1)->isParentOf((FXTreeItem const *)arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_save(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTreeItem_save((FXTreeItem const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_load(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTreeItem_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_setText(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem *","setText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  FXTreeItem_setText(arg1,(FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_setOpenIcon(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem *","setOpenIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setOpenIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXTreeItem_setOpenIcon(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_setClosedIcon(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem *","setClosedIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setClosedIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXTreeItem_setClosedIcon(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXTreeItem_setFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_setSelected(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem *","setSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXTreeItem_setSelected(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_setOpened(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem *","setOpened", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXTreeItem_setOpened(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_setExpanded(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem *","setExpanded", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXTreeItem_setExpanded(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_setEnabled(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem *","setEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXTreeItem_setEnabled(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_setDraggable(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem *","setDraggable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXTreeItem_setDraggable(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_getWidth(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXTreeList *arg2 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","getWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeList const *","getWidth", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeList * >(argp2);
+  result = (FXint)FXTreeItem_getWidth((FXTreeItem const *)arg1,(FXTreeList const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_getHeight(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXTreeList *arg2 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","getHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeList const *","getHeight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeList * >(argp2);
+  result = (FXint)FXTreeItem_getHeight((FXTreeItem const *)arg1,(FXTreeList const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_create(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  FXTreeItem_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_detach(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  FXTreeItem_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeItem_destroy(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  FXTreeItem_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXTreeList;
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_onEnter(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","onEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_onLeave(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","onLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_onRightBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","onRightBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onRightBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_onRightBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","onRightBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onRightBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_onTipTimer(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","onTipTimer", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTipTimer", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onTipTimer(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_onFocusIn(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","onFocusIn", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusIn", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusIn(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_onFocusOut(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","onFocusOut", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusOut", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusOut(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_onAutoScroll(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","onAutoScroll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onAutoScroll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onAutoScroll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_onClicked(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","onClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  SWIG_ConvertPtr(argv[2],&arg4,SWIGTYPE_p_FXTreeItem,1);
+  result = (long)(arg1)->onClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_onDoubleClicked(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","onDoubleClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDoubleClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  SWIG_ConvertPtr(argv[2],&arg4,SWIGTYPE_p_FXTreeItem,1);
+  result = (long)(arg1)->onDoubleClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_onTripleClicked(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","onTripleClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTripleClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  SWIG_ConvertPtr(argv[2],&arg4,SWIGTYPE_p_FXTreeItem,1);
+  result = (long)(arg1)->onTripleClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_onCommand(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","onCommand", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCommand", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  SWIG_ConvertPtr(argv[2],&arg4,SWIGTYPE_p_FXTreeItem,1);
+  result = (long)(arg1)->onCommand(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_onLookupTimer(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","onLookupTimer", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLookupTimer", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onLookupTimer(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_ascending(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","FXTreeList::ascending", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","FXTreeList::ascending", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXint)FXTreeList::ascending((FXTreeItem const *)arg1,(FXTreeItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_descending(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","FXTreeList::descending", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","FXTreeList::descending", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXint)FXTreeList::descending((FXTreeItem const *)arg1,(FXTreeItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_ascendingCase(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","FXTreeList::ascendingCase", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","FXTreeList::ascendingCase", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXint)FXTreeList::ascendingCase((FXTreeItem const *)arg1,(FXTreeItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_descendingCase(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","FXTreeList::descendingCase", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","FXTreeList::descendingCase", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXint)FXTreeList::descendingCase((FXTreeItem const *)arg1,(FXTreeItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXTreeList_allocate(VALUE self)
+#else
+_wrap_FXTreeList_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXTreeList);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXTreeList(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) TREELIST_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXTreeList *result = 0 ;
+  
+  if ((argc < 1) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXTreeList", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXTreeList", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXTreeList *)new_FXTreeList(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getNumItems(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","getNumItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (FXint)((FXTreeList const *)arg1)->getNumItems();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getNumVisible(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","getNumVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (FXint)((FXTreeList const *)arg1)->getNumVisible();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_setNumVisible(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","setNumVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setNumVisible(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getFirstItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","getFirstItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (FXTreeItem *)((FXTreeList const *)arg1)->getFirstItem();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getLastItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","getLastItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (FXTreeItem *)((FXTreeList const *)arg1)->getLastItem();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_fillItems(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXchar **arg3 = (FXchar **) 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  void *arg6 = (void *) 0 ;
+  FXbool arg7 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","fillItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","fillItems", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  {
+    arg3 = NULL;
+    if(!NIL_P(argv[1])){
+      Check_Type(argv[1], T_ARRAY);
+      if (FXMALLOC(&arg3, FXchar *, RARRAY_LEN(argv[1])+1)) {
+        for (long i = 0; i < RARRAY_LEN(argv[1]); i++) {
+          VALUE e = rb_ary_entry(argv[1], i);
+          arg3[i] = (FXchar *) StringValuePtr(e);
+        }
+        arg3[RARRAY_LEN(argv[1])] = 0;
+      }
+    }
+  }
+  if (argc > 2) {
+    res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","fillItems", 4, argv[2] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 3) {
+    res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","fillItems", 5, argv[3] )); 
+    }
+    arg5 = reinterpret_cast< FXIcon * >(argp5);
+  }
+  if (argc > 4) {
+    arg6 = (argv[4] == Qnil) ? NULL : (void *) argv[4];
+  }
+  if (argc > 5) {
+    arg7 = to_FXbool(argv[5]);
+  }
+  result = (FXint)(arg1)->fillItems(arg2,(FXchar const **)arg3,arg4,arg5,arg6,arg7);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  FXFREE(&arg3);
+  return vresult;
+fail:
+  FXFREE(&arg3);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_insertItem__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg3 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg4 = (FXTreeItem *) 0 ;
+  FXbool arg5 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","insertItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","insertItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXTreeItem *","insertItem", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXTreeItem * >(argp3);
+  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXTreeItem *","insertItem", 4, argv[2] )); 
+  }
+  arg4 = reinterpret_cast< FXTreeItem * >(argp4);
+  if (argc > 3) {
+    arg5 = to_FXbool(argv[3]);
+  }
+  result = (FXTreeItem *)FXTreeList_insertItem__SWIG_0(arg1,arg2,arg3,arg4,arg5);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_insertItem__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg3 = (FXTreeItem *) 0 ;
+  FXString *arg4 = 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  FXIcon *arg6 = (FXIcon *) 0 ;
+  void *arg7 = (void *) 0 ;
+  FXbool arg8 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  SwigValueWrapper< FXString > p4 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  void *argp6 = 0 ;
+  int res6 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 7)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","insertItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","insertItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXTreeItem *","insertItem", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXTreeItem * >(argp3);
+  p4 = to_FXString(argv[2]); arg4 = &p4;
+  if (argc > 3) {
+    res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","insertItem", 5, argv[3] )); 
+    }
+    arg5 = reinterpret_cast< FXIcon * >(argp5);
+  }
+  if (argc > 4) {
+    res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res6)) {
+      SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "FXIcon *","insertItem", 6, argv[4] )); 
+    }
+    arg6 = reinterpret_cast< FXIcon * >(argp6);
+  }
+  if (argc > 5) {
+    arg7 = (argv[5] == Qnil) ? NULL : (void *) argv[5];
+  }
+  if (argc > 6) {
+    arg8 = to_FXbool(argv[6]);
+  }
+  result = (FXTreeItem *)(arg1)->insertItem(arg2,arg3,(FXString const &)*arg4,arg5,arg6,arg7,arg8);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXTreeList_insertItem(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[9];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 9) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 4) && (argc <= 5)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTreeList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXTreeItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXTreeItem, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXTreeItem, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXTreeList_insertItem__SWIG_0(nargs, args, self);
+            }
+            {
+              _v = (argv[4] == Qtrue || argv[4] == Qfalse) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXTreeList_insertItem__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 4) && (argc <= 8)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTreeList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXTreeItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXTreeItem, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          {
+            _v = (NIL_P(argv[3]) || TYPE(argv[3]) == T_STRING) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXTreeList_insertItem__SWIG_1(nargs, args, self);
+            }
+            void *vptr = 0;
+            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_FXIcon, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_FXTreeList_insertItem__SWIG_1(nargs, args, self);
+              }
+              void *vptr = 0;
+              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_FXIcon, 0);
+              _v = SWIG_CheckState(res);
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_FXTreeList_insertItem__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = 1;
+                }
+                if (_v) {
+                  if (argc <= 7) {
+                    return _wrap_FXTreeList_insertItem__SWIG_1(nargs, args, self);
+                  }
+                  {
+                    _v = (argv[7] == Qtrue || argv[7] == Qfalse) ? 1 : 0;
+                  }
+                  if (_v) {
+                    return _wrap_FXTreeList_insertItem__SWIG_1(nargs, args, self);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 9, "insertItem", 
+    "    FXTreeItem insertItem(FXTreeItem *other, FXTreeItem *father, FXTreeItem *item, FXbool notify)\n"
+    "    FXTreeItem * insertItem(FXTreeItem *other, FXTreeItem *father, FXString const &text, FXIcon *oi, FXIcon *ci, void *ITEMDATA, FXbool notify)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_appendItem__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg3 = (FXTreeItem *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","appendItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","appendItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXTreeItem *","appendItem", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXTreeItem * >(argp3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  result = (FXTreeItem *)FXTreeList_appendItem__SWIG_0(arg1,arg2,arg3,arg4);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_appendItem__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXString *arg3 = 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  void *arg6 = (void *) 0 ;
+  FXbool arg7 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","appendItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","appendItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  if (argc > 2) {
+    res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","appendItem", 4, argv[2] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 3) {
+    res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","appendItem", 5, argv[3] )); 
+    }
+    arg5 = reinterpret_cast< FXIcon * >(argp5);
+  }
+  if (argc > 4) {
+    arg6 = (argv[4] == Qnil) ? NULL : (void *) argv[4];
+  }
+  if (argc > 5) {
+    arg7 = to_FXbool(argv[5]);
+  }
+  result = (FXTreeItem *)(arg1)->appendItem(arg2,(FXString const &)*arg3,arg4,arg5,arg6,arg7);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXTreeList_appendItem(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[8];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 8) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 3) && (argc <= 4)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTreeList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXTreeItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXTreeItem, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXTreeList_appendItem__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (argv[3] == Qtrue || argv[3] == Qfalse) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_FXTreeList_appendItem__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 3) && (argc <= 7)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTreeList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXTreeItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXTreeList_appendItem__SWIG_1(nargs, args, self);
+          }
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXTreeList_appendItem__SWIG_1(nargs, args, self);
+            }
+            void *vptr = 0;
+            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_FXIcon, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_FXTreeList_appendItem__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = 1;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_FXTreeList_appendItem__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (argv[6] == Qtrue || argv[6] == Qfalse) ? 1 : 0;
+                }
+                if (_v) {
+                  return _wrap_FXTreeList_appendItem__SWIG_1(nargs, args, self);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 8, "appendItem", 
+    "    FXTreeItem appendItem(FXTreeItem *father, FXTreeItem *item, FXbool notify)\n"
+    "    FXTreeItem * appendItem(FXTreeItem *father, FXString const &text, FXIcon *oi, FXIcon *ci, void *ITEMDATA, FXbool notify)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_prependItem__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg3 = (FXTreeItem *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","prependItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","prependItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXTreeItem *","prependItem", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXTreeItem * >(argp3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  result = (FXTreeItem *)FXTreeList_prependItem__SWIG_0(arg1,arg2,arg3,arg4);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_prependItem__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXString *arg3 = 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  void *arg6 = (void *) 0 ;
+  FXbool arg7 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","prependItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","prependItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  if (argc > 2) {
+    res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","prependItem", 4, argv[2] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 3) {
+    res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","prependItem", 5, argv[3] )); 
+    }
+    arg5 = reinterpret_cast< FXIcon * >(argp5);
+  }
+  if (argc > 4) {
+    arg6 = (argv[4] == Qnil) ? NULL : (void *) argv[4];
+  }
+  if (argc > 5) {
+    arg7 = to_FXbool(argv[5]);
+  }
+  result = (FXTreeItem *)(arg1)->prependItem(arg2,(FXString const &)*arg3,arg4,arg5,arg6,arg7);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXTreeList_prependItem(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[8];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 8) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 3) && (argc <= 4)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTreeList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXTreeItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXTreeItem, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXTreeList_prependItem__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (argv[3] == Qtrue || argv[3] == Qfalse) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_FXTreeList_prependItem__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 3) && (argc <= 7)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTreeList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXTreeItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXTreeList_prependItem__SWIG_1(nargs, args, self);
+          }
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXTreeList_prependItem__SWIG_1(nargs, args, self);
+            }
+            void *vptr = 0;
+            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_FXIcon, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_FXTreeList_prependItem__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = 1;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_FXTreeList_prependItem__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (argv[6] == Qtrue || argv[6] == Qfalse) ? 1 : 0;
+                }
+                if (_v) {
+                  return _wrap_FXTreeList_prependItem__SWIG_1(nargs, args, self);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 8, "prependItem", 
+    "    FXTreeItem prependItem(FXTreeItem *father, FXTreeItem *item, FXbool notify)\n"
+    "    FXTreeItem * prependItem(FXTreeItem *father, FXString const &text, FXIcon *oi, FXIcon *ci, void *ITEMDATA, FXbool notify)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_moveItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg3 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg4 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","moveItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","moveItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXTreeItem *","moveItem", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXTreeItem * >(argp3);
+  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXTreeItem *","moveItem", 4, argv[2] )); 
+  }
+  arg4 = reinterpret_cast< FXTreeItem * >(argp4);
+  result = (FXTreeItem *)(arg1)->moveItem(arg2,arg3,arg4);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_extractItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","extractItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","extractItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXTreeItem *)(arg1)->extractItem(arg2,arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_removeItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","removeItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","removeItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXTreeList_removeItem(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_removeItems(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg3 = (FXTreeItem *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","removeItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","removeItems", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXTreeItem *","removeItems", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXTreeItem * >(argp3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  FXTreeList_removeItems(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_clearItems(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","clearItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXTreeList_clearItems(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getItemWidth(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","getItemWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","getItemWidth", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXint)((FXTreeList const *)arg1)->getItemWidth((FXTreeItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getItemHeight(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","getItemHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","getItemHeight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXint)((FXTreeList const *)arg1)->getItemHeight((FXTreeItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_findItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXString *arg2 = 0 ;
+  FXTreeItem *arg3 = (FXTreeItem *) 0 ;
+  FXuint arg4 = (FXuint) SEARCH_FORWARD|SEARCH_WRAP ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","findItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXTreeItem *","findItem", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXTreeItem * >(argp3);
+  }
+  if (argc > 2) {
+    arg4 = NUM2UINT(argv[2]);
+  }
+  result = (FXTreeItem *)((FXTreeList const *)arg1)->findItem((FXString const &)*arg2,arg3,arg4);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_findItemByData(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXTreeItem *arg3 = (FXTreeItem *) 0 ;
+  FXuint arg4 = (FXuint) SEARCH_FORWARD|SEARCH_WRAP ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","findItemByData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  arg2 = (argv[0] == Qnil) ? NULL : (void *) argv[0];
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXTreeItem *","findItemByData", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXTreeItem * >(argp3);
+  }
+  if (argc > 2) {
+    arg4 = NUM2UINT(argv[2]);
+  }
+  result = (FXTreeItem *)((FXTreeList const *)arg1)->findItemByData((void const *)arg2,arg3,arg4);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_setItemText(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXString *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","setItemText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","setItemText", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  (arg1)->setItemText(arg2,(FXString const &)*arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getItemText(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","getItemText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","getItemText", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = ((FXTreeList const *)arg1)->getItemText((FXTreeItem const *)arg2);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_setItemOpenIcon(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","setItemOpenIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","setItemOpenIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","setItemOpenIcon", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXIcon * >(argp3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  (arg1)->setItemOpenIcon(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getItemOpenIcon(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","getItemOpenIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","getItemOpenIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXIcon *)((FXTreeList const *)arg1)->getItemOpenIcon((FXTreeItem const *)arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_setItemClosedIcon(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","setItemClosedIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","setItemClosedIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","setItemClosedIcon", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXIcon * >(argp3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  (arg1)->setItemClosedIcon(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getItemClosedIcon(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","getItemClosedIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","getItemClosedIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXIcon *)((FXTreeList const *)arg1)->getItemClosedIcon((FXTreeItem const *)arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_setItemData(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  VALUE arg3 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","setItemData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","setItemData", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  arg3 = argv[1];
+  FXTreeList_setItemData(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getItemData(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","getItemData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","getItemData", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (VALUE)FXTreeList_getItemData((FXTreeList const *)arg1,(FXTreeItem const *)arg2);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_isItemSelected(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","isItemSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","isItemSelected", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXbool)((FXTreeList const *)arg1)->isItemSelected((FXTreeItem const *)arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_isItemCurrent(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","isItemCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","isItemCurrent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXbool)((FXTreeList const *)arg1)->isItemCurrent((FXTreeItem const *)arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_isItemVisible(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","isItemVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","isItemVisible", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXbool)((FXTreeList const *)arg1)->isItemVisible((FXTreeItem const *)arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_isItemOpened(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","isItemOpened", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","isItemOpened", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXbool)((FXTreeList const *)arg1)->isItemOpened((FXTreeItem const *)arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_isItemExpanded(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","isItemExpanded", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","isItemExpanded", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXbool)((FXTreeList const *)arg1)->isItemExpanded((FXTreeItem const *)arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_isItemLeaf(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","isItemLeaf", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","isItemLeaf", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXbool)((FXTreeList const *)arg1)->isItemLeaf((FXTreeItem const *)arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_isItemEnabled(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","isItemEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","isItemEnabled", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXbool)((FXTreeList const *)arg1)->isItemEnabled((FXTreeItem const *)arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_hitItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","hitItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","hitItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  result = (FXint)((FXTreeList const *)arg1)->hitItem((FXTreeItem const *)arg2,arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_updateItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","updateItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","updateItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  ((FXTreeList const *)arg1)->updateItem(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getCurrentItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","getCurrentItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (FXTreeItem *)((FXTreeList const *)arg1)->getCurrentItem();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_setAnchorItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","setAnchorItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","setAnchorItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  (arg1)->setAnchorItem(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getAnchorItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","getAnchorItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (FXTreeItem *)((FXTreeList const *)arg1)->getAnchorItem();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getCursorItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","getCursorItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (FXTreeItem *)((FXTreeList const *)arg1)->getCursorItem();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_sortRootItems(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","sortRootItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  (arg1)->sortRootItems();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_sortItems(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","sortItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  (arg1)->sortItems();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_sortChildItems(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","sortChildItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","sortChildItems", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  (arg1)->sortChildItems(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_setFont(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  (arg1)->setFont(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getFont(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (FXFont *)((FXTreeList const *)arg1)->getFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_setIndent(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","setIndent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setIndent(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getIndent(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","getIndent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (FXint)((FXTreeList const *)arg1)->getIndent();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getTextColor(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","getTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (FXColor)((FXTreeList const *)arg1)->getTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_setTextColor(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","setTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","getSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (FXColor)((FXTreeList const *)arg1)->getSelBackColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_setSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","setSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelBackColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","getSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (FXColor)((FXTreeList const *)arg1)->getSelTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_setSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","setSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getLineColor(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","getLineColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (FXColor)((FXTreeList const *)arg1)->getLineColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_setLineColor(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","setLineColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setLineColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getListStyle(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","getListStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (FXuint)((FXTreeList const *)arg1)->getListStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_setListStyle(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","setListStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setListStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (FXString *) &((FXTreeList const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_save(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTreeList_save((FXTreeList const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_load(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTreeList_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_create(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  FXTreeList_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_detach(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  FXTreeList_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_destroy(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  FXTreeList_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_resize(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXTreeList_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (FXint)FXTreeList_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (FXint)FXTreeList_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXTreeList_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXTreeList_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (bool)FXTreeList_canFocus((FXTreeList const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  FXTreeList_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  FXTreeList_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXTreeList_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXTreeList_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_enable(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  FXTreeList_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_disable(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  FXTreeList_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  FXTreeList_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_lower(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  FXTreeList_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_move(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXTreeList_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXTreeList_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_layout(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  FXTreeList_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_recalc(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  FXTreeList_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_reparent(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXTreeList_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_show(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  FXTreeList_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_hide(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  FXTreeList_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (bool)FXTreeList_isComposite((FXTreeList const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_contains(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXTreeList_contains((FXTreeList const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (bool)FXTreeList_doesSaveUnder((FXTreeList const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXTreeList_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_tr(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXTreeList_tr((FXTreeList const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  FXTreeList_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  FXTreeList_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXTreeList_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXTreeList_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXTreeList_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXTreeList_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTreeList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTreeList_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTreeList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTreeList_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTreeList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTreeList_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  FXTreeList_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getViewportHeight(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","getViewportHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (FXint)FXTreeList_getViewportHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getViewportWidth(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","getViewportWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (FXint)FXTreeList_getViewportWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getContentHeight(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","getContentHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (FXint)FXTreeList_getContentHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getContentWidth(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","getContentWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (FXint)FXTreeList_getContentWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  result = (VALUE)FXTreeList_position__SWIG_1((FXTreeList const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXTreeList_position(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTreeList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXTreeList_position__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTreeList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXTreeList_position__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "position", 
+    "    void position(FXint x, FXint y, FXint w, FXint h)\n"
+    "    VALUE position()\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_selectItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","selectItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","selectItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXTreeList_selectItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_deselectItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","deselectItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","deselectItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXTreeList_deselectItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_toggleItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","toggleItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","toggleItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXTreeList_toggleItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_extendSelection(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","extendSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","extendSelection", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXTreeList_extendSelection(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_killSelection(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","killSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXTreeList_killSelection(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_openItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","openItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","openItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXTreeList_openItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_closeItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","closeItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","closeItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXTreeList_closeItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_collapseTree(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","collapseTree", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","collapseTree", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXTreeList_collapseTree(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_expandTree(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","expandTree", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","expandTree", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXTreeList_expandTree(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_setCurrentItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","setCurrentItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","setCurrentItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXTreeList_setCurrentItem(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_getItemAt(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList const *","getItemAt", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXTreeItem *)FXTreeList_getItemAt((FXTreeList const *)arg1,arg2,arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_makeItemVisible(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","makeItemVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","makeItemVisible", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  FXTreeList_makeItemVisible(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_enableItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","enableItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","enableItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXbool)FXTreeList_enableItem(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeList_disableItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeList *arg1 = (FXTreeList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeList *","disableItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","disableItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXbool)FXTreeList_disableItem(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXDirItem;
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXDirItem_allocate(VALUE self)
+#else
+_wrap_FXDirItem_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXDirItem);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXDirItem(int argc, VALUE *argv, VALUE self) {
+  FXString *arg1 = 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  void *arg4 = (void *) 0 ;
+  SwigValueWrapper< FXString > p1 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXDirItem *result = 0 ;
+  
+  if ((argc < 1) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  p1 = to_FXString(argv[0]); arg1 = &p1;
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","FXDirItem", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXIcon * >(argp2);
+  }
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","FXDirItem", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = (argv[3] == Qnil) ? NULL : (void *) argv[3];
+  }
+  {
+    result = (FXDirItem *)new_FXDirItem((FXString const &)*arg1,arg2,arg3,arg4);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_isFile(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem const *","isFile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  result = (FXbool)((FXDirItem const *)arg1)->isFile();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_isDirectory(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem const *","isDirectory", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  result = (FXbool)((FXDirItem const *)arg1)->isDirectory();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_isExecutable(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem const *","isExecutable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  result = (FXbool)((FXDirItem const *)arg1)->isExecutable();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_isSymlink(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem const *","isSymlink", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  result = (FXbool)((FXDirItem const *)arg1)->isSymlink();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_isChardev(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem const *","isChardev", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  result = (FXbool)((FXDirItem const *)arg1)->isChardev();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_isBlockdev(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem const *","isBlockdev", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  result = (FXbool)((FXDirItem const *)arg1)->isBlockdev();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_isFifo(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem const *","isFifo", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  result = (FXbool)((FXDirItem const *)arg1)->isFifo();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_isSocket(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem const *","isSocket", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  result = (FXbool)((FXDirItem const *)arg1)->isSocket();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_getAssoc(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFileAssoc *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem const *","getAssoc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  result = (FXFileAssoc *)((FXDirItem const *)arg1)->getAssoc();
+  vresult = FXRbGetRubyObj(result, "FXFileAssoc *");
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_getSize(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXlong result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem const *","getSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  result = ((FXDirItem const *)arg1)->getSize();
+  vresult = LONG2NUM(result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_getDate(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTime result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem const *","getDate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  result = (FXTime)((FXDirItem const *)arg1)->getDate();
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_save(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDirItem_save((FXDirItem const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_load(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDirItem_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_setText(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem *","setText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  FXDirItem_setText(arg1,(FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_setOpenIcon(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem *","setOpenIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setOpenIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXDirItem_setOpenIcon(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_setClosedIcon(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem *","setClosedIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setClosedIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXDirItem_setClosedIcon(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXDirItem_setFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_setSelected(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem *","setSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXDirItem_setSelected(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_setOpened(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem *","setOpened", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXDirItem_setOpened(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_setExpanded(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem *","setExpanded", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXDirItem_setExpanded(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_setEnabled(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem *","setEnabled", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXDirItem_setEnabled(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_setDraggable(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem *","setDraggable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  FXDirItem_setDraggable(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_getWidth(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  FXTreeList *arg2 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem const *","getWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeList const *","getWidth", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeList * >(argp2);
+  result = (FXint)FXDirItem_getWidth((FXDirItem const *)arg1,(FXTreeList const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_getHeight(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  FXTreeList *arg2 = (FXTreeList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem const *","getHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeList, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeList const *","getHeight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeList * >(argp2);
+  result = (FXint)FXDirItem_getHeight((FXDirItem const *)arg1,(FXTreeList const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_create(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  FXDirItem_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_detach(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  FXDirItem_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirItem_destroy(int argc, VALUE *argv, VALUE self) {
+  FXDirItem *arg1 = (FXDirItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirItem *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirItem * >(argp1);
+  FXDirItem_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXDirList;
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onRefreshTimer(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onRefreshTimer", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRefreshTimer", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onRefreshTimer(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onBeginDrag(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onBeginDrag", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onBeginDrag", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onBeginDrag(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onEndDrag(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onEndDrag", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEndDrag", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEndDrag(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onDragged(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onDragged", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDragged", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDragged(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onDNDEnter(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onDNDEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onDNDLeave(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onDNDLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onDNDMotion(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onDNDMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onDNDDrop(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onDNDDrop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDDrop", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDDrop(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onDNDRequest(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onDNDRequest", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDNDRequest", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDNDRequest(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = static_cast<void*>(StringValuePtr(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onCmdSetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onCmdSetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onCmdGetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onCmdGetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onCmdToggleHidden(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onCmdToggleHidden", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdToggleHidden", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdToggleHidden(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onUpdToggleHidden(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onUpdToggleHidden", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdToggleHidden", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdToggleHidden(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onCmdShowHidden(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onCmdShowHidden", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdShowHidden", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdShowHidden(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onUpdShowHidden(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onUpdShowHidden", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdShowHidden", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdShowHidden(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onCmdHideHidden(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onCmdHideHidden", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdHideHidden", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdHideHidden(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onUpdHideHidden(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onUpdHideHidden", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdHideHidden", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdHideHidden(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onCmdToggleFiles(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onCmdToggleFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdToggleFiles", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdToggleFiles(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onUpdToggleFiles(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onUpdToggleFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdToggleFiles", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdToggleFiles(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onCmdShowFiles(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onCmdShowFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdShowFiles", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdShowFiles(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onUpdShowFiles(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onUpdShowFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdShowFiles", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdShowFiles(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onCmdHideFiles(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onCmdHideFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdHideFiles", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdHideFiles(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onUpdHideFiles(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onUpdHideFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdHideFiles", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdHideFiles(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onCmdSetPattern(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onCmdSetPattern", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetPattern", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = static_cast<void*>(StringValuePtr(argv[2]));
+  result = (long)(arg1)->onCmdSetPattern(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onUpdSetPattern(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onUpdSetPattern", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSetPattern", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdSetPattern(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onCmdSortReverse(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onCmdSortReverse", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSortReverse", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSortReverse(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onUpdSortReverse(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onUpdSortReverse", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSortReverse", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdSortReverse(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onCmdSortCase(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onCmdSortCase", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSortCase", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSortCase(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onUpdSortCase(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onUpdSortCase", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSortCase", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdSortCase(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_onCmdRefresh(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","onCmdRefresh", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdRefresh", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdRefresh(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_ascending(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","FXDirList::ascending", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","FXDirList::ascending", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXint)FXDirList::ascending((FXTreeItem const *)arg1,(FXTreeItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_descending(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","FXDirList::descending", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","FXDirList::descending", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXint)FXDirList::descending((FXTreeItem const *)arg1,(FXTreeItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_ascendingCase(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","FXDirList::ascendingCase", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","FXDirList::ascendingCase", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXint)FXDirList::ascendingCase((FXTreeItem const *)arg1,(FXTreeItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_descendingCase(int argc, VALUE *argv, VALUE self) {
+  FXTreeItem *arg1 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeItem const *","FXDirList::descendingCase", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXTreeItem * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","FXDirList::descendingCase", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXint)FXDirList::descendingCase((FXTreeItem const *)arg1,(FXTreeItem const *)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXDirList_allocate(VALUE self)
+#else
+_wrap_FXDirList_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXDirList);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXDirList(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXDirList *result = 0 ;
+  
+  if ((argc < 1) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXDirList", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXDirList", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXDirList *)new_FXDirList(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_scan(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","scan", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->scan(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_isItemDirectory(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList const *","isItemDirectory", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","isItemDirectory", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXbool)((FXDirList const *)arg1)->isItemDirectory((FXTreeItem const *)arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_isItemFile(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList const *","isItemFile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","isItemFile", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXbool)((FXDirList const *)arg1)->isItemFile((FXTreeItem const *)arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_isItemExecutable(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList const *","isItemExecutable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","isItemExecutable", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXbool)((FXDirList const *)arg1)->isItemExecutable((FXTreeItem const *)arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_setCurrentFile(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXString *arg2 = 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","setCurrentFile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setCurrentFile((FXString const &)*arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_getCurrentFile(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList const *","getCurrentFile", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  result = ((FXDirList const *)arg1)->getCurrentFile();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_setDirectory(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXString *arg2 = 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","setDirectory", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setDirectory((FXString const &)*arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_getDirectory(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList const *","getDirectory", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  result = ((FXDirList const *)arg1)->getDirectory();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_getItemPathname(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList const *","getItemPathname", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","getItemPathname", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = ((FXDirList const *)arg1)->getItemPathname((FXTreeItem const *)arg2);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_getPathnameItem(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","getPathnameItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  result = (FXTreeItem *)(arg1)->getPathnameItem((FXString const &)*arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_setPattern(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","setPattern", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setPattern((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_getPattern(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList const *","getPattern", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  result = ((FXDirList const *)arg1)->getPattern();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_getMatchMode(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList const *","getMatchMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  result = (FXuint)((FXDirList const *)arg1)->getMatchMode();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_setMatchMode(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","setMatchMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setMatchMode(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_getShowFiles(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList const *","showFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  result = (FXbool)((FXDirList const *)arg1)->showFiles();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_setShowFiles(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","showFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->showFiles(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_getShowHiddenFiles(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList const *","showHiddenFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  result = (FXbool)((FXDirList const *)arg1)->showHiddenFiles();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_setShowHiddenFiles(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","showHiddenFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->showHiddenFiles(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_setAssociations(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXFileDict *arg2 = (FXFileDict *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","setAssociations", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFileDict, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFileDict *","setAssociations", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFileDict * >(argp2);
+  (arg1)->setAssociations(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_getAssociations(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFileDict *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList const *","getAssociations", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  result = (FXFileDict *)((FXDirList const *)arg1)->getAssociations();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFileDict, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_save(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDirList_save((FXDirList const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_load(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDirList_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_create(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  FXDirList_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_detach(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  FXDirList_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_destroy(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  FXDirList_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_resize(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDirList_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  result = (FXint)FXDirList_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  result = (FXint)FXDirList_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDirList_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDirList_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  result = (bool)FXDirList_canFocus((FXDirList const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  FXDirList_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  FXDirList_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXDirList_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXDirList_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_enable(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  FXDirList_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_disable(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  FXDirList_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  FXDirList_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_lower(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  FXDirList_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_move(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDirList_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDirList_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_layout(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  FXDirList_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_recalc(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  FXDirList_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_reparent(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXDirList_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_show(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  FXDirList_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_hide(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  FXDirList_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  result = (bool)FXDirList_isComposite((FXDirList const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_contains(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXDirList_contains((FXDirList const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  result = (bool)FXDirList_doesSaveUnder((FXDirList const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXDirList_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_tr(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXDirList_tr((FXDirList const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  FXDirList_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  FXDirList_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXDirList_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXDirList_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXDirList_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDirList_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDirList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDirList_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDirList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDirList_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDirList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDirList_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  FXDirList_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_getViewportHeight(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","getViewportHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  result = (FXint)FXDirList_getViewportHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_getViewportWidth(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","getViewportWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  result = (FXint)FXDirList_getViewportWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_getContentHeight(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","getContentHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  result = (FXint)FXDirList_getContentHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_getContentWidth(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","getContentWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  result = (FXint)FXDirList_getContentWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList const *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  result = (VALUE)FXDirList_position__SWIG_1((FXDirList const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDirList_position(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDirList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXDirList_position__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDirList, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXDirList_position__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "position", 
+    "    void position(FXint x, FXint y, FXint w, FXint h)\n"
+    "    VALUE position()\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_selectItem(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","selectItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","selectItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXDirList_selectItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_deselectItem(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","deselectItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","deselectItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXDirList_deselectItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_toggleItem(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","toggleItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","toggleItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXDirList_toggleItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_extendSelection(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","extendSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","extendSelection", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXDirList_extendSelection(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_killSelection(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","killSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXDirList_killSelection(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_openItem(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","openItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","openItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXDirList_openItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_closeItem(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","closeItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","closeItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXDirList_closeItem(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_collapseTree(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","collapseTree", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","collapseTree", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXDirList_collapseTree(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_expandTree(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","expandTree", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","expandTree", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  result = (FXbool)FXDirList_expandTree(arg1,arg2,arg3);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_setCurrentItem(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","setCurrentItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","setCurrentItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXDirList_setCurrentItem(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_getItemAt(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList const *","getItemAt", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXTreeItem *)FXDirList_getItemAt((FXDirList const *)arg1,arg2,arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_makeItemVisible(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","makeItemVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","makeItemVisible", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  FXDirList_makeItemVisible(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_enableItem(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","enableItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","enableItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXbool)FXDirList_enableItem(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirList_disableItem(int argc, VALUE *argv, VALUE self) {
+  FXDirList *arg1 = (FXDirList *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirList, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirList *","disableItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirList * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","disableItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXbool)FXDirList_disableItem(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_FXGradientBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShutterItemTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXTreeListTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXTreeList *) x));
+}
+static void *_p_FXSwitcherTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXDirListTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *)(FXTreeList *) ((FXDirList *) x));
+}
+static void *_p_FXMatrixTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXDrawableTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXDrawable *) x));
+}
+static void *_p_FXHeaderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXSplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSpringTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXProgressBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXFoldingListTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXFoldingList *) x));
+}
+static void *_p_FXToolTipTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXDockSiteTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXCanvasTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXColorWheelTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXVisualTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXVisual *) x));
+}
+static void *_p_FXScrollBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXFontTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXFont *) x));
+}
+static void *_p_FXComboBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStatusBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXCursor *) x));
+}
+static void *_p_FXKnobTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRulerViewTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXStatusLineTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXMainWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXDockBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXToolBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDirBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXDocumentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDocument *) x));
+}
+static void *_p_FXGradientBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXRegistryTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *)(FXSettings *) ((FXRegistry *) x));
+}
+static void *_p_FXHeaderItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXHeaderItem *) x));
+}
+static void *_p_FXShutterItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXTreeListTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXTreeList *) x));
+}
+static void *_p_FXSwitcherTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXIconDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXIconDict *) x));
+}
+static void *_p_FXDirListTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *)(FXTreeList *) ((FXDirList *) x));
+}
+static void *_p_FXMatrixTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXFileDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXFileDict *) x));
+}
+static void *_p_FXRecentFilesTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXRecentFiles *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXDrawableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXDrawable *) x));
+}
+static void *_p_FXAppTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXApp *) x));
+}
+static void *_p_FXHeaderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXTranslatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXTranslator *) x));
+}
+static void *_p_FX4SplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FXSpringTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXIdTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXId *) x));
+}
+static void *_p_FXProgressBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXFoldingListTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXFoldingList *) x));
+}
+static void *_p_FXToolTipTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXSettingsTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXSettings *) x));
+}
+static void *_p_FXDockSiteTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDebugTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDebugTarget *) x));
+}
+static void *_p_FXDataTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDataTarget *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXTreeItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXTreeItem *) x));
+}
+static void *_p_FXCanvasTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXListBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXColorWheelTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXVisualTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXVisual *) x));
+}
+static void *_p_FXScrollBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXDirItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXTreeItem *) ((FXDirItem *) x));
+}
+static void *_p_FXFontTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXFont *) x));
+}
+static void *_p_FXComboBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStringDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXStringDict *) x));
+}
+static void *_p_FXStatusBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXDelegatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDelegator *) x));
+}
+static void *_p_FXAccelTableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXAccelTable *) x));
+}
+static void *_p_FXCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXKnobTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRulerViewTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXStatusLineTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXDockBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDict *) x));
+}
+static void *_p_FXShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXFoldingItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXFoldingItem *) x));
+}
+static void *_p_FXToolBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDirBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXFoldingListTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXFoldingList *) x));
+}
+static void *_p_FXDirListTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *) (FXTreeList *) ((FXDirList *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXScrollWindow *) x));
+}
+static void *_p_FXTreeListTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXTreeList *) x));
+}
+static void *_p_FXImageViewTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXImageView *) x));
+}
+static void *_p_FXRulerViewTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXRulerView *) x));
+}
+static void *_p_FXGradientBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShutterItemTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTreeListTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXTreeList *) x));
+}
+static void *_p_FXTabBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXDirListTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *)(FXTreeList *) ((FXDirList *) x));
+}
+static void *_p_FXMatrixTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXHeaderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXSplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSpringTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXProgressBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXFoldingListTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXFoldingList *) x));
+}
+static void *_p_FXToolTipTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXDockSiteTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXCanvasTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXCanvas *) x));
+}
+static void *_p_FXColorWheelTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXScrollBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXScrollBar *) x));
+}
+static void *_p_FXComboBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStatusBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXKnobTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXRulerViewTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXStatusLineTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXDockBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXToolBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXDirBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXToolBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolTipTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXTabBookTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXShell *) x));
+}
+static void *_p_FXStatusBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXScrollArea *) x));
+}
+static void *_p_FXPopupTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXFoldingListTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXFoldingList *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXComboBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FX4SplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXSplitter *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXPackerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXPacker *) x));
+}
+static void *_p_FXDirBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXSwitcherTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXShutterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXDirListTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *)(FXTreeList *) ((FXDirList *) x));
+}
+static void *_p_FXDockSiteTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXRulerViewTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXMatrixTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXShutterItemTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXDockBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXImageViewTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXTreeListTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXTreeList *) x));
+}
+static void *_p_FXSpringTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXGradientBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShutterItemTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTreeListTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXTreeList *) x));
+}
+static void *_p_FXTabBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXDirListTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *)(FXTreeList *) ((FXDirList *) x));
+}
+static void *_p_FXMatrixTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXHeaderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXSplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSpringTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXProgressBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXFoldingListTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXFoldingList *) x));
+}
+static void *_p_FXToolTipTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXDockSiteTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXCanvasTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXColorWheelTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXScrollBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXComboBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStatusBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXKnobTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXRulerViewTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXStatusLineTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *)  ((FXWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXDockBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXToolBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXDirBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXFileStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXFileStream *) x));
+}
+static void *_p_FXMemoryStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXMemoryStream *) x));
+}
+static void *_p_FXDirListTo_p_FXTreeList(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTreeList *)  ((FXDirList *) x));
+}
+static void *_p_FXDirItemTo_p_FXTreeItem(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTreeItem *)  ((FXDirItem *) x));
+}
+static swig_type_info _swigt__p_FXBitmap = {"_p_FXBitmap", "FXBitmap *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXComposite = {"_p_FXComposite", "FXComposite *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDriveBox = {"_p_FXDriveBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBar = {"_p_FXToolBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolTip = {"_p_FXToolTip", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTabBook = {"_p_FXTabBook", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGroupBox = {"_p_FXGroupBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShell = {"_p_FXShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusBar = {"_p_FXStatusBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPopup = {"_p_FXPopup", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTopWindow = {"_p_FXTopWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRootWindow = {"_p_FXRootWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMainWindow = {"_p_FXMainWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplashWindow = {"_p_FXSplashWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollWindow = {"_p_FXScrollWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXComboBox = {"_p_FXComboBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalFrame = {"_p_FXHorizontalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalFrame = {"_p_FXVerticalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FX4Splitter = {"_p_FX4Splitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplitter = {"_p_FXSplitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRealSpinner = {"_p_FXRealSpinner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSpinner = {"_p_FXSpinner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPacker = {"_p_FXPacker", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDirBox = {"_p_FXDirBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSwitcher = {"_p_FXSwitcher", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDirSelector = {"_p_FXDirSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileSelector = {"_p_FXFileSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorSelector = {"_p_FXColorSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFontSelector = {"_p_FXFontSelector", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutter = {"_p_FXShutter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRulerView = {"_p_FXRulerView", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockSite = {"_p_FXDockSite", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTreeListBox = {"_p_FXTreeListBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXListBox = {"_p_FXListBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMatrix = {"_p_FXMatrix", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutterItem = {"_p_FXShutterItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockBar = {"_p_FXDockBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTabBar = {"_p_FXTabBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImageView = {"_p_FXImageView", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSpring = {"_p_FXSpring", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarShell = {"_p_FXToolBarShell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDirItem = {"_p_FXDirItem", "FXDirItem *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDirList = {"_p_FXDirList", "FXDirList *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDrawable = {"_p_FXDrawable", "FXDrawable *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGradientBar = {"_p_FXGradientBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorBar = {"_p_FXColorBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTextField = {"_p_FXTextField", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarTab = {"_p_FXToolBarTab", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollCorner = {"_p_FXScrollCorner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXArrowButton = {"_p_FXArrowButton", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImageFrame = {"_p_FXImageFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalSeparator = {"_p_FXVerticalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalSeparator = {"_p_FXHorizontalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSeparator = {"_p_FXSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXKnob = {"_p_FXKnob", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXProgressBar = {"_p_FXProgressBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXBitmapFrame = {"_p_FXBitmapFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSlider = {"_p_FXSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRealSlider = {"_p_FXRealSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorRing = {"_p_FXColorRing", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockHandler = {"_p_FXDockHandler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCanvas = {"_p_FXCanvas", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWheel = {"_p_FXColorWheel", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDial = {"_p_FXDial", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarGrip = {"_p_FXToolBarGrip", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollBar = {"_p_FXScrollBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFrame = {"_p_FXFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FX7Segment = {"_p_FX7Segment", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDockTitle = {"_p_FXDockTitle", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusLine = {"_p_FXStatusLine", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWell = {"_p_FXColorWell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDragCorner = {"_p_FXDragCorner", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRuler = {"_p_FXRuler", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXFileDict = {"_p_FXFileDict", "FXFileDict *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFoldingItem = {"_p_FXFoldingItem", "FXFoldingItem *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFoldingList = {"_p_FXFoldingList", "FXFoldingList *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFoldingListSortFunc = {"_p_FXFoldingListSortFunc", "FXFoldingListSortFunc *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFont = {"_p_FXFont", "FXFont *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXHeader = {"_p_FXHeader", "FXHeader *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXIcon = {"_p_FXIcon", "FXIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXId = {"_p_FXId", "FXId *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXVisual = {"_p_FXVisual", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCursor = {"_p_FXCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCURCursor = {"_p_FXCURCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGIFCursor = {"_p_FXGIFCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXObject = {"_p_FXObject", "FXObject *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDocument = {"_p_FXDocument", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRegistry = {"_p_FXRegistry", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHeaderItem = {"_p_FXHeaderItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXIconDict = {"_p_FXIconDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRecentFiles = {"_p_FXRecentFiles", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTranslator = {"_p_FXTranslator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXApp = {"_p_FXApp", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDict = {"_p_FXDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSettings = {"_p_FXSettings", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDataTarget = {"_p_FXDataTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDebugTarget = {"_p_FXDebugTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStringDict = {"_p_FXStringDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDelegator = {"_p_FXDelegator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXAccelTable = {"_p_FXAccelTable", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRegion = {"_p_FXRegion", "FXRegion *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXScrollArea = {"_p_FXScrollArea", "FXScrollArea *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXStream = {"_p_FXStream", "FXStream *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFileStream = {"_p_FXFileStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMemoryStream = {"_p_FXMemoryStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTreeItem = {"_p_FXTreeItem", "FXTreeItem *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXTreeList = {"_p_FXTreeList", "FXTreeList *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXWindow = {"_p_FXWindow", "FXWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_char = {"_p_char", "char *|FXchar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "double *|FXdouble *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_float = {"_p_float", "float *|FXfloat *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "FXint *|int *|FXInputHandle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_long = {"_p_long", "long *|FXTime *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_short = {"_p_short", "short *|FXshort *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "FXuchar *|unsigned char *|FXbool *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "FXwchar *|FXDragType *|unsigned int *|FXuint *|FXColor *|FXSelector *|FXHotKey *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|FXuval *|FXPixel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|FXushort *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_FX4Splitter,
+  &_swigt__p_FX7Segment,
+  &_swigt__p_FXAccelTable,
+  &_swigt__p_FXApp,
+  &_swigt__p_FXArrowButton,
+  &_swigt__p_FXBitmap,
+  &_swigt__p_FXBitmapFrame,
+  &_swigt__p_FXCURCursor,
+  &_swigt__p_FXCanvas,
+  &_swigt__p_FXColorBar,
+  &_swigt__p_FXColorRing,
+  &_swigt__p_FXColorSelector,
+  &_swigt__p_FXColorWell,
+  &_swigt__p_FXColorWheel,
+  &_swigt__p_FXComboBox,
+  &_swigt__p_FXComposite,
+  &_swigt__p_FXCursor,
+  &_swigt__p_FXDataTarget,
+  &_swigt__p_FXDebugTarget,
+  &_swigt__p_FXDelegator,
+  &_swigt__p_FXDial,
+  &_swigt__p_FXDict,
+  &_swigt__p_FXDirBox,
+  &_swigt__p_FXDirItem,
+  &_swigt__p_FXDirList,
+  &_swigt__p_FXDirSelector,
+  &_swigt__p_FXDockBar,
+  &_swigt__p_FXDockHandler,
+  &_swigt__p_FXDockSite,
+  &_swigt__p_FXDockTitle,
+  &_swigt__p_FXDocument,
+  &_swigt__p_FXDragCorner,
+  &_swigt__p_FXDrawable,
+  &_swigt__p_FXDriveBox,
+  &_swigt__p_FXFileDict,
+  &_swigt__p_FXFileSelector,
+  &_swigt__p_FXFileStream,
+  &_swigt__p_FXFoldingItem,
+  &_swigt__p_FXFoldingList,
+  &_swigt__p_FXFoldingListSortFunc,
+  &_swigt__p_FXFont,
+  &_swigt__p_FXFontSelector,
+  &_swigt__p_FXFrame,
+  &_swigt__p_FXGIFCursor,
+  &_swigt__p_FXGradientBar,
+  &_swigt__p_FXGroupBox,
+  &_swigt__p_FXHeader,
+  &_swigt__p_FXHeaderItem,
+  &_swigt__p_FXHorizontalFrame,
+  &_swigt__p_FXHorizontalSeparator,
+  &_swigt__p_FXIcon,
+  &_swigt__p_FXIconDict,
+  &_swigt__p_FXId,
+  &_swigt__p_FXImageFrame,
+  &_swigt__p_FXImageView,
+  &_swigt__p_FXKnob,
+  &_swigt__p_FXListBox,
+  &_swigt__p_FXMainWindow,
+  &_swigt__p_FXMatrix,
+  &_swigt__p_FXMemoryStream,
+  &_swigt__p_FXObject,
+  &_swigt__p_FXPacker,
+  &_swigt__p_FXPopup,
+  &_swigt__p_FXProgressBar,
+  &_swigt__p_FXRealSlider,
+  &_swigt__p_FXRealSpinner,
+  &_swigt__p_FXRecentFiles,
+  &_swigt__p_FXRegion,
+  &_swigt__p_FXRegistry,
+  &_swigt__p_FXRootWindow,
+  &_swigt__p_FXRuler,
+  &_swigt__p_FXRulerView,
+  &_swigt__p_FXScrollArea,
+  &_swigt__p_FXScrollBar,
+  &_swigt__p_FXScrollCorner,
+  &_swigt__p_FXScrollWindow,
+  &_swigt__p_FXSeparator,
+  &_swigt__p_FXSettings,
+  &_swigt__p_FXShell,
+  &_swigt__p_FXShutter,
+  &_swigt__p_FXShutterItem,
+  &_swigt__p_FXSlider,
+  &_swigt__p_FXSpinner,
+  &_swigt__p_FXSplashWindow,
+  &_swigt__p_FXSplitter,
+  &_swigt__p_FXSpring,
+  &_swigt__p_FXStatusBar,
+  &_swigt__p_FXStatusLine,
+  &_swigt__p_FXStream,
+  &_swigt__p_FXStringDict,
+  &_swigt__p_FXSwitcher,
+  &_swigt__p_FXTabBar,
+  &_swigt__p_FXTabBook,
+  &_swigt__p_FXTextField,
+  &_swigt__p_FXToolBar,
+  &_swigt__p_FXToolBarGrip,
+  &_swigt__p_FXToolBarShell,
+  &_swigt__p_FXToolBarTab,
+  &_swigt__p_FXToolTip,
+  &_swigt__p_FXTopWindow,
+  &_swigt__p_FXTranslator,
+  &_swigt__p_FXTreeItem,
+  &_swigt__p_FXTreeList,
+  &_swigt__p_FXTreeListBox,
+  &_swigt__p_FXVerticalFrame,
+  &_swigt__p_FXVerticalSeparator,
+  &_swigt__p_FXVisual,
+  &_swigt__p_FXWindow,
+  &_swigt__p_char,
+  &_swigt__p_double,
+  &_swigt__p_float,
+  &_swigt__p_int,
+  &_swigt__p_long,
+  &_swigt__p_short,
+  &_swigt__p_unsigned_char,
+  &_swigt__p_unsigned_int,
+  &_swigt__p_unsigned_long,
+  &_swigt__p_unsigned_short,
+};
+
+static swig_cast_info _swigc__p_FXBitmap[] = {  {&_swigt__p_FXBitmap, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDriveBox[] = {{&_swigt__p_FXDriveBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBar[] = {{&_swigt__p_FXToolBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolTip[] = {{&_swigt__p_FXToolTip, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabBook[] = {{&_swigt__p_FXTabBook, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGroupBox[] = {{&_swigt__p_FXGroupBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShell[] = {{&_swigt__p_FXShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusBar[] = {{&_swigt__p_FXStatusBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPopup[] = {{&_swigt__p_FXPopup, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTopWindow[] = {{&_swigt__p_FXTopWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRootWindow[] = {{&_swigt__p_FXRootWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMainWindow[] = {{&_swigt__p_FXMainWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplashWindow[] = {{&_swigt__p_FXSplashWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollWindow[] = {{&_swigt__p_FXScrollWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComboBox[] = {{&_swigt__p_FXComboBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalFrame[] = {{&_swigt__p_FXHorizontalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalFrame[] = {{&_swigt__p_FXVerticalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FX4Splitter[] = {{&_swigt__p_FX4Splitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplitter[] = {{&_swigt__p_FXSplitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSpinner[] = {{&_swigt__p_FXRealSpinner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpinner[] = {{&_swigt__p_FXSpinner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPacker[] = {{&_swigt__p_FXPacker, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirBox[] = {{&_swigt__p_FXDirBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSwitcher[] = {{&_swigt__p_FXSwitcher, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirSelector[] = {{&_swigt__p_FXDirSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileSelector[] = {{&_swigt__p_FXFileSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorSelector[] = {{&_swigt__p_FXColorSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFontSelector[] = {{&_swigt__p_FXFontSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutter[] = {{&_swigt__p_FXShutter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRulerView[] = {{&_swigt__p_FXRulerView, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockSite[] = {{&_swigt__p_FXDockSite, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTreeListBox[] = {{&_swigt__p_FXTreeListBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXListBox[] = {{&_swigt__p_FXListBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMatrix[] = {{&_swigt__p_FXMatrix, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutterItem[] = {{&_swigt__p_FXShutterItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockBar[] = {{&_swigt__p_FXDockBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabBar[] = {{&_swigt__p_FXTabBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageView[] = {{&_swigt__p_FXImageView, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpring[] = {{&_swigt__p_FXSpring, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarShell[] = {{&_swigt__p_FXToolBarShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComposite[] = {  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXComposite, 0, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXComposite, 0, 0},  {&_swigt__p_FXFoldingList, _p_FXFoldingListTo_p_FXComposite, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXComposite, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDirList, _p_FXDirListTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTreeList, _p_FXTreeListTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXComposite, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXComposite, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirItem[] = {  {&_swigt__p_FXDirItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirList[] = {  {&_swigt__p_FXDirList, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGradientBar[] = {{&_swigt__p_FXGradientBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorBar[] = {{&_swigt__p_FXColorBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTextField[] = {{&_swigt__p_FXTextField, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarTab[] = {{&_swigt__p_FXToolBarTab, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollCorner[] = {{&_swigt__p_FXScrollCorner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXArrowButton[] = {{&_swigt__p_FXArrowButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageFrame[] = {{&_swigt__p_FXImageFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalSeparator[] = {{&_swigt__p_FXVerticalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalSeparator[] = {{&_swigt__p_FXHorizontalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSeparator[] = {{&_swigt__p_FXSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXKnob[] = {{&_swigt__p_FXKnob, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXProgressBar[] = {{&_swigt__p_FXProgressBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBitmapFrame[] = {{&_swigt__p_FXBitmapFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSlider[] = {{&_swigt__p_FXSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSlider[] = {{&_swigt__p_FXRealSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorRing[] = {{&_swigt__p_FXColorRing, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockHandler[] = {{&_swigt__p_FXDockHandler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCanvas[] = {{&_swigt__p_FXCanvas, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWheel[] = {{&_swigt__p_FXColorWheel, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDial[] = {{&_swigt__p_FXDial, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarGrip[] = {{&_swigt__p_FXToolBarGrip, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollBar[] = {{&_swigt__p_FXScrollBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFrame[] = {{&_swigt__p_FXFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FX7Segment[] = {{&_swigt__p_FX7Segment, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockTitle[] = {{&_swigt__p_FXDockTitle, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusLine[] = {{&_swigt__p_FXStatusLine, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWell[] = {{&_swigt__p_FXColorWell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDragCorner[] = {{&_swigt__p_FXDragCorner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRuler[] = {{&_swigt__p_FXRuler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDrawable[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTreeList, _p_FXTreeListTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirList, _p_FXDirListTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDrawable, 0, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFoldingList, _p_FXFoldingListTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXDrawable, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileDict[] = {  {&_swigt__p_FXFileDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFoldingItem[] = {  {&_swigt__p_FXFoldingItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFoldingList[] = {  {&_swigt__p_FXFoldingList, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFoldingListSortFunc[] = {  {&_swigt__p_FXFoldingListSortFunc, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFont[] = {  {&_swigt__p_FXFont, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeader[] = {  {&_swigt__p_FXHeader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIcon[] = {  {&_swigt__p_FXIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVisual[] = {{&_swigt__p_FXVisual, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCursor[] = {{&_swigt__p_FXCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCURCursor[] = {{&_swigt__p_FXCURCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGIFCursor[] = {{&_swigt__p_FXGIFCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXId[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXId, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXId, 0, 0},  {&_swigt__p_FXTreeList, _p_FXTreeListTo_p_FXId, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXId, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXId, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXId, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXDirList, _p_FXDirListTo_p_FXId, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXId, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXId, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXId, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXId, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXId, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXId, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXId, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXId, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXId, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXId, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXId, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXId, 0, 0},  {&_swigt__p_FXFoldingList, _p_FXFoldingListTo_p_FXId, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXId, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXId, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXId, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXId, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXId, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXId, 0, 0},  {&_swigt__p_FXId, 0, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXId, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXId, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXId, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXId, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXId, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXId, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXId, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXId, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXId, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXId, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXId, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXId, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXId, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXId, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDocument[] = {{&_swigt__p_FXDocument, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegistry[] = {{&_swigt__p_FXRegistry, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeaderItem[] = {{&_swigt__p_FXHeaderItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIconDict[] = {{&_swigt__p_FXIconDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRecentFiles[] = {{&_swigt__p_FXRecentFiles, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTranslator[] = {{&_swigt__p_FXTranslator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXApp[] = {{&_swigt__p_FXApp, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDict[] = {{&_swigt__p_FXDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSettings[] = {{&_swigt__p_FXSettings, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDataTarget[] = {{&_swigt__p_FXDataTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDebugTarget[] = {{&_swigt__p_FXDebugTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStringDict[] = {{&_swigt__p_FXStringDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDelegator[] = {{&_swigt__p_FXDelegator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXAccelTable[] = {{&_swigt__p_FXAccelTable, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXObject[] = {  {&_swigt__p_FXDocument, _p_FXDocumentTo_p_FXObject, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXRegistry, _p_FXRegistryTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeaderItem, _p_FXHeaderItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXTreeList, _p_FXTreeListTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXObject, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXObject, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirList, _p_FXDirListTo_p_FXObject, 0, 0},  {&_swigt__p_FXIconDict, _p_FXIconDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileDict, _p_FXFileDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXRecentFiles, _p_FXRecentFilesTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXObject, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXObject, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXObject, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FXTranslator, _p_FXTranslatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXObject, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXObject, 0, 0},  {&_swigt__p_FXApp, _p_FXAppTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXObject, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXObject, 0, 0},  {&_swigt__p_FXFoldingList, _p_FXFoldingListTo_p_FXObject, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXObject, 0, 0},  {&_swigt__p_FXDict, _p_FXDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXSettings, _p_FXSettingsTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXObject, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXObject, 0, 0},  {&_swigt__p_FXDataTarget, _p_FXDataTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDebugTarget, _p_FXDebugTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXObject, 0, 0},  {&_swigt__p_FXTreeItem, _p_FXTreeItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXObject, 0, 0},  {&_swigt__p_FXId, _p_FXIdTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXObject, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirItem, _p_FXDirItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXObject, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXStringDict, _p_FXStringDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXDelegator, _p_FXDelegatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXAccelTable, _p_FXAccelTableTo_p_FXObject, 0, 0},  {&_swigt__p_FXObject, 0, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXObject, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXObject, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXObject, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXObject, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXFoldingItem, _p_FXFoldingItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXObject, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegion[] = {  {&_swigt__p_FXRegion, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollArea[] = {  {&_swigt__p_FXFoldingList, _p_FXFoldingListTo_p_FXScrollArea, 0, 0},  {&_swigt__p_FXDirList, _p_FXDirListTo_p_FXScrollArea, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXScrollArea, 0, 0},  {&_swigt__p_FXTreeList, _p_FXTreeListTo_p_FXScrollArea, 0, 0},  {&_swigt__p_FXScrollArea, 0, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXScrollArea, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXScrollArea, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileStream[] = {{&_swigt__p_FXFileStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMemoryStream[] = {{&_swigt__p_FXMemoryStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStream[] = {  {&_swigt__p_FXFileStream, _p_FXFileStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXMemoryStream, _p_FXMemoryStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTreeItem[] = {  {&_swigt__p_FXTreeItem, 0, 0, 0},  {&_swigt__p_FXDirItem, _p_FXDirItemTo_p_FXTreeItem, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTreeList[] = {  {&_swigt__p_FXDirList, _p_FXDirListTo_p_FXTreeList, 0, 0},  {&_swigt__p_FXTreeList, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXWindow[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTreeList, _p_FXTreeListTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDirList, _p_FXDirListTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXWindow, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXWindow, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFoldingList, _p_FXFoldingListTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXWindow, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXWindow, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXWindow, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXWindow, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXWindow, 0, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXWindow, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
+
+static swig_cast_info *swig_cast_initial[] = {
+  _swigc__p_FX4Splitter,
+  _swigc__p_FX7Segment,
+  _swigc__p_FXAccelTable,
+  _swigc__p_FXApp,
+  _swigc__p_FXArrowButton,
+  _swigc__p_FXBitmap,
+  _swigc__p_FXBitmapFrame,
+  _swigc__p_FXCURCursor,
+  _swigc__p_FXCanvas,
+  _swigc__p_FXColorBar,
+  _swigc__p_FXColorRing,
+  _swigc__p_FXColorSelector,
+  _swigc__p_FXColorWell,
+  _swigc__p_FXColorWheel,
+  _swigc__p_FXComboBox,
+  _swigc__p_FXComposite,
+  _swigc__p_FXCursor,
+  _swigc__p_FXDataTarget,
+  _swigc__p_FXDebugTarget,
+  _swigc__p_FXDelegator,
+  _swigc__p_FXDial,
+  _swigc__p_FXDict,
+  _swigc__p_FXDirBox,
+  _swigc__p_FXDirItem,
+  _swigc__p_FXDirList,
+  _swigc__p_FXDirSelector,
+  _swigc__p_FXDockBar,
+  _swigc__p_FXDockHandler,
+  _swigc__p_FXDockSite,
+  _swigc__p_FXDockTitle,
+  _swigc__p_FXDocument,
+  _swigc__p_FXDragCorner,
+  _swigc__p_FXDrawable,
+  _swigc__p_FXDriveBox,
+  _swigc__p_FXFileDict,
+  _swigc__p_FXFileSelector,
+  _swigc__p_FXFileStream,
+  _swigc__p_FXFoldingItem,
+  _swigc__p_FXFoldingList,
+  _swigc__p_FXFoldingListSortFunc,
+  _swigc__p_FXFont,
+  _swigc__p_FXFontSelector,
+  _swigc__p_FXFrame,
+  _swigc__p_FXGIFCursor,
+  _swigc__p_FXGradientBar,
+  _swigc__p_FXGroupBox,
+  _swigc__p_FXHeader,
+  _swigc__p_FXHeaderItem,
+  _swigc__p_FXHorizontalFrame,
+  _swigc__p_FXHorizontalSeparator,
+  _swigc__p_FXIcon,
+  _swigc__p_FXIconDict,
+  _swigc__p_FXId,
+  _swigc__p_FXImageFrame,
+  _swigc__p_FXImageView,
+  _swigc__p_FXKnob,
+  _swigc__p_FXListBox,
+  _swigc__p_FXMainWindow,
+  _swigc__p_FXMatrix,
+  _swigc__p_FXMemoryStream,
+  _swigc__p_FXObject,
+  _swigc__p_FXPacker,
+  _swigc__p_FXPopup,
+  _swigc__p_FXProgressBar,
+  _swigc__p_FXRealSlider,
+  _swigc__p_FXRealSpinner,
+  _swigc__p_FXRecentFiles,
+  _swigc__p_FXRegion,
+  _swigc__p_FXRegistry,
+  _swigc__p_FXRootWindow,
+  _swigc__p_FXRuler,
+  _swigc__p_FXRulerView,
+  _swigc__p_FXScrollArea,
+  _swigc__p_FXScrollBar,
+  _swigc__p_FXScrollCorner,
+  _swigc__p_FXScrollWindow,
+  _swigc__p_FXSeparator,
+  _swigc__p_FXSettings,
+  _swigc__p_FXShell,
+  _swigc__p_FXShutter,
+  _swigc__p_FXShutterItem,
+  _swigc__p_FXSlider,
+  _swigc__p_FXSpinner,
+  _swigc__p_FXSplashWindow,
+  _swigc__p_FXSplitter,
+  _swigc__p_FXSpring,
+  _swigc__p_FXStatusBar,
+  _swigc__p_FXStatusLine,
+  _swigc__p_FXStream,
+  _swigc__p_FXStringDict,
+  _swigc__p_FXSwitcher,
+  _swigc__p_FXTabBar,
+  _swigc__p_FXTabBook,
+  _swigc__p_FXTextField,
+  _swigc__p_FXToolBar,
+  _swigc__p_FXToolBarGrip,
+  _swigc__p_FXToolBarShell,
+  _swigc__p_FXToolBarTab,
+  _swigc__p_FXToolTip,
+  _swigc__p_FXTopWindow,
+  _swigc__p_FXTranslator,
+  _swigc__p_FXTreeItem,
+  _swigc__p_FXTreeList,
+  _swigc__p_FXTreeListBox,
+  _swigc__p_FXVerticalFrame,
+  _swigc__p_FXVerticalSeparator,
+  _swigc__p_FXVisual,
+  _swigc__p_FXWindow,
+  _swigc__p_char,
+  _swigc__p_double,
+  _swigc__p_float,
+  _swigc__p_int,
+  _swigc__p_long,
+  _swigc__p_short,
+  _swigc__p_unsigned_char,
+  _swigc__p_unsigned_int,
+  _swigc__p_unsigned_long,
+  _swigc__p_unsigned_short,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned statically to an initial
+ * array. We just loop through that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded.
+ * There are three cases to handle:
+ *  1) If the cast->type has already been loaded AND the type we are adding
+ *     casting info to has not been loaded (it is in this module), THEN we
+ *     replace the cast->type pointer with the type pointer that has already
+ *     been loaded.
+ *  2) If BOTH types (the one we are adding casting info to, and the
+ *     cast->type) are loaded, THEN the cast info has already been loaded by
+ *     the previous module so we just ignore it.
+ *  3) Finally, if cast->type has not already been loaded, then we add that
+ *     swig_cast_info to the linked list (because the cast->type) pointer will
+ *     be correct.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* c-mode */
+#endif
+#endif
+
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+  size_t i;
+  swig_module_info *module_head, *iter;
+  int init;
+
+  /* check to see if the circular list has been setup, if not, set it up */
+  if (swig_module.next==0) {
+    /* Initialize the swig_module */
+    swig_module.type_initial = swig_type_initial;
+    swig_module.cast_initial = swig_cast_initial;
+    swig_module.next = &swig_module;
+    init = 1;
+  } else {
+    init = 0;
+  }
+
+  /* Try and load any already created modules */
+  module_head = SWIG_GetModule(clientdata);
+  if (!module_head) {
+    /* This is the first module loaded for this interpreter */
+    /* so set the swig module into the interpreter */
+    SWIG_SetModule(clientdata, &swig_module);
+  } else {
+    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+    iter=module_head;
+    do {
+      if (iter==&swig_module) {
+        /* Our module is already in the list, so there's nothing more to do. */
+        return;
+      }
+      iter=iter->next;
+    } while (iter!= module_head);
+
+    /* otherwise we must add our module into the list */
+    swig_module.next = module_head->next;
+    module_head->next = &swig_module;
+  }
+
+  /* When multiple interpreters are used, a module could have already been initialized in
+     a different interpreter, but not yet have a pointer in this interpreter.
+     In this case, we do not want to continue adding types... everything should be
+     set up already */
+  if (init == 0) return;
+
+  /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+  for (i = 0; i < swig_module.size; ++i) {
+    swig_type_info *type = 0;
+    swig_type_info *ret;
+    swig_cast_info *cast;
+
+#ifdef SWIGRUNTIME_DEBUG
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+
+    /* if there is another module already loaded */
+    if (swig_module.next != &swig_module) {
+      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
+    }
+    if (type) {
+      /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+      if (swig_module.type_initial[i]->clientdata) {
+	type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+      }
+    } else {
+      type = swig_module.type_initial[i];
+    }
+
+    /* Insert casting types */
+    cast = swig_module.cast_initial[i];
+    while (cast->type) {
+
+      /* Don't need to add information already in the list */
+      ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+      if (swig_module.next != &swig_module) {
+        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+      }
+      if (ret) {
+	if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+	  cast->type = ret;
+	  ret = 0;
+	} else {
+	  /* Check for casting already in the list */
+	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+	  if (!ocast) ret = 0;
+	}
+      }
+
+      if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+        if (type->cast) {
+          type->cast->prev = cast;
+          cast->next = type->cast;
+        }
+        type->cast = cast;
+      }
+      cast++;
+    }
+    /* Set entry in modules->types array equal to the type */
+    swig_module.types[i] = type;
+  }
+  swig_module.types[i] = 0;
+
+#ifdef SWIGRUNTIME_DEBUG
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+  for (i = 0; i < swig_module.size; ++i) {
+    int j = 0;
+    swig_cast_info *cast = swig_module.cast_initial[i];
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    while (cast->type) {
+      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+      cast++;
+      ++j;
+    }
+  printf("---- Total casts: %d\n",j);
+  }
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types.  It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+  size_t i;
+  swig_cast_info *equiv;
+  static int init_run = 0;
+
+  if (init_run) return;
+  init_run = 1;
+
+  for (i = 0; i < swig_module.size; i++) {
+    if (swig_module.types[i]->clientdata) {
+      equiv = swig_module.types[i]->cast;
+      while (equiv) {
+        if (!equiv->converter) {
+          if (equiv->type && !equiv->type->clientdata)
+            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+        }
+        equiv = equiv->next;
+      }
+    }
+  }
+}
+
+#ifdef __cplusplus
+#if 0
+{ /* c-mode */
+#endif
+}
+#endif
+
+/*
+
+*/
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void Init_treelist(void) {
+  size_t i;
+  
+  SWIG_InitRuntime();
+  
+  
+  SWIG_InitializeModule(0);
+  for (i = 0; i < swig_module.size; i++) {
+    SWIG_define_class(swig_module.types[i]);
+  }
+  
+  SWIG_RubyInitializeTrackings();
+  
+  
+  
+  
+  rb_define_const(mFox, "FOLDINGLIST_EXTENDEDSELECT", SWIG_From_int(static_cast< int >(FOLDINGLIST_EXTENDEDSELECT)));
+  rb_define_const(mFox, "FOLDINGLIST_SINGLESELECT", SWIG_From_int(static_cast< int >(FOLDINGLIST_SINGLESELECT)));
+  rb_define_const(mFox, "FOLDINGLIST_BROWSESELECT", SWIG_From_int(static_cast< int >(FOLDINGLIST_BROWSESELECT)));
+  rb_define_const(mFox, "FOLDINGLIST_MULTIPLESELECT", SWIG_From_int(static_cast< int >(FOLDINGLIST_MULTIPLESELECT)));
+  rb_define_const(mFox, "FOLDINGLIST_AUTOSELECT", SWIG_From_int(static_cast< int >(FOLDINGLIST_AUTOSELECT)));
+  rb_define_const(mFox, "FOLDINGLIST_SHOWS_LINES", SWIG_From_int(static_cast< int >(FOLDINGLIST_SHOWS_LINES)));
+  rb_define_const(mFox, "FOLDINGLIST_SHOWS_BOXES", SWIG_From_int(static_cast< int >(FOLDINGLIST_SHOWS_BOXES)));
+  rb_define_const(mFox, "FOLDINGLIST_ROOT_BOXES", SWIG_From_int(static_cast< int >(FOLDINGLIST_ROOT_BOXES)));
+  rb_define_const(mFox, "FOLDINGLIST_NORMAL", SWIG_From_int(static_cast< int >(FOLDINGLIST_NORMAL)));
+  
+  SwigClassFXFoldingItem.klass = rb_define_class_under(mFox, "FXFoldingItem", ((swig_class *) SWIGTYPE_p_FXObject->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXFoldingItem, (void *) &SwigClassFXFoldingItem);
+  rb_define_alloc_func(SwigClassFXFoldingItem.klass, _wrap_FXFoldingItem_allocate);
+  rb_define_method(SwigClassFXFoldingItem.klass, "initialize", VALUEFUNC(_wrap_new_FXFoldingItem), -1);
+  rb_define_const(SwigClassFXFoldingItem.klass, "SELECTED", SWIG_From_int(static_cast< int >(FXFoldingItem::SELECTED)));
+  rb_define_const(SwigClassFXFoldingItem.klass, "FOCUS", SWIG_From_int(static_cast< int >(FXFoldingItem::FOCUS)));
+  rb_define_const(SwigClassFXFoldingItem.klass, "DISABLED", SWIG_From_int(static_cast< int >(FXFoldingItem::DISABLED)));
+  rb_define_const(SwigClassFXFoldingItem.klass, "OPENED", SWIG_From_int(static_cast< int >(FXFoldingItem::OPENED)));
+  rb_define_const(SwigClassFXFoldingItem.klass, "EXPANDED", SWIG_From_int(static_cast< int >(FXFoldingItem::EXPANDED)));
+  rb_define_const(SwigClassFXFoldingItem.klass, "HASITEMS", SWIG_From_int(static_cast< int >(FXFoldingItem::HASITEMS)));
+  rb_define_const(SwigClassFXFoldingItem.klass, "DRAGGABLE", SWIG_From_int(static_cast< int >(FXFoldingItem::DRAGGABLE)));
+  rb_define_const(SwigClassFXFoldingItem.klass, "OPENICONOWNED", SWIG_From_int(static_cast< int >(FXFoldingItem::OPENICONOWNED)));
+  rb_define_const(SwigClassFXFoldingItem.klass, "CLOSEDICONOWNED", SWIG_From_int(static_cast< int >(FXFoldingItem::CLOSEDICONOWNED)));
+  rb_define_method(SwigClassFXFoldingItem.klass, "getParent", VALUEFUNC(_wrap_FXFoldingItem_getParent), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "getNext", VALUEFUNC(_wrap_FXFoldingItem_getNext), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "getPrev", VALUEFUNC(_wrap_FXFoldingItem_getPrev), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "getFirst", VALUEFUNC(_wrap_FXFoldingItem_getFirst), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "getLast", VALUEFUNC(_wrap_FXFoldingItem_getLast), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "getBelow", VALUEFUNC(_wrap_FXFoldingItem_getBelow), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "getAbove", VALUEFUNC(_wrap_FXFoldingItem_getAbove), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "getNumChildren", VALUEFUNC(_wrap_FXFoldingItem_getNumChildren), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "getText", VALUEFUNC(_wrap_FXFoldingItem_getText), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "getOpenIcon", VALUEFUNC(_wrap_FXFoldingItem_getOpenIcon), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "getClosedIcon", VALUEFUNC(_wrap_FXFoldingItem_getClosedIcon), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "setData", VALUEFUNC(_wrap_FXFoldingItem_setData), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "getData", VALUEFUNC(_wrap_FXFoldingItem_getData), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "hasFocus", VALUEFUNC(_wrap_FXFoldingItem_hasFocus), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "isSelected", VALUEFUNC(_wrap_FXFoldingItem_isSelected), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "isOpened", VALUEFUNC(_wrap_FXFoldingItem_isOpened), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "isExpanded", VALUEFUNC(_wrap_FXFoldingItem_isExpanded), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "isEnabled", VALUEFUNC(_wrap_FXFoldingItem_isEnabled), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "isDraggable", VALUEFUNC(_wrap_FXFoldingItem_isDraggable), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "hasItems?", VALUEFUNC(_wrap_FXFoldingItem_hasItemsq___), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "hasItems=", VALUEFUNC(_wrap_FXFoldingItem_hasItemse___), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "isChildOf", VALUEFUNC(_wrap_FXFoldingItem_isChildOf), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "isParentOf", VALUEFUNC(_wrap_FXFoldingItem_isParentOf), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "save", VALUEFUNC(_wrap_FXFoldingItem_save), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "load", VALUEFUNC(_wrap_FXFoldingItem_load), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "setText", VALUEFUNC(_wrap_FXFoldingItem_setText), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "setOpenIcon", VALUEFUNC(_wrap_FXFoldingItem_setOpenIcon), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "setClosedIcon", VALUEFUNC(_wrap_FXFoldingItem_setClosedIcon), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "setFocus", VALUEFUNC(_wrap_FXFoldingItem_setFocus), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "setSelected", VALUEFUNC(_wrap_FXFoldingItem_setSelected), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "setOpened", VALUEFUNC(_wrap_FXFoldingItem_setOpened), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "setExpanded", VALUEFUNC(_wrap_FXFoldingItem_setExpanded), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "setEnabled", VALUEFUNC(_wrap_FXFoldingItem_setEnabled), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "setDraggable", VALUEFUNC(_wrap_FXFoldingItem_setDraggable), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "getWidth", VALUEFUNC(_wrap_FXFoldingItem_getWidth), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "getHeight", VALUEFUNC(_wrap_FXFoldingItem_getHeight), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "create", VALUEFUNC(_wrap_FXFoldingItem_create), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "detach", VALUEFUNC(_wrap_FXFoldingItem_detach), -1);
+  rb_define_method(SwigClassFXFoldingItem.klass, "destroy", VALUEFUNC(_wrap_FXFoldingItem_destroy), -1);
+  SwigClassFXFoldingItem.mark = (void (*)(void *)) FXRbFoldingItem::markfunc;
+  SwigClassFXFoldingItem.destroy = (void (*)(void *)) FXRbFoldingItem::freefunc;
+  SwigClassFXFoldingItem.trackObjects = 0;
+  
+  SwigClassFXFoldingList.klass = rb_define_class_under(mFox, "FXFoldingList", ((swig_class *) SWIGTYPE_p_FXScrollArea->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXFoldingList, (void *) &SwigClassFXFoldingList);
+  rb_define_alloc_func(SwigClassFXFoldingList.klass, _wrap_FXFoldingList_allocate);
+  rb_define_method(SwigClassFXFoldingList.klass, "initialize", VALUEFUNC(_wrap_new_FXFoldingList), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "onPaint", VALUEFUNC(_wrap_FXFoldingList_onPaint), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "onEnter", VALUEFUNC(_wrap_FXFoldingList_onEnter), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "onLeave", VALUEFUNC(_wrap_FXFoldingList_onLeave), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "onUngrabbed", VALUEFUNC(_wrap_FXFoldingList_onUngrabbed), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "onMotion", VALUEFUNC(_wrap_FXFoldingList_onMotion), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "onKeyPress", VALUEFUNC(_wrap_FXFoldingList_onKeyPress), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "onKeyRelease", VALUEFUNC(_wrap_FXFoldingList_onKeyRelease), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXFoldingList_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXFoldingList_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "onRightBtnPress", VALUEFUNC(_wrap_FXFoldingList_onRightBtnPress), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "onRightBtnRelease", VALUEFUNC(_wrap_FXFoldingList_onRightBtnRelease), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "onHeaderChanged", VALUEFUNC(_wrap_FXFoldingList_onHeaderChanged), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "onQueryTip", VALUEFUNC(_wrap_FXFoldingList_onQueryTip), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "onQueryHelp", VALUEFUNC(_wrap_FXFoldingList_onQueryHelp), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "onTipTimer", VALUEFUNC(_wrap_FXFoldingList_onTipTimer), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "onFocusIn", VALUEFUNC(_wrap_FXFoldingList_onFocusIn), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "onFocusOut", VALUEFUNC(_wrap_FXFoldingList_onFocusOut), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "onAutoScroll", VALUEFUNC(_wrap_FXFoldingList_onAutoScroll), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "onClicked", VALUEFUNC(_wrap_FXFoldingList_onClicked), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "onDoubleClicked", VALUEFUNC(_wrap_FXFoldingList_onDoubleClicked), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "onTripleClicked", VALUEFUNC(_wrap_FXFoldingList_onTripleClicked), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "onCommand", VALUEFUNC(_wrap_FXFoldingList_onCommand), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "onLookupTimer", VALUEFUNC(_wrap_FXFoldingList_onLookupTimer), -1);
+  rb_define_singleton_method(SwigClassFXFoldingList.klass, "ascending", VALUEFUNC(_wrap_FXFoldingList_ascending), -1);
+  rb_define_singleton_method(SwigClassFXFoldingList.klass, "descending", VALUEFUNC(_wrap_FXFoldingList_descending), -1);
+  rb_define_singleton_method(SwigClassFXFoldingList.klass, "ascendingCase", VALUEFUNC(_wrap_FXFoldingList_ascendingCase), -1);
+  rb_define_singleton_method(SwigClassFXFoldingList.klass, "descendingCase", VALUEFUNC(_wrap_FXFoldingList_descendingCase), -1);
+  rb_define_const(SwigClassFXFoldingList.klass, "ID_LOOKUPTIMER", SWIG_From_int(static_cast< int >(FXFoldingList::ID_LOOKUPTIMER)));
+  rb_define_const(SwigClassFXFoldingList.klass, "ID_HEADER_CHANGE", SWIG_From_int(static_cast< int >(FXFoldingList::ID_HEADER_CHANGE)));
+  rb_define_const(SwigClassFXFoldingList.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXFoldingList::ID_LAST)));
+  rb_define_method(SwigClassFXFoldingList.klass, "getHeader", VALUEFUNC(_wrap_FXFoldingList_getHeader), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setHeaders", VALUEFUNC(_wrap_FXFoldingList_setHeaders), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "appendHeader", VALUEFUNC(_wrap_FXFoldingList_appendHeader), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "removeHeader", VALUEFUNC(_wrap_FXFoldingList_removeHeader), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setHeaderText", VALUEFUNC(_wrap_FXFoldingList_setHeaderText), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getHeaderText", VALUEFUNC(_wrap_FXFoldingList_getHeaderText), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setHeaderIcon", VALUEFUNC(_wrap_FXFoldingList_setHeaderIcon), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getHeaderIcon", VALUEFUNC(_wrap_FXFoldingList_getHeaderIcon), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setHeaderSize", VALUEFUNC(_wrap_FXFoldingList_setHeaderSize), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getHeaderSize", VALUEFUNC(_wrap_FXFoldingList_getHeaderSize), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getNumHeaders", VALUEFUNC(_wrap_FXFoldingList_getNumHeaders), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getNumItems", VALUEFUNC(_wrap_FXFoldingList_getNumItems), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getNumVisible", VALUEFUNC(_wrap_FXFoldingList_getNumVisible), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setNumVisible", VALUEFUNC(_wrap_FXFoldingList_setNumVisible), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getFirstItem", VALUEFUNC(_wrap_FXFoldingList_getFirstItem), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getLastItem", VALUEFUNC(_wrap_FXFoldingList_getLastItem), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "fillItems", VALUEFUNC(_wrap_FXFoldingList_fillItems), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "insertItem", VALUEFUNC(_wrap_FXFoldingList_insertItem), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "appendItem", VALUEFUNC(_wrap_FXFoldingList_appendItem), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "prependItem", VALUEFUNC(_wrap_FXFoldingList_prependItem), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "moveItem", VALUEFUNC(_wrap_FXFoldingList_moveItem), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "extractItem", VALUEFUNC(_wrap_FXFoldingList_extractItem), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "removeItem", VALUEFUNC(_wrap_FXFoldingList_removeItem), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "removeItems", VALUEFUNC(_wrap_FXFoldingList_removeItems), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "clearItems", VALUEFUNC(_wrap_FXFoldingList_clearItems), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getItemWidth", VALUEFUNC(_wrap_FXFoldingList_getItemWidth), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getItemHeight", VALUEFUNC(_wrap_FXFoldingList_getItemHeight), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "findItem", VALUEFUNC(_wrap_FXFoldingList_findItem), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "findItemByData", VALUEFUNC(_wrap_FXFoldingList_findItemByData), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setItemText", VALUEFUNC(_wrap_FXFoldingList_setItemText), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getItemText", VALUEFUNC(_wrap_FXFoldingList_getItemText), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setItemOpenIcon", VALUEFUNC(_wrap_FXFoldingList_setItemOpenIcon), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getItemOpenIcon", VALUEFUNC(_wrap_FXFoldingList_getItemOpenIcon), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setItemClosedIcon", VALUEFUNC(_wrap_FXFoldingList_setItemClosedIcon), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getItemClosedIcon", VALUEFUNC(_wrap_FXFoldingList_getItemClosedIcon), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setItemData", VALUEFUNC(_wrap_FXFoldingList_setItemData), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getItemData", VALUEFUNC(_wrap_FXFoldingList_getItemData), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "isItemSelected", VALUEFUNC(_wrap_FXFoldingList_isItemSelected), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "isItemCurrent", VALUEFUNC(_wrap_FXFoldingList_isItemCurrent), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "isItemVisible", VALUEFUNC(_wrap_FXFoldingList_isItemVisible), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "isItemOpened", VALUEFUNC(_wrap_FXFoldingList_isItemOpened), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "isItemExpanded", VALUEFUNC(_wrap_FXFoldingList_isItemExpanded), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "isItemLeaf", VALUEFUNC(_wrap_FXFoldingList_isItemLeaf), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "isItemEnabled", VALUEFUNC(_wrap_FXFoldingList_isItemEnabled), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "hitItem", VALUEFUNC(_wrap_FXFoldingList_hitItem), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "updateItem", VALUEFUNC(_wrap_FXFoldingList_updateItem), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getCurrentItem", VALUEFUNC(_wrap_FXFoldingList_getCurrentItem), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setAnchorItem", VALUEFUNC(_wrap_FXFoldingList_setAnchorItem), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getAnchorItem", VALUEFUNC(_wrap_FXFoldingList_getAnchorItem), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getCursorItem", VALUEFUNC(_wrap_FXFoldingList_getCursorItem), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "sortItems", VALUEFUNC(_wrap_FXFoldingList_sortItems), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "sortRootItems", VALUEFUNC(_wrap_FXFoldingList_sortRootItems), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "sortChildItems", VALUEFUNC(_wrap_FXFoldingList_sortChildItems), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getSortFunc", VALUEFUNC(_wrap_FXFoldingList_getSortFunc), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setSortFunc", VALUEFUNC(_wrap_FXFoldingList_setSortFunc), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setFont", VALUEFUNC(_wrap_FXFoldingList_setFont), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getFont", VALUEFUNC(_wrap_FXFoldingList_getFont), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setIndent", VALUEFUNC(_wrap_FXFoldingList_setIndent), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getIndent", VALUEFUNC(_wrap_FXFoldingList_getIndent), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getTextColor", VALUEFUNC(_wrap_FXFoldingList_getTextColor), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setTextColor", VALUEFUNC(_wrap_FXFoldingList_setTextColor), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getSelBackColor", VALUEFUNC(_wrap_FXFoldingList_getSelBackColor), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setSelBackColor", VALUEFUNC(_wrap_FXFoldingList_setSelBackColor), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getSelTextColor", VALUEFUNC(_wrap_FXFoldingList_getSelTextColor), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setSelTextColor", VALUEFUNC(_wrap_FXFoldingList_setSelTextColor), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getLineColor", VALUEFUNC(_wrap_FXFoldingList_getLineColor), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setLineColor", VALUEFUNC(_wrap_FXFoldingList_setLineColor), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getListStyle", VALUEFUNC(_wrap_FXFoldingList_getListStyle), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setListStyle", VALUEFUNC(_wrap_FXFoldingList_setListStyle), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setHelpText", VALUEFUNC(_wrap_FXFoldingList_setHelpText), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getHelpText", VALUEFUNC(_wrap_FXFoldingList_getHelpText), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "save", VALUEFUNC(_wrap_FXFoldingList_save), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "load", VALUEFUNC(_wrap_FXFoldingList_load), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "create", VALUEFUNC(_wrap_FXFoldingList_create), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "detach", VALUEFUNC(_wrap_FXFoldingList_detach), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "destroy", VALUEFUNC(_wrap_FXFoldingList_destroy), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "resize", VALUEFUNC(_wrap_FXFoldingList_resize), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXFoldingList_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXFoldingList_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXFoldingList_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXFoldingList_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "canFocus", VALUEFUNC(_wrap_FXFoldingList_canFocus), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setFocus", VALUEFUNC(_wrap_FXFoldingList_setFocus), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "killFocus", VALUEFUNC(_wrap_FXFoldingList_killFocus), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "changeFocus", VALUEFUNC(_wrap_FXFoldingList_changeFocus), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setDefault", VALUEFUNC(_wrap_FXFoldingList_setDefault), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "enable", VALUEFUNC(_wrap_FXFoldingList_enable), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "disable", VALUEFUNC(_wrap_FXFoldingList_disable), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "raiseWindow", VALUEFUNC(_wrap_FXFoldingList_raiseWindow), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "lower", VALUEFUNC(_wrap_FXFoldingList_lower), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "move", VALUEFUNC(_wrap_FXFoldingList_move), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "layout", VALUEFUNC(_wrap_FXFoldingList_layout), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "recalc", VALUEFUNC(_wrap_FXFoldingList_recalc), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "reparent", VALUEFUNC(_wrap_FXFoldingList_reparent), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "show", VALUEFUNC(_wrap_FXFoldingList_show), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "hide", VALUEFUNC(_wrap_FXFoldingList_hide), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "isComposite", VALUEFUNC(_wrap_FXFoldingList_isComposite), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "contains", VALUEFUNC(_wrap_FXFoldingList_contains), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXFoldingList_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setBackColor", VALUEFUNC(_wrap_FXFoldingList_setBackColor), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "tr", VALUEFUNC(_wrap_FXFoldingList_tr), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "dropEnable", VALUEFUNC(_wrap_FXFoldingList_dropEnable), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "dropDisable", VALUEFUNC(_wrap_FXFoldingList_dropDisable), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setShape", VALUEFUNC(_wrap_FXFoldingList_setShape), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "clearShape", VALUEFUNC(_wrap_FXFoldingList_clearShape), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getViewportHeight", VALUEFUNC(_wrap_FXFoldingList_getViewportHeight), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getViewportWidth", VALUEFUNC(_wrap_FXFoldingList_getViewportWidth), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getContentHeight", VALUEFUNC(_wrap_FXFoldingList_getContentHeight), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getContentWidth", VALUEFUNC(_wrap_FXFoldingList_getContentWidth), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "position", VALUEFUNC(_wrap_FXFoldingList_position), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "getItemAt", VALUEFUNC(_wrap_FXFoldingList_getItemAt), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "makeItemVisible", VALUEFUNC(_wrap_FXFoldingList_makeItemVisible), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "enableItem", VALUEFUNC(_wrap_FXFoldingList_enableItem), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "disableItem", VALUEFUNC(_wrap_FXFoldingList_disableItem), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "selectItem", VALUEFUNC(_wrap_FXFoldingList_selectItem), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "deselectItem", VALUEFUNC(_wrap_FXFoldingList_deselectItem), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "toggleItem", VALUEFUNC(_wrap_FXFoldingList_toggleItem), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "extendSelection", VALUEFUNC(_wrap_FXFoldingList_extendSelection), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "killSelection", VALUEFUNC(_wrap_FXFoldingList_killSelection), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "openItem", VALUEFUNC(_wrap_FXFoldingList_openItem), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "closeItem", VALUEFUNC(_wrap_FXFoldingList_closeItem), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "collapseTree", VALUEFUNC(_wrap_FXFoldingList_collapseTree), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "expandTree", VALUEFUNC(_wrap_FXFoldingList_expandTree), -1);
+  rb_define_method(SwigClassFXFoldingList.klass, "setCurrentItem", VALUEFUNC(_wrap_FXFoldingList_setCurrentItem), -1);
+  SwigClassFXFoldingList.mark = (void (*)(void *)) FXRbFoldingList::markfunc;
+  SwigClassFXFoldingList.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXFoldingList.trackObjects = 0;
+  rb_define_const(mFox, "TREELIST_EXTENDEDSELECT", SWIG_From_int(static_cast< int >(TREELIST_EXTENDEDSELECT)));
+  rb_define_const(mFox, "TREELIST_SINGLESELECT", SWIG_From_int(static_cast< int >(TREELIST_SINGLESELECT)));
+  rb_define_const(mFox, "TREELIST_BROWSESELECT", SWIG_From_int(static_cast< int >(TREELIST_BROWSESELECT)));
+  rb_define_const(mFox, "TREELIST_MULTIPLESELECT", SWIG_From_int(static_cast< int >(TREELIST_MULTIPLESELECT)));
+  rb_define_const(mFox, "TREELIST_AUTOSELECT", SWIG_From_int(static_cast< int >(TREELIST_AUTOSELECT)));
+  rb_define_const(mFox, "TREELIST_SHOWS_LINES", SWIG_From_int(static_cast< int >(TREELIST_SHOWS_LINES)));
+  rb_define_const(mFox, "TREELIST_SHOWS_BOXES", SWIG_From_int(static_cast< int >(TREELIST_SHOWS_BOXES)));
+  rb_define_const(mFox, "TREELIST_ROOT_BOXES", SWIG_From_int(static_cast< int >(TREELIST_ROOT_BOXES)));
+  rb_define_const(mFox, "TREELIST_NORMAL", SWIG_From_int(static_cast< int >(TREELIST_NORMAL)));
+  
+  SwigClassFXTreeItem.klass = rb_define_class_under(mFox, "FXTreeItem", ((swig_class *) SWIGTYPE_p_FXObject->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXTreeItem, (void *) &SwigClassFXTreeItem);
+  rb_define_alloc_func(SwigClassFXTreeItem.klass, _wrap_FXTreeItem_allocate);
+  rb_define_method(SwigClassFXTreeItem.klass, "initialize", VALUEFUNC(_wrap_new_FXTreeItem), -1);
+  rb_define_const(SwigClassFXTreeItem.klass, "SELECTED", SWIG_From_int(static_cast< int >(FXTreeItem::SELECTED)));
+  rb_define_const(SwigClassFXTreeItem.klass, "FOCUS", SWIG_From_int(static_cast< int >(FXTreeItem::FOCUS)));
+  rb_define_const(SwigClassFXTreeItem.klass, "DISABLED", SWIG_From_int(static_cast< int >(FXTreeItem::DISABLED)));
+  rb_define_const(SwigClassFXTreeItem.klass, "OPENED", SWIG_From_int(static_cast< int >(FXTreeItem::OPENED)));
+  rb_define_const(SwigClassFXTreeItem.klass, "EXPANDED", SWIG_From_int(static_cast< int >(FXTreeItem::EXPANDED)));
+  rb_define_const(SwigClassFXTreeItem.klass, "HASITEMS", SWIG_From_int(static_cast< int >(FXTreeItem::HASITEMS)));
+  rb_define_const(SwigClassFXTreeItem.klass, "DRAGGABLE", SWIG_From_int(static_cast< int >(FXTreeItem::DRAGGABLE)));
+  rb_define_const(SwigClassFXTreeItem.klass, "OPENICONOWNED", SWIG_From_int(static_cast< int >(FXTreeItem::OPENICONOWNED)));
+  rb_define_const(SwigClassFXTreeItem.klass, "CLOSEDICONOWNED", SWIG_From_int(static_cast< int >(FXTreeItem::CLOSEDICONOWNED)));
+  rb_define_method(SwigClassFXTreeItem.klass, "getText", VALUEFUNC(_wrap_FXTreeItem_getText), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "getOpenIcon", VALUEFUNC(_wrap_FXTreeItem_getOpenIcon), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "getClosedIcon", VALUEFUNC(_wrap_FXTreeItem_getClosedIcon), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "getParent", VALUEFUNC(_wrap_FXTreeItem_getParent), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "getNext", VALUEFUNC(_wrap_FXTreeItem_getNext), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "getPrev", VALUEFUNC(_wrap_FXTreeItem_getPrev), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "getFirst", VALUEFUNC(_wrap_FXTreeItem_getFirst), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "getLast", VALUEFUNC(_wrap_FXTreeItem_getLast), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "getBelow", VALUEFUNC(_wrap_FXTreeItem_getBelow), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "getAbove", VALUEFUNC(_wrap_FXTreeItem_getAbove), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "getNumChildren", VALUEFUNC(_wrap_FXTreeItem_getNumChildren), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "setData", VALUEFUNC(_wrap_FXTreeItem_setData), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "getData", VALUEFUNC(_wrap_FXTreeItem_getData), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "hasFocus", VALUEFUNC(_wrap_FXTreeItem_hasFocus), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "isSelected", VALUEFUNC(_wrap_FXTreeItem_isSelected), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "isOpened", VALUEFUNC(_wrap_FXTreeItem_isOpened), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "isExpanded", VALUEFUNC(_wrap_FXTreeItem_isExpanded), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "isEnabled", VALUEFUNC(_wrap_FXTreeItem_isEnabled), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "isDraggable", VALUEFUNC(_wrap_FXTreeItem_isDraggable), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "hasItems?", VALUEFUNC(_wrap_FXTreeItem_hasItemsq___), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "hasItems=", VALUEFUNC(_wrap_FXTreeItem_hasItemse___), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "isChildOf", VALUEFUNC(_wrap_FXTreeItem_isChildOf), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "isParentOf", VALUEFUNC(_wrap_FXTreeItem_isParentOf), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "save", VALUEFUNC(_wrap_FXTreeItem_save), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "load", VALUEFUNC(_wrap_FXTreeItem_load), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "setText", VALUEFUNC(_wrap_FXTreeItem_setText), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "setOpenIcon", VALUEFUNC(_wrap_FXTreeItem_setOpenIcon), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "setClosedIcon", VALUEFUNC(_wrap_FXTreeItem_setClosedIcon), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "setFocus", VALUEFUNC(_wrap_FXTreeItem_setFocus), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "setSelected", VALUEFUNC(_wrap_FXTreeItem_setSelected), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "setOpened", VALUEFUNC(_wrap_FXTreeItem_setOpened), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "setExpanded", VALUEFUNC(_wrap_FXTreeItem_setExpanded), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "setEnabled", VALUEFUNC(_wrap_FXTreeItem_setEnabled), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "setDraggable", VALUEFUNC(_wrap_FXTreeItem_setDraggable), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "getWidth", VALUEFUNC(_wrap_FXTreeItem_getWidth), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "getHeight", VALUEFUNC(_wrap_FXTreeItem_getHeight), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "create", VALUEFUNC(_wrap_FXTreeItem_create), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "detach", VALUEFUNC(_wrap_FXTreeItem_detach), -1);
+  rb_define_method(SwigClassFXTreeItem.klass, "destroy", VALUEFUNC(_wrap_FXTreeItem_destroy), -1);
+  SwigClassFXTreeItem.mark = (void (*)(void *)) FXRbTreeItem::markfunc;
+  SwigClassFXTreeItem.destroy = (void (*)(void *)) FXRbTreeItem::freefunc;
+  SwigClassFXTreeItem.trackObjects = 0;
+  
+  SWIGTYPE_p_FXTreeItem->dcast = (swig_dycast_func) FXTreeItem_dynamic_cast;
+  
+  
+  SwigClassFXTreeList.klass = rb_define_class_under(mFox, "FXTreeList", ((swig_class *) SWIGTYPE_p_FXScrollArea->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXTreeList, (void *) &SwigClassFXTreeList);
+  rb_define_alloc_func(SwigClassFXTreeList.klass, _wrap_FXTreeList_allocate);
+  rb_define_method(SwigClassFXTreeList.klass, "initialize", VALUEFUNC(_wrap_new_FXTreeList), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "onPaint", VALUEFUNC(_wrap_FXTreeList_onPaint), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "onEnter", VALUEFUNC(_wrap_FXTreeList_onEnter), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "onLeave", VALUEFUNC(_wrap_FXTreeList_onLeave), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "onUngrabbed", VALUEFUNC(_wrap_FXTreeList_onUngrabbed), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "onMotion", VALUEFUNC(_wrap_FXTreeList_onMotion), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "onKeyPress", VALUEFUNC(_wrap_FXTreeList_onKeyPress), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "onKeyRelease", VALUEFUNC(_wrap_FXTreeList_onKeyRelease), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXTreeList_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXTreeList_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "onRightBtnPress", VALUEFUNC(_wrap_FXTreeList_onRightBtnPress), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "onRightBtnRelease", VALUEFUNC(_wrap_FXTreeList_onRightBtnRelease), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "onQueryTip", VALUEFUNC(_wrap_FXTreeList_onQueryTip), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "onQueryHelp", VALUEFUNC(_wrap_FXTreeList_onQueryHelp), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "onTipTimer", VALUEFUNC(_wrap_FXTreeList_onTipTimer), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "onFocusIn", VALUEFUNC(_wrap_FXTreeList_onFocusIn), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "onFocusOut", VALUEFUNC(_wrap_FXTreeList_onFocusOut), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "onAutoScroll", VALUEFUNC(_wrap_FXTreeList_onAutoScroll), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "onClicked", VALUEFUNC(_wrap_FXTreeList_onClicked), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "onDoubleClicked", VALUEFUNC(_wrap_FXTreeList_onDoubleClicked), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "onTripleClicked", VALUEFUNC(_wrap_FXTreeList_onTripleClicked), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "onCommand", VALUEFUNC(_wrap_FXTreeList_onCommand), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "onLookupTimer", VALUEFUNC(_wrap_FXTreeList_onLookupTimer), -1);
+  rb_define_singleton_method(SwigClassFXTreeList.klass, "ascending", VALUEFUNC(_wrap_FXTreeList_ascending), -1);
+  rb_define_singleton_method(SwigClassFXTreeList.klass, "descending", VALUEFUNC(_wrap_FXTreeList_descending), -1);
+  rb_define_singleton_method(SwigClassFXTreeList.klass, "ascendingCase", VALUEFUNC(_wrap_FXTreeList_ascendingCase), -1);
+  rb_define_singleton_method(SwigClassFXTreeList.klass, "descendingCase", VALUEFUNC(_wrap_FXTreeList_descendingCase), -1);
+  rb_define_const(SwigClassFXTreeList.klass, "ID_LOOKUPTIMER", SWIG_From_int(static_cast< int >(FXTreeList::ID_LOOKUPTIMER)));
+  rb_define_const(SwigClassFXTreeList.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXTreeList::ID_LAST)));
+  rb_define_method(SwigClassFXTreeList.klass, "getNumItems", VALUEFUNC(_wrap_FXTreeList_getNumItems), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getNumVisible", VALUEFUNC(_wrap_FXTreeList_getNumVisible), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "setNumVisible", VALUEFUNC(_wrap_FXTreeList_setNumVisible), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getFirstItem", VALUEFUNC(_wrap_FXTreeList_getFirstItem), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getLastItem", VALUEFUNC(_wrap_FXTreeList_getLastItem), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "fillItems", VALUEFUNC(_wrap_FXTreeList_fillItems), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "insertItem", VALUEFUNC(_wrap_FXTreeList_insertItem), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "appendItem", VALUEFUNC(_wrap_FXTreeList_appendItem), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "prependItem", VALUEFUNC(_wrap_FXTreeList_prependItem), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "moveItem", VALUEFUNC(_wrap_FXTreeList_moveItem), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "extractItem", VALUEFUNC(_wrap_FXTreeList_extractItem), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "removeItem", VALUEFUNC(_wrap_FXTreeList_removeItem), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "removeItems", VALUEFUNC(_wrap_FXTreeList_removeItems), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "clearItems", VALUEFUNC(_wrap_FXTreeList_clearItems), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getItemWidth", VALUEFUNC(_wrap_FXTreeList_getItemWidth), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getItemHeight", VALUEFUNC(_wrap_FXTreeList_getItemHeight), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "findItem", VALUEFUNC(_wrap_FXTreeList_findItem), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "findItemByData", VALUEFUNC(_wrap_FXTreeList_findItemByData), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "setItemText", VALUEFUNC(_wrap_FXTreeList_setItemText), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getItemText", VALUEFUNC(_wrap_FXTreeList_getItemText), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "setItemOpenIcon", VALUEFUNC(_wrap_FXTreeList_setItemOpenIcon), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getItemOpenIcon", VALUEFUNC(_wrap_FXTreeList_getItemOpenIcon), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "setItemClosedIcon", VALUEFUNC(_wrap_FXTreeList_setItemClosedIcon), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getItemClosedIcon", VALUEFUNC(_wrap_FXTreeList_getItemClosedIcon), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "setItemData", VALUEFUNC(_wrap_FXTreeList_setItemData), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getItemData", VALUEFUNC(_wrap_FXTreeList_getItemData), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "isItemSelected", VALUEFUNC(_wrap_FXTreeList_isItemSelected), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "isItemCurrent", VALUEFUNC(_wrap_FXTreeList_isItemCurrent), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "isItemVisible", VALUEFUNC(_wrap_FXTreeList_isItemVisible), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "isItemOpened", VALUEFUNC(_wrap_FXTreeList_isItemOpened), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "isItemExpanded", VALUEFUNC(_wrap_FXTreeList_isItemExpanded), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "isItemLeaf", VALUEFUNC(_wrap_FXTreeList_isItemLeaf), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "isItemEnabled", VALUEFUNC(_wrap_FXTreeList_isItemEnabled), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "hitItem", VALUEFUNC(_wrap_FXTreeList_hitItem), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "updateItem", VALUEFUNC(_wrap_FXTreeList_updateItem), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getCurrentItem", VALUEFUNC(_wrap_FXTreeList_getCurrentItem), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "setAnchorItem", VALUEFUNC(_wrap_FXTreeList_setAnchorItem), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getAnchorItem", VALUEFUNC(_wrap_FXTreeList_getAnchorItem), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getCursorItem", VALUEFUNC(_wrap_FXTreeList_getCursorItem), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "sortRootItems", VALUEFUNC(_wrap_FXTreeList_sortRootItems), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "sortItems", VALUEFUNC(_wrap_FXTreeList_sortItems), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "sortChildItems", VALUEFUNC(_wrap_FXTreeList_sortChildItems), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "setFont", VALUEFUNC(_wrap_FXTreeList_setFont), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getFont", VALUEFUNC(_wrap_FXTreeList_getFont), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "setIndent", VALUEFUNC(_wrap_FXTreeList_setIndent), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getIndent", VALUEFUNC(_wrap_FXTreeList_getIndent), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getTextColor", VALUEFUNC(_wrap_FXTreeList_getTextColor), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "setTextColor", VALUEFUNC(_wrap_FXTreeList_setTextColor), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getSelBackColor", VALUEFUNC(_wrap_FXTreeList_getSelBackColor), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "setSelBackColor", VALUEFUNC(_wrap_FXTreeList_setSelBackColor), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getSelTextColor", VALUEFUNC(_wrap_FXTreeList_getSelTextColor), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "setSelTextColor", VALUEFUNC(_wrap_FXTreeList_setSelTextColor), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getLineColor", VALUEFUNC(_wrap_FXTreeList_getLineColor), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "setLineColor", VALUEFUNC(_wrap_FXTreeList_setLineColor), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getListStyle", VALUEFUNC(_wrap_FXTreeList_getListStyle), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "setListStyle", VALUEFUNC(_wrap_FXTreeList_setListStyle), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "setHelpText", VALUEFUNC(_wrap_FXTreeList_setHelpText), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getHelpText", VALUEFUNC(_wrap_FXTreeList_getHelpText), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "save", VALUEFUNC(_wrap_FXTreeList_save), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "load", VALUEFUNC(_wrap_FXTreeList_load), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "create", VALUEFUNC(_wrap_FXTreeList_create), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "detach", VALUEFUNC(_wrap_FXTreeList_detach), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "destroy", VALUEFUNC(_wrap_FXTreeList_destroy), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "resize", VALUEFUNC(_wrap_FXTreeList_resize), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXTreeList_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXTreeList_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXTreeList_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXTreeList_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "canFocus", VALUEFUNC(_wrap_FXTreeList_canFocus), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "setFocus", VALUEFUNC(_wrap_FXTreeList_setFocus), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "killFocus", VALUEFUNC(_wrap_FXTreeList_killFocus), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "changeFocus", VALUEFUNC(_wrap_FXTreeList_changeFocus), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "setDefault", VALUEFUNC(_wrap_FXTreeList_setDefault), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "enable", VALUEFUNC(_wrap_FXTreeList_enable), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "disable", VALUEFUNC(_wrap_FXTreeList_disable), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "raiseWindow", VALUEFUNC(_wrap_FXTreeList_raiseWindow), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "lower", VALUEFUNC(_wrap_FXTreeList_lower), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "move", VALUEFUNC(_wrap_FXTreeList_move), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "layout", VALUEFUNC(_wrap_FXTreeList_layout), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "recalc", VALUEFUNC(_wrap_FXTreeList_recalc), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "reparent", VALUEFUNC(_wrap_FXTreeList_reparent), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "show", VALUEFUNC(_wrap_FXTreeList_show), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "hide", VALUEFUNC(_wrap_FXTreeList_hide), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "isComposite", VALUEFUNC(_wrap_FXTreeList_isComposite), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "contains", VALUEFUNC(_wrap_FXTreeList_contains), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXTreeList_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "setBackColor", VALUEFUNC(_wrap_FXTreeList_setBackColor), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "tr", VALUEFUNC(_wrap_FXTreeList_tr), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "dropEnable", VALUEFUNC(_wrap_FXTreeList_dropEnable), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "dropDisable", VALUEFUNC(_wrap_FXTreeList_dropDisable), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "setShape", VALUEFUNC(_wrap_FXTreeList_setShape), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "clearShape", VALUEFUNC(_wrap_FXTreeList_clearShape), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getViewportHeight", VALUEFUNC(_wrap_FXTreeList_getViewportHeight), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getViewportWidth", VALUEFUNC(_wrap_FXTreeList_getViewportWidth), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getContentHeight", VALUEFUNC(_wrap_FXTreeList_getContentHeight), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getContentWidth", VALUEFUNC(_wrap_FXTreeList_getContentWidth), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "position", VALUEFUNC(_wrap_FXTreeList_position), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "selectItem", VALUEFUNC(_wrap_FXTreeList_selectItem), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "deselectItem", VALUEFUNC(_wrap_FXTreeList_deselectItem), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "toggleItem", VALUEFUNC(_wrap_FXTreeList_toggleItem), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "extendSelection", VALUEFUNC(_wrap_FXTreeList_extendSelection), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "killSelection", VALUEFUNC(_wrap_FXTreeList_killSelection), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "openItem", VALUEFUNC(_wrap_FXTreeList_openItem), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "closeItem", VALUEFUNC(_wrap_FXTreeList_closeItem), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "collapseTree", VALUEFUNC(_wrap_FXTreeList_collapseTree), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "expandTree", VALUEFUNC(_wrap_FXTreeList_expandTree), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "setCurrentItem", VALUEFUNC(_wrap_FXTreeList_setCurrentItem), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "getItemAt", VALUEFUNC(_wrap_FXTreeList_getItemAt), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "makeItemVisible", VALUEFUNC(_wrap_FXTreeList_makeItemVisible), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "enableItem", VALUEFUNC(_wrap_FXTreeList_enableItem), -1);
+  rb_define_method(SwigClassFXTreeList.klass, "disableItem", VALUEFUNC(_wrap_FXTreeList_disableItem), -1);
+  SwigClassFXTreeList.mark = (void (*)(void *)) FXRbTreeList::markfunc;
+  SwigClassFXTreeList.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXTreeList.trackObjects = 0;
+  
+  SWIGTYPE_p_FXTreeList->dcast = (swig_dycast_func) FXTreeList_dynamic_cast;
+  
+  rb_define_const(mFox, "DIRLIST_SHOWFILES", SWIG_From_int(static_cast< int >(DIRLIST_SHOWFILES)));
+  rb_define_const(mFox, "DIRLIST_SHOWHIDDEN", SWIG_From_int(static_cast< int >(DIRLIST_SHOWHIDDEN)));
+  rb_define_const(mFox, "DIRLIST_NO_OWN_ASSOC", SWIG_From_int(static_cast< int >(DIRLIST_NO_OWN_ASSOC)));
+  
+  SwigClassFXDirItem.klass = rb_define_class_under(mFox, "FXDirItem", ((swig_class *) SWIGTYPE_p_FXTreeItem->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXDirItem, (void *) &SwigClassFXDirItem);
+  rb_define_alloc_func(SwigClassFXDirItem.klass, _wrap_FXDirItem_allocate);
+  rb_define_method(SwigClassFXDirItem.klass, "initialize", VALUEFUNC(_wrap_new_FXDirItem), -1);
+  rb_define_const(SwigClassFXDirItem.klass, "FOLDER", SWIG_From_int(static_cast< int >(FXDirItem::FOLDER)));
+  rb_define_const(SwigClassFXDirItem.klass, "EXECUTABLE", SWIG_From_int(static_cast< int >(FXDirItem::EXECUTABLE)));
+  rb_define_const(SwigClassFXDirItem.klass, "SYMLINK", SWIG_From_int(static_cast< int >(FXDirItem::SYMLINK)));
+  rb_define_const(SwigClassFXDirItem.klass, "CHARDEV", SWIG_From_int(static_cast< int >(FXDirItem::CHARDEV)));
+  rb_define_const(SwigClassFXDirItem.klass, "BLOCKDEV", SWIG_From_int(static_cast< int >(FXDirItem::BLOCKDEV)));
+  rb_define_const(SwigClassFXDirItem.klass, "FIFO", SWIG_From_int(static_cast< int >(FXDirItem::FIFO)));
+  rb_define_const(SwigClassFXDirItem.klass, "SOCK", SWIG_From_int(static_cast< int >(FXDirItem::SOCK)));
+  rb_define_method(SwigClassFXDirItem.klass, "isFile", VALUEFUNC(_wrap_FXDirItem_isFile), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "isDirectory", VALUEFUNC(_wrap_FXDirItem_isDirectory), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "isExecutable", VALUEFUNC(_wrap_FXDirItem_isExecutable), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "isSymlink", VALUEFUNC(_wrap_FXDirItem_isSymlink), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "isChardev", VALUEFUNC(_wrap_FXDirItem_isChardev), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "isBlockdev", VALUEFUNC(_wrap_FXDirItem_isBlockdev), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "isFifo", VALUEFUNC(_wrap_FXDirItem_isFifo), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "isSocket", VALUEFUNC(_wrap_FXDirItem_isSocket), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "getAssoc", VALUEFUNC(_wrap_FXDirItem_getAssoc), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "getSize", VALUEFUNC(_wrap_FXDirItem_getSize), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "getDate", VALUEFUNC(_wrap_FXDirItem_getDate), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "save", VALUEFUNC(_wrap_FXDirItem_save), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "load", VALUEFUNC(_wrap_FXDirItem_load), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "setText", VALUEFUNC(_wrap_FXDirItem_setText), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "setOpenIcon", VALUEFUNC(_wrap_FXDirItem_setOpenIcon), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "setClosedIcon", VALUEFUNC(_wrap_FXDirItem_setClosedIcon), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "setFocus", VALUEFUNC(_wrap_FXDirItem_setFocus), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "setSelected", VALUEFUNC(_wrap_FXDirItem_setSelected), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "setOpened", VALUEFUNC(_wrap_FXDirItem_setOpened), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "setExpanded", VALUEFUNC(_wrap_FXDirItem_setExpanded), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "setEnabled", VALUEFUNC(_wrap_FXDirItem_setEnabled), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "setDraggable", VALUEFUNC(_wrap_FXDirItem_setDraggable), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "getWidth", VALUEFUNC(_wrap_FXDirItem_getWidth), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "getHeight", VALUEFUNC(_wrap_FXDirItem_getHeight), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "create", VALUEFUNC(_wrap_FXDirItem_create), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "detach", VALUEFUNC(_wrap_FXDirItem_detach), -1);
+  rb_define_method(SwigClassFXDirItem.klass, "destroy", VALUEFUNC(_wrap_FXDirItem_destroy), -1);
+  SwigClassFXDirItem.mark = (void (*)(void *)) FXRbDirItem::markfunc;
+  SwigClassFXDirItem.destroy = (void (*)(void *)) FXRbDirItem::freefunc;
+  SwigClassFXDirItem.trackObjects = 0;
+  
+  SwigClassFXDirList.klass = rb_define_class_under(mFox, "FXDirList", ((swig_class *) SWIGTYPE_p_FXTreeList->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXDirList, (void *) &SwigClassFXDirList);
+  rb_define_alloc_func(SwigClassFXDirList.klass, _wrap_FXDirList_allocate);
+  rb_define_method(SwigClassFXDirList.klass, "initialize", VALUEFUNC(_wrap_new_FXDirList), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onRefreshTimer", VALUEFUNC(_wrap_FXDirList_onRefreshTimer), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onBeginDrag", VALUEFUNC(_wrap_FXDirList_onBeginDrag), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onEndDrag", VALUEFUNC(_wrap_FXDirList_onEndDrag), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onDragged", VALUEFUNC(_wrap_FXDirList_onDragged), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onDNDEnter", VALUEFUNC(_wrap_FXDirList_onDNDEnter), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onDNDLeave", VALUEFUNC(_wrap_FXDirList_onDNDLeave), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onDNDMotion", VALUEFUNC(_wrap_FXDirList_onDNDMotion), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onDNDDrop", VALUEFUNC(_wrap_FXDirList_onDNDDrop), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onDNDRequest", VALUEFUNC(_wrap_FXDirList_onDNDRequest), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXDirList_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onCmdSetStringValue", VALUEFUNC(_wrap_FXDirList_onCmdSetStringValue), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onCmdGetStringValue", VALUEFUNC(_wrap_FXDirList_onCmdGetStringValue), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onCmdToggleHidden", VALUEFUNC(_wrap_FXDirList_onCmdToggleHidden), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onUpdToggleHidden", VALUEFUNC(_wrap_FXDirList_onUpdToggleHidden), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onCmdShowHidden", VALUEFUNC(_wrap_FXDirList_onCmdShowHidden), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onUpdShowHidden", VALUEFUNC(_wrap_FXDirList_onUpdShowHidden), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onCmdHideHidden", VALUEFUNC(_wrap_FXDirList_onCmdHideHidden), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onUpdHideHidden", VALUEFUNC(_wrap_FXDirList_onUpdHideHidden), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onCmdToggleFiles", VALUEFUNC(_wrap_FXDirList_onCmdToggleFiles), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onUpdToggleFiles", VALUEFUNC(_wrap_FXDirList_onUpdToggleFiles), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onCmdShowFiles", VALUEFUNC(_wrap_FXDirList_onCmdShowFiles), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onUpdShowFiles", VALUEFUNC(_wrap_FXDirList_onUpdShowFiles), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onCmdHideFiles", VALUEFUNC(_wrap_FXDirList_onCmdHideFiles), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onUpdHideFiles", VALUEFUNC(_wrap_FXDirList_onUpdHideFiles), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onCmdSetPattern", VALUEFUNC(_wrap_FXDirList_onCmdSetPattern), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onUpdSetPattern", VALUEFUNC(_wrap_FXDirList_onUpdSetPattern), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onCmdSortReverse", VALUEFUNC(_wrap_FXDirList_onCmdSortReverse), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onUpdSortReverse", VALUEFUNC(_wrap_FXDirList_onUpdSortReverse), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onCmdSortCase", VALUEFUNC(_wrap_FXDirList_onCmdSortCase), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onUpdSortCase", VALUEFUNC(_wrap_FXDirList_onUpdSortCase), -1);
+  rb_define_method(SwigClassFXDirList.klass, "onCmdRefresh", VALUEFUNC(_wrap_FXDirList_onCmdRefresh), -1);
+  rb_define_singleton_method(SwigClassFXDirList.klass, "ascending", VALUEFUNC(_wrap_FXDirList_ascending), -1);
+  rb_define_singleton_method(SwigClassFXDirList.klass, "descending", VALUEFUNC(_wrap_FXDirList_descending), -1);
+  rb_define_singleton_method(SwigClassFXDirList.klass, "ascendingCase", VALUEFUNC(_wrap_FXDirList_ascendingCase), -1);
+  rb_define_singleton_method(SwigClassFXDirList.klass, "descendingCase", VALUEFUNC(_wrap_FXDirList_descendingCase), -1);
+  rb_define_const(SwigClassFXDirList.klass, "ID_REFRESHTIMER", SWIG_From_int(static_cast< int >(FXDirList::ID_REFRESHTIMER)));
+  rb_define_const(SwigClassFXDirList.klass, "ID_SHOW_FILES", SWIG_From_int(static_cast< int >(FXDirList::ID_SHOW_FILES)));
+  rb_define_const(SwigClassFXDirList.klass, "ID_HIDE_FILES", SWIG_From_int(static_cast< int >(FXDirList::ID_HIDE_FILES)));
+  rb_define_const(SwigClassFXDirList.klass, "ID_TOGGLE_FILES", SWIG_From_int(static_cast< int >(FXDirList::ID_TOGGLE_FILES)));
+  rb_define_const(SwigClassFXDirList.klass, "ID_SHOW_HIDDEN", SWIG_From_int(static_cast< int >(FXDirList::ID_SHOW_HIDDEN)));
+  rb_define_const(SwigClassFXDirList.klass, "ID_HIDE_HIDDEN", SWIG_From_int(static_cast< int >(FXDirList::ID_HIDE_HIDDEN)));
+  rb_define_const(SwigClassFXDirList.klass, "ID_TOGGLE_HIDDEN", SWIG_From_int(static_cast< int >(FXDirList::ID_TOGGLE_HIDDEN)));
+  rb_define_const(SwigClassFXDirList.klass, "ID_SET_PATTERN", SWIG_From_int(static_cast< int >(FXDirList::ID_SET_PATTERN)));
+  rb_define_const(SwigClassFXDirList.klass, "ID_SORT_REVERSE", SWIG_From_int(static_cast< int >(FXDirList::ID_SORT_REVERSE)));
+  rb_define_const(SwigClassFXDirList.klass, "ID_SORT_CASE", SWIG_From_int(static_cast< int >(FXDirList::ID_SORT_CASE)));
+  rb_define_const(SwigClassFXDirList.klass, "ID_REFRESH", SWIG_From_int(static_cast< int >(FXDirList::ID_REFRESH)));
+  rb_define_const(SwigClassFXDirList.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXDirList::ID_LAST)));
+  rb_define_method(SwigClassFXDirList.klass, "scan", VALUEFUNC(_wrap_FXDirList_scan), -1);
+  rb_define_method(SwigClassFXDirList.klass, "isItemDirectory", VALUEFUNC(_wrap_FXDirList_isItemDirectory), -1);
+  rb_define_method(SwigClassFXDirList.klass, "isItemFile", VALUEFUNC(_wrap_FXDirList_isItemFile), -1);
+  rb_define_method(SwigClassFXDirList.klass, "isItemExecutable", VALUEFUNC(_wrap_FXDirList_isItemExecutable), -1);
+  rb_define_method(SwigClassFXDirList.klass, "setCurrentFile", VALUEFUNC(_wrap_FXDirList_setCurrentFile), -1);
+  rb_define_method(SwigClassFXDirList.klass, "getCurrentFile", VALUEFUNC(_wrap_FXDirList_getCurrentFile), -1);
+  rb_define_method(SwigClassFXDirList.klass, "setDirectory", VALUEFUNC(_wrap_FXDirList_setDirectory), -1);
+  rb_define_method(SwigClassFXDirList.klass, "getDirectory", VALUEFUNC(_wrap_FXDirList_getDirectory), -1);
+  rb_define_method(SwigClassFXDirList.klass, "getItemPathname", VALUEFUNC(_wrap_FXDirList_getItemPathname), -1);
+  rb_define_method(SwigClassFXDirList.klass, "getPathnameItem", VALUEFUNC(_wrap_FXDirList_getPathnameItem), -1);
+  rb_define_method(SwigClassFXDirList.klass, "setPattern", VALUEFUNC(_wrap_FXDirList_setPattern), -1);
+  rb_define_method(SwigClassFXDirList.klass, "getPattern", VALUEFUNC(_wrap_FXDirList_getPattern), -1);
+  rb_define_method(SwigClassFXDirList.klass, "getMatchMode", VALUEFUNC(_wrap_FXDirList_getMatchMode), -1);
+  rb_define_method(SwigClassFXDirList.klass, "setMatchMode", VALUEFUNC(_wrap_FXDirList_setMatchMode), -1);
+  rb_define_method(SwigClassFXDirList.klass, "getShowFiles", VALUEFUNC(_wrap_FXDirList_getShowFiles), -1);
+  rb_define_method(SwigClassFXDirList.klass, "setShowFiles", VALUEFUNC(_wrap_FXDirList_setShowFiles), -1);
+  rb_define_method(SwigClassFXDirList.klass, "getShowHiddenFiles", VALUEFUNC(_wrap_FXDirList_getShowHiddenFiles), -1);
+  rb_define_method(SwigClassFXDirList.klass, "setShowHiddenFiles", VALUEFUNC(_wrap_FXDirList_setShowHiddenFiles), -1);
+  rb_define_method(SwigClassFXDirList.klass, "setAssociations", VALUEFUNC(_wrap_FXDirList_setAssociations), -1);
+  rb_define_method(SwigClassFXDirList.klass, "getAssociations", VALUEFUNC(_wrap_FXDirList_getAssociations), -1);
+  rb_define_method(SwigClassFXDirList.klass, "save", VALUEFUNC(_wrap_FXDirList_save), -1);
+  rb_define_method(SwigClassFXDirList.klass, "load", VALUEFUNC(_wrap_FXDirList_load), -1);
+  rb_define_method(SwigClassFXDirList.klass, "create", VALUEFUNC(_wrap_FXDirList_create), -1);
+  rb_define_method(SwigClassFXDirList.klass, "detach", VALUEFUNC(_wrap_FXDirList_detach), -1);
+  rb_define_method(SwigClassFXDirList.klass, "destroy", VALUEFUNC(_wrap_FXDirList_destroy), -1);
+  rb_define_method(SwigClassFXDirList.klass, "resize", VALUEFUNC(_wrap_FXDirList_resize), -1);
+  rb_define_method(SwigClassFXDirList.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXDirList_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXDirList.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXDirList_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXDirList.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXDirList_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXDirList.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXDirList_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXDirList.klass, "canFocus", VALUEFUNC(_wrap_FXDirList_canFocus), -1);
+  rb_define_method(SwigClassFXDirList.klass, "setFocus", VALUEFUNC(_wrap_FXDirList_setFocus), -1);
+  rb_define_method(SwigClassFXDirList.klass, "killFocus", VALUEFUNC(_wrap_FXDirList_killFocus), -1);
+  rb_define_method(SwigClassFXDirList.klass, "changeFocus", VALUEFUNC(_wrap_FXDirList_changeFocus), -1);
+  rb_define_method(SwigClassFXDirList.klass, "setDefault", VALUEFUNC(_wrap_FXDirList_setDefault), -1);
+  rb_define_method(SwigClassFXDirList.klass, "enable", VALUEFUNC(_wrap_FXDirList_enable), -1);
+  rb_define_method(SwigClassFXDirList.klass, "disable", VALUEFUNC(_wrap_FXDirList_disable), -1);
+  rb_define_method(SwigClassFXDirList.klass, "raiseWindow", VALUEFUNC(_wrap_FXDirList_raiseWindow), -1);
+  rb_define_method(SwigClassFXDirList.klass, "lower", VALUEFUNC(_wrap_FXDirList_lower), -1);
+  rb_define_method(SwigClassFXDirList.klass, "move", VALUEFUNC(_wrap_FXDirList_move), -1);
+  rb_define_method(SwigClassFXDirList.klass, "layout", VALUEFUNC(_wrap_FXDirList_layout), -1);
+  rb_define_method(SwigClassFXDirList.klass, "recalc", VALUEFUNC(_wrap_FXDirList_recalc), -1);
+  rb_define_method(SwigClassFXDirList.klass, "reparent", VALUEFUNC(_wrap_FXDirList_reparent), -1);
+  rb_define_method(SwigClassFXDirList.klass, "show", VALUEFUNC(_wrap_FXDirList_show), -1);
+  rb_define_method(SwigClassFXDirList.klass, "hide", VALUEFUNC(_wrap_FXDirList_hide), -1);
+  rb_define_method(SwigClassFXDirList.klass, "isComposite", VALUEFUNC(_wrap_FXDirList_isComposite), -1);
+  rb_define_method(SwigClassFXDirList.klass, "contains", VALUEFUNC(_wrap_FXDirList_contains), -1);
+  rb_define_method(SwigClassFXDirList.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXDirList_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXDirList.klass, "setBackColor", VALUEFUNC(_wrap_FXDirList_setBackColor), -1);
+  rb_define_method(SwigClassFXDirList.klass, "tr", VALUEFUNC(_wrap_FXDirList_tr), -1);
+  rb_define_method(SwigClassFXDirList.klass, "dropEnable", VALUEFUNC(_wrap_FXDirList_dropEnable), -1);
+  rb_define_method(SwigClassFXDirList.klass, "dropDisable", VALUEFUNC(_wrap_FXDirList_dropDisable), -1);
+  rb_define_method(SwigClassFXDirList.klass, "setShape", VALUEFUNC(_wrap_FXDirList_setShape), -1);
+  rb_define_method(SwigClassFXDirList.klass, "clearShape", VALUEFUNC(_wrap_FXDirList_clearShape), -1);
+  rb_define_method(SwigClassFXDirList.klass, "getViewportHeight", VALUEFUNC(_wrap_FXDirList_getViewportHeight), -1);
+  rb_define_method(SwigClassFXDirList.klass, "getViewportWidth", VALUEFUNC(_wrap_FXDirList_getViewportWidth), -1);
+  rb_define_method(SwigClassFXDirList.klass, "getContentHeight", VALUEFUNC(_wrap_FXDirList_getContentHeight), -1);
+  rb_define_method(SwigClassFXDirList.klass, "getContentWidth", VALUEFUNC(_wrap_FXDirList_getContentWidth), -1);
+  rb_define_method(SwigClassFXDirList.klass, "position", VALUEFUNC(_wrap_FXDirList_position), -1);
+  rb_define_method(SwigClassFXDirList.klass, "selectItem", VALUEFUNC(_wrap_FXDirList_selectItem), -1);
+  rb_define_method(SwigClassFXDirList.klass, "deselectItem", VALUEFUNC(_wrap_FXDirList_deselectItem), -1);
+  rb_define_method(SwigClassFXDirList.klass, "toggleItem", VALUEFUNC(_wrap_FXDirList_toggleItem), -1);
+  rb_define_method(SwigClassFXDirList.klass, "extendSelection", VALUEFUNC(_wrap_FXDirList_extendSelection), -1);
+  rb_define_method(SwigClassFXDirList.klass, "killSelection", VALUEFUNC(_wrap_FXDirList_killSelection), -1);
+  rb_define_method(SwigClassFXDirList.klass, "openItem", VALUEFUNC(_wrap_FXDirList_openItem), -1);
+  rb_define_method(SwigClassFXDirList.klass, "closeItem", VALUEFUNC(_wrap_FXDirList_closeItem), -1);
+  rb_define_method(SwigClassFXDirList.klass, "collapseTree", VALUEFUNC(_wrap_FXDirList_collapseTree), -1);
+  rb_define_method(SwigClassFXDirList.klass, "expandTree", VALUEFUNC(_wrap_FXDirList_expandTree), -1);
+  rb_define_method(SwigClassFXDirList.klass, "setCurrentItem", VALUEFUNC(_wrap_FXDirList_setCurrentItem), -1);
+  rb_define_method(SwigClassFXDirList.klass, "getItemAt", VALUEFUNC(_wrap_FXDirList_getItemAt), -1);
+  rb_define_method(SwigClassFXDirList.klass, "makeItemVisible", VALUEFUNC(_wrap_FXDirList_makeItemVisible), -1);
+  rb_define_method(SwigClassFXDirList.klass, "enableItem", VALUEFUNC(_wrap_FXDirList_enableItem), -1);
+  rb_define_method(SwigClassFXDirList.klass, "disableItem", VALUEFUNC(_wrap_FXDirList_disableItem), -1);
+  SwigClassFXDirList.mark = (void (*)(void *)) FXRbDirList::markfunc;
+  SwigClassFXDirList.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXDirList.trackObjects = 0;
+}
+
diff --git a/ext/fox16_c/ui_wrap.cpp b/ext/fox16_c/ui_wrap.cpp
new file mode 100644
index 00000000..573eed1f
--- /dev/null
+++ b/ext/fox16_c/ui_wrap.cpp
@@ -0,0 +1,58444 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 3.0.12
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+
+#ifndef SWIGRUBY
+#define SWIGRUBY
+#endif
+
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
+};
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+/* -----------------------------------------------------------------------------
+ * swigrun.swg
+ *
+ * This file contains generic C API SWIG runtime support for pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* This should only be incremented when either the layout of swig_type_info changes,
+   or for whatever reason, the runtime changes incompatibly */
+#define SWIG_RUNTIME_VERSION "4"
+
+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
+#ifdef SWIG_TYPE_TABLE
+# define SWIG_QUOTE_STRING(x) #x
+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
+#else
+# define SWIG_TYPE_TABLE_NAME
+#endif
+
+/*
+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
+
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
+*/
+
+#ifndef SWIGRUNTIME
+# define SWIGRUNTIME SWIGINTERN
+#endif
+
+#ifndef SWIGRUNTIMEINLINE
+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
+#endif
+
+/*  Generic buffer size */
+#ifndef SWIG_BUFFER_SIZE
+# define SWIG_BUFFER_SIZE 1024
+#endif
+
+/* Flags for pointer conversions */
+#define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
+
+/* Flags for new pointer objects */
+#define SWIG_POINTER_OWN           0x1
+
+
+/*
+   Flags/methods for returning states.
+
+   The SWIG conversion methods, as ConvertPtr, return an integer
+   that tells if the conversion was successful or not. And if not,
+   an error code can be returned (see swigerrors.swg for the codes).
+
+   Use the following macros/flags to set or process the returning
+   states.
+
+   In old versions of SWIG, code such as the following was usually written:
+
+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
+       // success code
+     } else {
+       //fail code
+     }
+
+   Now you can be more explicit:
+
+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+    } else {
+      // fail code
+    }
+
+   which is the same really, but now you can also do
+
+    Type *ptr;
+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
+    if (SWIG_IsOK(res)) {
+      // success code
+      if (SWIG_IsNewObj(res) {
+        ...
+	delete *ptr;
+      } else {
+        ...
+      }
+    } else {
+      // fail code
+    }
+
+   I.e., now SWIG_ConvertPtr can return new objects and you can
+   identify the case and take care of the deallocation. Of course that
+   also requires SWIG_ConvertPtr to return new result values, such as
+
+      int SWIG_ConvertPtr(obj, ptr,...) {
+        if (<obj is ok>) {
+          if (<need new object>) {
+            *ptr = <ptr to new allocated object>;
+            return SWIG_NEWOBJ;
+          } else {
+            *ptr = <ptr to old object>;
+            return SWIG_OLDOBJ;
+          }
+        } else {
+          return SWIG_BADOBJ;
+        }
+      }
+
+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
+   SWIG errors code.
+
+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
+   allows to return the 'cast rank', for example, if you have this
+
+       int food(double)
+       int fooi(int);
+
+   and you call
+
+      food(1)   // cast rank '1'  (1 -> 1.0)
+      fooi(1)   // cast rank '0'
+
+   just use the SWIG_AddCast()/SWIG_CheckState()
+*/
+
+#define SWIG_OK                    (0)
+#define SWIG_ERROR                 (-1)
+#define SWIG_IsOK(r)               (r >= 0)
+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
+
+/* The CastRankLimit says how many bits are used for the cast rank */
+#define SWIG_CASTRANKLIMIT         (1 << 8)
+/* The NewMask denotes the object was created (using new/malloc) */
+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
+/* The TmpMask is for in/out typemaps that use temporal objects */
+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
+/* Simple returning values */
+#define SWIG_BADOBJ                (SWIG_ERROR)
+#define SWIG_OLDOBJ                (SWIG_OK)
+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
+/* Check, add and del mask methods */
+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
+
+/* Cast-Rank Mode */
+#if defined(SWIG_CASTRANK_MODE)
+#  ifndef SWIG_TypeRank
+#    define SWIG_TypeRank             unsigned long
+#  endif
+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
+#    define SWIG_MAXCASTRANK          (2)
+#  endif
+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
+SWIGINTERNINLINE int SWIG_AddCast(int r) {
+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
+}
+SWIGINTERNINLINE int SWIG_CheckState(int r) {
+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
+}
+#else /* no cast-rank mode */
+#  define SWIG_AddCast(r) (r)
+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
+#endif
+
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *(*swig_converter_func)(void *, int *);
+typedef struct swig_type_info *(*swig_dycast_func)(void **);
+
+/* Structure to store information on one type */
+typedef struct swig_type_info {
+  const char             *name;			/* mangled name of this type */
+  const char             *str;			/* human readable name of this type */
+  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
+  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
+  void                   *clientdata;		/* language specific type data */
+  int                    owndata;		/* flag if the structure owns the clientdata */
+} swig_type_info;
+
+/* Structure to store a type and conversion function used for casting */
+typedef struct swig_cast_info {
+  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
+  swig_converter_func     converter;		/* function to cast the void pointers */
+  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
+  struct swig_cast_info  *prev;			/* pointer to the previous cast */
+} swig_cast_info;
+
+/* Structure used to store module information
+ * Each module generates one structure like this, and the runtime collects
+ * all of these structures and stores them in a circularly linked list.*/
+typedef struct swig_module_info {
+  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
+  size_t                 size;		        /* Number of types in this module */
+  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
+  swig_type_info         **type_initial;	/* Array of initially generated type structures */
+  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
+  void                    *clientdata;		/* Language specific module data */
+} swig_module_info;
+
+/*
+  Compare two type names skipping the space characters, therefore
+  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
+
+  Return 0 when the two name types are equivalent, as in
+  strncmp, but skipping ' '.
+*/
+SWIGRUNTIME int
+SWIG_TypeNameComp(const char *f1, const char *l1,
+		  const char *f2, const char *l2) {
+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
+    while ((*f1 == ' ') && (f1 != l1)) ++f1;
+    while ((*f2 == ' ') && (f2 != l2)) ++f2;
+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
+  }
+  return (int)((l1 - f1) - (l2 - f2));
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
+*/
+SWIGRUNTIME int
+SWIG_TypeCmp(const char *nb, const char *tb) {
+  int equiv = 1;
+  const char* te = tb + strlen(tb);
+  const char* ne = nb;
+  while (equiv != 0 && *ne) {
+    for (nb = ne; *ne; ++ne) {
+      if (*ne == '|') break;
+    }
+    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
+    if (*ne) ++ne;
+  }
+  return equiv;
+}
+
+/*
+  Check type equivalence in a name list like <name1>|<name2>|...
+  Return 0 if not equal, 1 if equal
+*/
+SWIGRUNTIME int
+SWIG_TypeEquiv(const char *nb, const char *tb) {
+  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
+}
+
+/*
+  Check the typename
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
+SWIGRUNTIME swig_cast_info *
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
+}
+
+/*
+  Cast a pointer up an inheritance hierarchy
+*/
+SWIGRUNTIMEINLINE void *
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
+}
+
+/*
+   Dynamic pointer casting. Down an inheritance hierarchy
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
+  swig_type_info *lastty = ty;
+  if (!ty || !ty->dcast) return ty;
+  while (ty && (ty->dcast)) {
+    ty = (*ty->dcast)(ptr);
+    if (ty) lastty = ty;
+  }
+  return lastty;
+}
+
+/*
+  Return the name associated with this type
+*/
+SWIGRUNTIMEINLINE const char *
+SWIG_TypeName(const swig_type_info *ty) {
+  return ty->name;
+}
+
+/*
+  Return the pretty name associated with this type,
+  that is an unmangled type name in a form presentable to the user.
+*/
+SWIGRUNTIME const char *
+SWIG_TypePrettyName(const swig_type_info *type) {
+  /* The "str" field contains the equivalent pretty names of the
+     type, separated by vertical-bar characters.  We choose
+     to print the last name, as it is often (?) the most
+     specific. */
+  if (!type) return NULL;
+  if (type->str != NULL) {
+    const char *last_name = type->str;
+    const char *s;
+    for (s = type->str; *s; s++)
+      if (*s == '|') last_name = s+1;
+    return last_name;
+  }
+  else
+    return type->name;
+}
+
+/*
+   Set the clientdata field for a type
+*/
+SWIGRUNTIME void
+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
+  swig_cast_info *cast = ti->cast;
+  /* if (ti->clientdata == clientdata) return; */
+  ti->clientdata = clientdata;
+
+  while (cast) {
+    if (!cast->converter) {
+      swig_type_info *tc = cast->type;
+      if (!tc->clientdata) {
+	SWIG_TypeClientData(tc, clientdata);
+      }
+    }
+    cast = cast->next;
+  }
+}
+SWIGRUNTIME void
+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
+  SWIG_TypeClientData(ti, clientdata);
+  ti->owndata = 1;
+}
+
+/*
+  Search for a swig_type_info structure only by mangled name
+  Search is a O(log #types)
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_MangledTypeQueryModule(swig_module_info *start,
+                            swig_module_info *end,
+		            const char *name) {
+  swig_module_info *iter = start;
+  do {
+    if (iter->size) {
+      size_t l = 0;
+      size_t r = iter->size - 1;
+      do {
+	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
+	size_t i = (l + r) >> 1;
+	const char *iname = iter->types[i]->name;
+	if (iname) {
+	  int compare = strcmp(name, iname);
+	  if (compare == 0) {
+	    return iter->types[i];
+	  } else if (compare < 0) {
+	    if (i) {
+	      r = i - 1;
+	    } else {
+	      break;
+	    }
+	  } else if (compare > 0) {
+	    l = i + 1;
+	  }
+	} else {
+	  break; /* should never happen */
+	}
+      } while (l <= r);
+    }
+    iter = iter->next;
+  } while (iter != end);
+  return 0;
+}
+
+/*
+  Search for a swig_type_info structure for either a mangled name or a human readable name.
+  It first searches the mangled names of the types, which is a O(log #types)
+  If a type is not found it then searches the human readable names, which is O(#types).
+
+  We start searching at module start, and finish searching when start == end.
+  Note: if start == end at the beginning of the function, we go all the way around
+  the circular list.
+*/
+SWIGRUNTIME swig_type_info *
+SWIG_TypeQueryModule(swig_module_info *start,
+                     swig_module_info *end,
+		     const char *name) {
+  /* STEP 1: Search the name field using binary search */
+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
+  if (ret) {
+    return ret;
+  } else {
+    /* STEP 2: If the type hasn't been found, do a complete search
+       of the str field (the human readable name) */
+    swig_module_info *iter = start;
+    do {
+      size_t i = 0;
+      for (; i < iter->size; ++i) {
+	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
+	  return iter->types[i];
+      }
+      iter = iter->next;
+    } while (iter != end);
+  }
+
+  /* neither found a match */
+  return 0;
+}
+
+/*
+   Pack binary data into a string
+*/
+SWIGRUNTIME char *
+SWIG_PackData(char *c, void *ptr, size_t sz) {
+  static const char hex[17] = "0123456789abcdef";
+  const unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu =  u + sz;
+  for (; u != eu; ++u) {
+    unsigned char uu = *u;
+    *(c++) = hex[(uu & 0xf0) >> 4];
+    *(c++) = hex[uu & 0xf];
+  }
+  return c;
+}
+
+/*
+   Unpack binary data from a string
+*/
+SWIGRUNTIME const char *
+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  unsigned char *u = (unsigned char *) ptr;
+  const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    char d = *(c++);
+    unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = (unsigned char)((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = (unsigned char)((d - ('a'-10)) << 4);
+    else
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (unsigned char)(d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (unsigned char)(d - ('a'-10));
+    else
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+
+/*
+   Pack 'void *' into a string buffer.
+*/
+SWIGRUNTIME char *
+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
+  char *r = buff;
+  if ((2*sizeof(void *) + 2) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,&ptr,sizeof(void *));
+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
+  strcpy(r,name);
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      *ptr = (void *) 0;
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sizeof(void *));
+}
+
+SWIGRUNTIME char *
+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
+  char *r = buff;
+  size_t lname = (name ? strlen(name) : 0);
+  if ((2*sz + 2 + lname) > bsz) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r,ptr,sz);
+  if (lname) {
+    strncpy(r,name,lname+1);
+  } else {
+    *r = 0;
+  }
+  return buff;
+}
+
+SWIGRUNTIME const char *
+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
+  if (*c != '_') {
+    if (strcmp(c,"NULL") == 0) {
+      memset(ptr,0,sz);
+      return name;
+    } else {
+      return 0;
+    }
+  }
+  return SWIG_UnpackData(++c,ptr,sz);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/*  Errors in SWIG */
+#define  SWIG_UnknownError    	   -1
+#define  SWIG_IOError        	   -2
+#define  SWIG_RuntimeError   	   -3
+#define  SWIG_IndexError     	   -4
+#define  SWIG_TypeError      	   -5
+#define  SWIG_DivisionByZero 	   -6
+#define  SWIG_OverflowError  	   -7
+#define  SWIG_SyntaxError    	   -8
+#define  SWIG_ValueError     	   -9
+#define  SWIG_SystemError    	   -10
+#define  SWIG_AttributeError 	   -11
+#define  SWIG_MemoryError    	   -12
+#define  SWIG_NullReferenceError   -13
+
+
+
+      #include <ruby.h>
+
+      #if defined(RB_METHOD_DEFINITION_DECL)
+      # define RUBY_VALUE_METHOD_FUNC(func) (func)
+      # define RUBY_INT_METHOD_FUNC(func) (func)
+      # define RUBY_VOID_METHOD_FUNC(func) (func)
+      # define RUBY_VOIDP_METHOD_FUNC(func) (func)
+      #else
+      # define RUBY_VALUE_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
+      # define RUBY_INT_METHOD_FUNC(func) ((int (*)(ANYARGS))(func))
+      # define RUBY_VOID_METHOD_FUNC(func) ((void (*)(ANYARGS))(func))
+      # define RUBY_VOIDP_METHOD_FUNC(func) ((void *(*)(ANYARGS))(func))
+      #endif
+
+
+/* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
+ * breaks using rb_intern as an lvalue, as SWIG does.  We work around this
+ * issue for now by disabling this.
+ * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
+ */
+#ifdef rb_intern
+# undef rb_intern
+#endif
+
+/* Remove global macros defined in Ruby's win32.h */
+#ifdef write
+# undef write
+#endif
+#ifdef read
+# undef read
+#endif
+#ifdef bind
+# undef bind
+#endif
+#ifdef close
+# undef close
+#endif
+#ifdef connect
+# undef connect
+#endif
+
+
+/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
+#ifndef NUM2LL
+#define NUM2LL(x) NUM2LONG((x))
+#endif
+#ifndef LL2NUM
+#define LL2NUM(x) INT2NUM((long) (x))
+#endif
+#ifndef ULL2NUM
+#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
+#endif
+
+/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
+#ifndef NUM2ULL
+#ifdef HAVE_LONG_LONG
+#define NUM2ULL(x) rb_num2ull((x))
+#else
+#define NUM2ULL(x) NUM2ULONG(x)
+#endif
+#endif
+
+/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
+/* Define these for older versions so we can just write code the new way */
+#ifndef RSTRING_LEN
+# define RSTRING_LEN(x) RSTRING(x)->len
+#endif
+#ifndef RSTRING_PTR
+# define RSTRING_PTR(x) RSTRING(x)->ptr
+#endif
+#ifndef RSTRING_END
+# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
+#endif
+#ifndef RARRAY_LEN
+# define RARRAY_LEN(x) RARRAY(x)->len
+#endif
+#ifndef RARRAY_PTR
+# define RARRAY_PTR(x) RARRAY(x)->ptr
+#endif
+#ifndef RFLOAT_VALUE
+# define RFLOAT_VALUE(x) RFLOAT(x)->value
+#endif
+#ifndef DOUBLE2NUM
+# define DOUBLE2NUM(x) rb_float_new(x)
+#endif
+#ifndef RHASH_TBL
+# define RHASH_TBL(x) (RHASH(x)->tbl)
+#endif
+#ifndef RHASH_ITER_LEV
+# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
+#endif
+#ifndef RHASH_IFNONE
+# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
+#endif
+#ifndef RHASH_SIZE
+# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
+#endif
+#ifndef RHASH_EMPTY_P
+# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
+#endif
+#ifndef RSTRUCT_LEN
+# define RSTRUCT_LEN(x) RSTRUCT(x)->len
+#endif
+#ifndef RSTRUCT_PTR
+# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
+#endif
+
+
+
+/*
+ * Need to be very careful about how these macros are defined, especially
+ * when compiling C++ code or C code with an ANSI C compiler.
+ *
+ * VALUEFUNC(f) is a macro used to typecast a C function that implements
+ * a Ruby method so that it can be passed as an argument to API functions
+ * like rb_define_method() and rb_define_singleton_method().
+ *
+ * VOIDFUNC(f) is a macro used to typecast a C function that implements
+ * either the "mark" or "free" stuff for a Ruby Data object, so that it
+ * can be passed as an argument to API functions like Data_Wrap_Struct()
+ * and Data_Make_Struct().
+ */
+ 
+#ifdef __cplusplus
+#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
+#    define PROTECTFUNC(f) ((VALUE (*)()) f)
+#    define VALUEFUNC(f) ((VALUE (*)()) f)
+#    define VOIDFUNC(f)  ((void (*)()) f)
+#  else
+#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
+#      define PROTECTFUNC(f) ((VALUE (*)()) f)
+#      define VALUEFUNC(f) ((VALUE (*)()) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    else /* These definitions should work for Ruby 1.7+ */
+#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
+#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    endif
+#  endif
+#else
+#  define VALUEFUNC(f) (f)
+#  define VOIDFUNC(f) (f)
+#endif
+
+/* Don't use for expressions have side effect */
+#ifndef RB_STRING_VALUE
+#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
+#endif
+#ifndef StringValue
+#define StringValue(s) RB_STRING_VALUE(s)
+#endif
+#ifndef StringValuePtr
+#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
+#endif
+#ifndef StringValueLen
+#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
+#endif
+#ifndef SafeStringValue
+#define SafeStringValue(v) do {\
+    StringValue(v);\
+    rb_check_safe_str(v);\
+} while (0)
+#endif
+
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
+#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
+#endif
+
+static VALUE _mSWIG = Qnil;
+
+/* -----------------------------------------------------------------------------
+ * error manipulation
+ * ----------------------------------------------------------------------------- */
+
+
+/* Define some additional error types */
+#define SWIG_ObjectPreviouslyDeletedError  -100
+
+
+/* Define custom exceptions for errors that do not map to existing Ruby
+   exceptions.  Note this only works for C++ since a global cannot be
+   initialized by a function in C.  For C, fallback to rb_eRuntimeError.*/
+
+SWIGINTERN VALUE 
+getNullReferenceError(void) {
+  static int init = 0;
+  static VALUE rb_eNullReferenceError ;
+  if (!init) {
+    init = 1;
+    rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
+  }
+  return rb_eNullReferenceError;
+} 
+
+SWIGINTERN VALUE 
+getObjectPreviouslyDeletedError(void) {
+  static int init = 0;
+  static VALUE rb_eObjectPreviouslyDeleted ;
+  if (!init) {
+    init = 1;
+    rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
+  }
+  return rb_eObjectPreviouslyDeleted;
+} 
+
+
+SWIGINTERN VALUE
+SWIG_Ruby_ErrorType(int SWIG_code) {
+  VALUE type;
+  switch (SWIG_code) {
+  case SWIG_MemoryError:
+    type = rb_eNoMemError;
+    break;
+  case SWIG_IOError:
+    type = rb_eIOError;
+    break;
+  case SWIG_RuntimeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_IndexError:
+    type = rb_eIndexError;
+    break;
+  case SWIG_TypeError:
+    type = rb_eTypeError;
+    break;
+  case SWIG_DivisionByZero:
+    type = rb_eZeroDivError;
+    break;
+  case SWIG_OverflowError:
+    type = rb_eRangeError;
+    break;
+  case SWIG_SyntaxError:
+    type = rb_eSyntaxError;
+    break;
+  case SWIG_ValueError:
+    type = rb_eArgError;
+    break;
+  case SWIG_SystemError:
+    type = rb_eFatal;
+    break;
+  case SWIG_AttributeError:
+    type = rb_eRuntimeError;
+    break;
+  case SWIG_NullReferenceError:
+    type = getNullReferenceError();
+    break;
+  case SWIG_ObjectPreviouslyDeletedError:
+    type = getObjectPreviouslyDeletedError();
+    break;
+  case SWIG_UnknownError:
+    type = rb_eRuntimeError;
+    break;
+  default:
+    type = rb_eRuntimeError;
+  }
+  return type;
+}
+
+
+/* This function is called when a user inputs a wrong argument to
+   a method.
+ */
+SWIGINTERN 
+const char* Ruby_Format_TypeError( const char* msg,
+				   const char* type, 
+				   const char* name, 
+				   const int argn,
+				   VALUE input )
+{
+  char buf[128];
+  VALUE str;
+  VALUE asStr;
+  if ( msg && *msg )
+    {
+      str = rb_str_new2(msg);
+    }
+  else
+    {
+      str = rb_str_new(NULL, 0);
+    }
+
+  str = rb_str_cat2( str, "Expected argument " );
+  sprintf( buf, "%d of type ", argn-1 );
+  str = rb_str_cat2( str, buf );
+  str = rb_str_cat2( str, type );
+  str = rb_str_cat2( str, ", but got " );
+  str = rb_str_cat2( str, rb_obj_classname(input) );
+  str = rb_str_cat2( str, " " );
+  asStr = rb_inspect(input);
+  if ( RSTRING_LEN(asStr) > 30 )
+    {
+      str = rb_str_cat( str, StringValuePtr(asStr), 30 );
+      str = rb_str_cat2( str, "..." );
+    }
+  else
+    {
+      str = rb_str_append( str, asStr );
+    }
+
+  if ( name )
+    {
+      str = rb_str_cat2( str, "\n\tin SWIG method '" );
+      str = rb_str_cat2( str, name );
+      str = rb_str_cat2( str, "'" );
+    }
+
+  return StringValuePtr( str );
+}
+
+/* This function is called when an overloaded method fails */
+SWIGINTERN 
+void Ruby_Format_OverloadedError(
+				 const int argc,
+				 const int maxargs,
+				 const char* method, 
+				 const char* prototypes 
+				 )
+{
+  const char* msg = "Wrong # of arguments";
+  if ( argc <= maxargs ) msg = "Wrong arguments";
+  rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"  
+	   "Possible C/C++ prototypes are:\n%s",
+	   msg, method, prototypes);
+}
+
+/* -----------------------------------------------------------------------------
+ * rubytracking.swg
+ *
+ * This file contains support for tracking mappings from 
+ * Ruby objects to C++ objects.  This functionality is needed
+ * to implement mark functions for Ruby's mark and sweep
+ * garbage collector.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(ST_DATA_T_DEFINED)
+/* Needs to be explicitly included for Ruby 1.8 and earlier */
+#include <st.h>
+#endif
+
+/* Ruby 1.8 actually assumes the first case. */
+#if SIZEOF_VOIDP == SIZEOF_LONG
+#  define SWIG2NUM(v) LONG2NUM((unsigned long)v)
+#  define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
+#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
+#  define SWIG2NUM(v) LL2NUM((unsigned long long)v)
+#  define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
+#else
+#  error sizeof(void*) is not the same as long or long long
+#endif
+
+/* Global hash table to store Trackings from C/C++
+   structs to Ruby Objects. 
+*/
+static st_table* swig_ruby_trackings = NULL;
+
+static VALUE swig_ruby_trackings_count(ID id, VALUE *var) {
+  return SWIG2NUM(swig_ruby_trackings->num_entries);
+}
+
+
+/* Setup a hash table to store Trackings */
+SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
+  /* Create a hash table to store Trackings from C++
+     objects to Ruby objects. */
+
+  /* Try to see if some other .so has already created a 
+     tracking hash table, which we keep hidden in an instance var
+     in the SWIG module.
+     This is done to allow multiple DSOs to share the same
+     tracking table.
+  */
+  VALUE trackings_value = Qnil;
+  /* change the variable name so that we can mix modules
+     compiled with older SWIG's - this used to be called "@__trackings__" */
+  ID trackings_id = rb_intern( "@__safetrackings__" );
+  VALUE verbose = rb_gv_get("VERBOSE");
+  rb_gv_set("VERBOSE", Qfalse);
+  trackings_value = rb_ivar_get( _mSWIG, trackings_id );
+  rb_gv_set("VERBOSE", verbose);
+
+  /* The trick here is that we have to store the hash table
+  pointer in a Ruby variable. We do not want Ruby's GC to
+  treat this pointer as a Ruby object, so we convert it to
+  a Ruby numeric value. */
+  if (trackings_value == Qnil) {
+    /* No, it hasn't.  Create one ourselves */
+    swig_ruby_trackings = st_init_numtable();
+    rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
+  } else {
+    swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
+  }
+
+        rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", RUBY_VALUE_METHOD_FUNC(swig_ruby_trackings_count), RUBY_VOID_METHOD_FUNC((rb_gvar_setter_t*)NULL))
+;
+}
+
+/* Add a Tracking from a C/C++ struct to a Ruby object */
+SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
+  /* Store the mapping to the global hash table. */
+  st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
+}
+
+/* Get the Ruby object that owns the specified C/C++ struct */
+SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
+  /* Now lookup the value stored in the global hash table */
+  VALUE value;
+
+  if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
+    return value;
+  } else {
+    return Qnil;
+  }
+}
+
+/* Remove a Tracking from a C/C++ struct to a Ruby object.  It
+   is very important to remove objects once they are destroyed
+   since the same memory address may be reused later to create
+   a new object. */
+SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
+  /* Delete the object from the hash table */
+  st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
+}
+
+/* This is a helper method that unlinks a Ruby object from its
+   underlying C++ object.  This is needed if the lifetime of the
+   Ruby object is longer than the C++ object */
+SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
+  VALUE object = SWIG_RubyInstanceFor(ptr);
+
+  if (object != Qnil) {
+    if (TYPE(object) != T_DATA)
+      abort();
+    DATA_PTR(object) = 0;
+  }
+}
+
+/* This is a helper method that iterates over all the trackings
+   passing the C++ object pointer and its related Ruby object
+   to the passed callback function. */
+
+/* Proxy method to abstract the internal trackings datatype */
+      static int swig_ruby_internal_iterate_callback(st_data_t ptr, st_data_t obj, st_data_t meth) {
+        ((void(*)(void*, VALUE))meth)((void*)ptr, (VALUE)obj);
+
+  return ST_CONTINUE;
+}
+
+SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
+  st_foreach(swig_ruby_trackings, RUBY_INT_METHOD_FUNC(swig_ruby_internal_iterate_callback), (st_data_t)meth);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ * Ruby API portion that goes into the runtime
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGINTERN VALUE
+SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
+  if (NIL_P(target)) {
+    target = o;
+  } else {
+    if (TYPE(target) != T_ARRAY) {
+      VALUE o2 = target;
+      target = rb_ary_new();
+      rb_ary_push(target, o2);
+    }
+    rb_ary_push(target, o);
+  }
+  return target;
+}
+
+/* For ruby1.8.4 and earlier. */
+#ifndef RUBY_INIT_STACK
+   RUBY_EXTERN void Init_stack(VALUE* addr);
+#  define RUBY_INIT_STACK \
+   VALUE variable_in_this_stack_frame; \
+   Init_stack(&variable_in_this_stack_frame);
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* -----------------------------------------------------------------------------
+ * rubyrun.swg
+ *
+ * This file contains the runtime support for Ruby modules
+ * and includes code for managing global variables and pointer
+ * type checking.
+ * ----------------------------------------------------------------------------- */
+
+/* For backward compatibility only */
+#define SWIG_POINTER_EXCEPTION  0
+
+/* for raw pointers */
+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
+#define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
+#define swig_owntype                                    swig_ruby_owntype
+
+/* for raw packed data */
+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+/* for class or struct pointers */
+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
+
+/* for C or C++ function pointers */
+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
+
+/* for C++ member pointers, ie, member methods */
+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
+
+
+/* Runtime API */
+
+#define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule(clientdata)
+#define SWIG_SetModule(clientdata, pointer) 		SWIG_Ruby_SetModule(pointer)
+
+
+/* Error manipulation */
+
+#define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
+#define SWIG_Error(code, msg)            		rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
+#define SWIG_fail                        		goto fail				 
+
+
+/* Ruby-specific SWIG API */
+
+#define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
+#define SWIG_define_class(ty)                        	SWIG_Ruby_define_class(ty)
+#define SWIG_NewClassInstance(value, ty)             	SWIG_Ruby_NewClassInstance(value, ty)
+#define SWIG_MangleStr(value)                        	SWIG_Ruby_MangleStr(value)		  
+#define SWIG_CheckConvert(value, ty)                 	SWIG_Ruby_CheckConvert(value, ty)	  
+
+#include "assert.h"
+
+/* -----------------------------------------------------------------------------
+ * pointers/data manipulation
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  VALUE klass;
+  VALUE mImpl;
+  void  (*mark)(void *);
+  void  (*destroy)(void *);
+  int trackObjects;
+} swig_class;
+
+
+/* Global pointer used to keep some internal SWIG stuff */
+static VALUE _cSWIG_Pointer = Qnil;
+static VALUE swig_runtime_data_type_pointer = Qnil;
+
+/* Global IDs used to keep some internal SWIG stuff */
+static ID swig_arity_id = 0;
+static ID swig_call_id  = 0;
+
+/*
+  If your swig extension is to be run within an embedded ruby and has
+  director callbacks, you should set -DRUBY_EMBEDDED during compilation.  
+  This will reset ruby's stack frame on each entry point from the main 
+  program the first time a virtual director function is invoked (in a 
+  non-recursive way).
+  If this is not done, you run the risk of Ruby trashing the stack.
+*/
+
+#ifdef RUBY_EMBEDDED
+
+#  define SWIG_INIT_STACK                            \
+      if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
+      ++swig_virtual_calls;
+#  define SWIG_RELEASE_STACK --swig_virtual_calls;
+#  define Ruby_DirectorTypeMismatchException(x) \
+          rb_raise( rb_eTypeError, "%s", x ); return c_result;
+
+      static unsigned int swig_virtual_calls = 0;
+
+#else  /* normal non-embedded extension */
+
+#  define SWIG_INIT_STACK
+#  define SWIG_RELEASE_STACK
+#  define Ruby_DirectorTypeMismatchException(x) \
+          throw Swig::DirectorTypeMismatchException( x );
+
+#endif  /* RUBY_EMBEDDED */
+
+
+SWIGRUNTIME VALUE 
+getExceptionClass(void) {
+  static int init = 0;
+  static VALUE rubyExceptionClass ;
+  if (!init) {
+    init = 1;
+    rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
+  }
+  return rubyExceptionClass;
+} 
+
+/* This code checks to see if the Ruby object being raised as part
+   of an exception inherits from the Ruby class Exception.  If so,
+   the object is simply returned.  If not, then a new Ruby exception
+   object is created and that will be returned to Ruby.*/
+SWIGRUNTIME VALUE
+SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
+  VALUE exceptionClass = getExceptionClass();
+  if (rb_obj_is_kind_of(obj, exceptionClass)) {
+    return obj;
+  }  else {
+    return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
+  }
+}
+
+/* Initialize Ruby runtime support */
+SWIGRUNTIME void
+SWIG_Ruby_InitRuntime(void)
+{
+  if (_mSWIG == Qnil) {
+    _mSWIG = rb_define_module("SWIG");
+    swig_call_id  = rb_intern("call");
+    swig_arity_id = rb_intern("arity");
+  }
+}
+
+/* Define Ruby class for C type */
+SWIGRUNTIME void
+SWIG_Ruby_define_class(swig_type_info *type)
+{
+  char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+  sprintf(klass_name, "TYPE%s", type->name);
+  if (NIL_P(_cSWIG_Pointer)) {
+    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
+    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
+  }
+  rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
+  free((void *) klass_name);
+}
+
+/* Create a new pointer object */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
+{
+  int own =  flags & SWIG_POINTER_OWN; 
+  int track;
+  char *klass_name;
+  swig_class *sklass;
+  VALUE klass;
+  VALUE obj;
+  
+  if (!ptr)
+    return Qnil;
+  
+  if (type->clientdata) {
+    sklass = (swig_class *) type->clientdata;
+		
+    /* Are we tracking this class and have we already returned this Ruby object? */
+    track = sklass->trackObjects;
+    if (track) {
+      obj = SWIG_RubyInstanceFor(ptr);
+      
+      /* Check the object's type and make sure it has the correct type.
+        It might not in cases where methods do things like 
+        downcast methods. */
+      if (obj != Qnil) {
+        VALUE value = rb_iv_get(obj, "@__swigtype__");
+        const char* type_name = RSTRING_PTR(value);
+				
+        if (strcmp(type->name, type_name) == 0) {
+          return obj;
+        }
+      }
+    }
+
+    /* Create a new Ruby object */
+    obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), 
+			   ( own ? VOIDFUNC(sklass->destroy) : 
+			     (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
+			     ), ptr);
+
+    /* If tracking is on for this class then track this object. */
+    if (track) {
+      SWIG_RubyAddTracking(ptr, obj);
+    }
+  } else {
+    klass_name = (char *) malloc(4 + strlen(type->name) + 1);
+    sprintf(klass_name, "TYPE%s", type->name);
+    klass = rb_const_get(_mSWIG, rb_intern(klass_name));
+    free((void *) klass_name);
+    obj = Data_Wrap_Struct(klass, 0, 0, ptr);
+  }
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  
+  return obj;
+}
+
+/* Create a new class instance (always owned) */
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
+{
+  VALUE obj;
+  swig_class *sklass = (swig_class *) type->clientdata;
+  obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
+  rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
+  return obj;
+}
+
+/* Get type mangle from class name */
+SWIGRUNTIMEINLINE char *
+SWIG_Ruby_MangleStr(VALUE obj)
+{
+  VALUE stype = rb_iv_get(obj, "@__swigtype__");
+  return StringValuePtr(stype);
+}
+
+/* Acquire a pointer value */
+typedef struct {
+  void (*datafree)(void *);
+  int own;
+} swig_ruby_owntype;
+
+SWIGRUNTIME swig_ruby_owntype
+SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
+  swig_ruby_owntype oldown = {0, 0};
+  if (obj) {
+    oldown.datafree = RDATA(obj)->dfree;
+    RDATA(obj)->dfree = own.datafree;
+  }
+  return oldown;
+}
+
+/* Convert a pointer value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
+{
+  char *c;
+  swig_cast_info *tc;
+  void *vptr = 0;
+
+  /* Grab the pointer */
+  if (NIL_P(obj)) {
+    if (ptr)
+      *ptr = 0;
+    return SWIG_OK;
+  } else {
+    if (TYPE(obj) != T_DATA) {
+      return SWIG_ERROR;
+    }
+    Data_Get_Struct(obj, void, vptr);
+  }
+  
+  if (own) {
+    own->datafree = RDATA(obj)->dfree;
+    own->own = 0;
+  }
+    
+  /* Check to see if the input object is giving up ownership
+     of the underlying C struct or C++ object.  If so then we
+     need to reset the destructor since the Ruby object no 
+     longer owns the underlying C++ object.*/ 
+  if (flags & SWIG_POINTER_DISOWN) {
+    /* Is tracking on for this class? */
+    int track = 0;
+    if (ty && ty->clientdata) {
+      swig_class *sklass = (swig_class *) ty->clientdata;
+      track = sklass->trackObjects;
+    }
+		
+    if (track) {
+      /* We are tracking objects for this class.  Thus we change the destructor
+       * to SWIG_RubyRemoveTracking.  This allows us to
+       * remove the mapping from the C++ to Ruby object
+       * when the Ruby object is garbage collected.  If we don't
+       * do this, then it is possible we will return a reference 
+       * to a Ruby object that no longer exists thereby crashing Ruby. */
+      RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
+    } else {    
+      RDATA(obj)->dfree = 0;
+    }
+  }
+
+  /* Do type-checking if type info was provided */
+  if (ty) {
+    if (ty->clientdata) {
+      if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
+        if (vptr == 0) {
+          /* The object has already been deleted */
+          return SWIG_ObjectPreviouslyDeletedError;
+        }
+      }
+    }
+    if ((c = SWIG_MangleStr(obj)) == NULL) {
+      return SWIG_ERROR;
+    }
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) {
+      return SWIG_ERROR;
+    } else {
+      if (ptr) {
+        if (tc->type == ty) {
+          *ptr = vptr;
+        } else {
+          int newmemory = 0;
+          *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
+          if (newmemory == SWIG_CAST_NEW_MEMORY) {
+            assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+            if (own)
+              own->own = own->own | SWIG_CAST_NEW_MEMORY;
+          }
+        }
+      }
+    }
+  } else {
+    if (ptr)
+      *ptr = vptr;
+  }
+  
+  return SWIG_OK;
+}
+
+/* Check convert */
+SWIGRUNTIMEINLINE int
+SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
+{
+  char *c = SWIG_MangleStr(obj);
+  if (!c) return 0;
+  return SWIG_TypeCheck(c,ty) != 0;
+}
+
+SWIGRUNTIME VALUE
+SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
+  char result[1024];
+  char *r = result;
+  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
+  *(r++) = '_';
+  r = SWIG_PackData(r, ptr, sz);
+  strcpy(r, type->name);
+  return rb_str_new2(result);
+}
+
+/* Convert a packed value value */
+SWIGRUNTIME int
+SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
+  swig_cast_info *tc;
+  const char  *c;
+
+  if (TYPE(obj) != T_STRING) goto type_error;
+  c = StringValuePtr(obj);
+  /* Pointer values must start with leading underscore */
+  if (*c != '_') goto type_error;
+  c++;
+  c = SWIG_UnpackData(c, ptr, sz);
+  if (ty) {
+    tc = SWIG_TypeCheck(c, ty);
+    if (!tc) goto type_error;
+  }
+  return SWIG_OK;
+
+ type_error:
+  return SWIG_ERROR;
+}
+
+SWIGRUNTIME swig_module_info *
+SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
+{
+  VALUE pointer;
+  swig_module_info *ret = 0;
+  VALUE verbose = rb_gv_get("VERBOSE");
+
+ /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
+  rb_gv_set("VERBOSE", Qfalse);
+  
+  /* first check if pointer already created */
+  pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
+  if (pointer != Qnil) {
+    Data_Get_Struct(pointer, swig_module_info, ret);
+  }
+
+  /* reinstate warnings */
+  rb_gv_set("VERBOSE", verbose);
+  return ret;
+}
+
+SWIGRUNTIME void 
+SWIG_Ruby_SetModule(swig_module_info *pointer)
+{
+  /* register a new class */
+  VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
+  /* create and store the structure pointer to a global variable */
+  swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
+  rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
+}
+
+/* This function can be used to check whether a proc or method or similarly
+   callable function has been passed.  Usually used in a %typecheck, like:
+
+   %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
+        $result = SWIG_Ruby_isCallable( $input );
+   }
+ */
+SWIGINTERN
+int SWIG_Ruby_isCallable( VALUE proc )
+{
+  if ( rb_respond_to( proc, swig_call_id ) )
+    return 1;
+  return 0;
+}
+
+/* This function can be used to check the arity (number of arguments)
+   a proc or method can take.  Usually used in a %typecheck.
+   Valid arities will be that equal to minimal or those < 0
+   which indicate a variable number of parameters at the end.
+ */
+SWIGINTERN
+int SWIG_Ruby_arity( VALUE proc, int minimal )
+{
+  if ( rb_respond_to( proc, swig_arity_id ) )
+    {
+      VALUE num = rb_funcall( proc, swig_arity_id, 0 );
+      int arity = NUM2INT(num);
+      if ( arity < 0 && (arity+1) < -minimal ) return 1;
+      if ( arity == minimal ) return 1;
+      return 1;
+    }
+  return 0;
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
+
+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
+
+
+
+  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) 
+
+
+/* -------- TYPES TABLE (BEGIN) -------- */
+
+#define SWIGTYPE_p_FX4Splitter swig_types[0]
+#define SWIGTYPE_p_FX7Segment swig_types[1]
+#define SWIGTYPE_p_FXAccelTable swig_types[2]
+#define SWIGTYPE_p_FXApp swig_types[3]
+#define SWIGTYPE_p_FXArrowButton swig_types[4]
+#define SWIGTYPE_p_FXBitmap swig_types[5]
+#define SWIGTYPE_p_FXBitmapFrame swig_types[6]
+#define SWIGTYPE_p_FXButton swig_types[7]
+#define SWIGTYPE_p_FXCURCursor swig_types[8]
+#define SWIGTYPE_p_FXCanvas swig_types[9]
+#define SWIGTYPE_p_FXColorBar swig_types[10]
+#define SWIGTYPE_p_FXColorRing swig_types[11]
+#define SWIGTYPE_p_FXColorSelector swig_types[12]
+#define SWIGTYPE_p_FXColorWell swig_types[13]
+#define SWIGTYPE_p_FXColorWheel swig_types[14]
+#define SWIGTYPE_p_FXComboBox swig_types[15]
+#define SWIGTYPE_p_FXComposite swig_types[16]
+#define SWIGTYPE_p_FXCursor swig_types[17]
+#define SWIGTYPE_p_FXDataTarget swig_types[18]
+#define SWIGTYPE_p_FXDebugTarget swig_types[19]
+#define SWIGTYPE_p_FXDelegator swig_types[20]
+#define SWIGTYPE_p_FXDial swig_types[21]
+#define SWIGTYPE_p_FXDict swig_types[22]
+#define SWIGTYPE_p_FXDirBox swig_types[23]
+#define SWIGTYPE_p_FXDirSelector swig_types[24]
+#define SWIGTYPE_p_FXDockBar swig_types[25]
+#define SWIGTYPE_p_FXDockHandler swig_types[26]
+#define SWIGTYPE_p_FXDockSite swig_types[27]
+#define SWIGTYPE_p_FXDockTitle swig_types[28]
+#define SWIGTYPE_p_FXDocument swig_types[29]
+#define SWIGTYPE_p_FXDragCorner swig_types[30]
+#define SWIGTYPE_p_FXDrawable swig_types[31]
+#define SWIGTYPE_p_FXDriveBox swig_types[32]
+#define SWIGTYPE_p_FXFileDict swig_types[33]
+#define SWIGTYPE_p_FXFileSelector swig_types[34]
+#define SWIGTYPE_p_FXFileStream swig_types[35]
+#define SWIGTYPE_p_FXFont swig_types[36]
+#define SWIGTYPE_p_FXFontDesc swig_types[37]
+#define SWIGTYPE_p_FXFontSelector swig_types[38]
+#define SWIGTYPE_p_FXFrame swig_types[39]
+#define SWIGTYPE_p_FXGIFCursor swig_types[40]
+#define SWIGTYPE_p_FXGradientBar swig_types[41]
+#define SWIGTYPE_p_FXGroupBox swig_types[42]
+#define SWIGTYPE_p_FXHeader swig_types[43]
+#define SWIGTYPE_p_FXHeaderItem swig_types[44]
+#define SWIGTYPE_p_FXHorizontalFrame swig_types[45]
+#define SWIGTYPE_p_FXHorizontalSeparator swig_types[46]
+#define SWIGTYPE_p_FXIcon swig_types[47]
+#define SWIGTYPE_p_FXIconDict swig_types[48]
+#define SWIGTYPE_p_FXId swig_types[49]
+#define SWIGTYPE_p_FXImage swig_types[50]
+#define SWIGTYPE_p_FXImageFrame swig_types[51]
+#define SWIGTYPE_p_FXImageView swig_types[52]
+#define SWIGTYPE_p_FXKnob swig_types[53]
+#define SWIGTYPE_p_FXListBox swig_types[54]
+#define SWIGTYPE_p_FXListItem swig_types[55]
+#define SWIGTYPE_p_FXMainWindow swig_types[56]
+#define SWIGTYPE_p_FXMatrix swig_types[57]
+#define SWIGTYPE_p_FXMemoryStream swig_types[58]
+#define SWIGTYPE_p_FXObject swig_types[59]
+#define SWIGTYPE_p_FXPacker swig_types[60]
+#define SWIGTYPE_p_FXPopup swig_types[61]
+#define SWIGTYPE_p_FXProgressBar swig_types[62]
+#define SWIGTYPE_p_FXRealSlider swig_types[63]
+#define SWIGTYPE_p_FXRealSpinner swig_types[64]
+#define SWIGTYPE_p_FXRecentFiles swig_types[65]
+#define SWIGTYPE_p_FXRegion swig_types[66]
+#define SWIGTYPE_p_FXRegistry swig_types[67]
+#define SWIGTYPE_p_FXRootWindow swig_types[68]
+#define SWIGTYPE_p_FXRuler swig_types[69]
+#define SWIGTYPE_p_FXRulerView swig_types[70]
+#define SWIGTYPE_p_FXScrollArea swig_types[71]
+#define SWIGTYPE_p_FXScrollBar swig_types[72]
+#define SWIGTYPE_p_FXScrollCorner swig_types[73]
+#define SWIGTYPE_p_FXScrollWindow swig_types[74]
+#define SWIGTYPE_p_FXSeparator swig_types[75]
+#define SWIGTYPE_p_FXSettings swig_types[76]
+#define SWIGTYPE_p_FXShell swig_types[77]
+#define SWIGTYPE_p_FXShutter swig_types[78]
+#define SWIGTYPE_p_FXShutterItem swig_types[79]
+#define SWIGTYPE_p_FXSlider swig_types[80]
+#define SWIGTYPE_p_FXSpinner swig_types[81]
+#define SWIGTYPE_p_FXSplashWindow swig_types[82]
+#define SWIGTYPE_p_FXSplitter swig_types[83]
+#define SWIGTYPE_p_FXSpring swig_types[84]
+#define SWIGTYPE_p_FXStatusBar swig_types[85]
+#define SWIGTYPE_p_FXStatusLine swig_types[86]
+#define SWIGTYPE_p_FXStream swig_types[87]
+#define SWIGTYPE_p_FXStringDict swig_types[88]
+#define SWIGTYPE_p_FXSwitcher swig_types[89]
+#define SWIGTYPE_p_FXTabBar swig_types[90]
+#define SWIGTYPE_p_FXTabBook swig_types[91]
+#define SWIGTYPE_p_FXTextField swig_types[92]
+#define SWIGTYPE_p_FXToolBar swig_types[93]
+#define SWIGTYPE_p_FXToolBarGrip swig_types[94]
+#define SWIGTYPE_p_FXToolBarShell swig_types[95]
+#define SWIGTYPE_p_FXToolBarTab swig_types[96]
+#define SWIGTYPE_p_FXToolTip swig_types[97]
+#define SWIGTYPE_p_FXTopWindow swig_types[98]
+#define SWIGTYPE_p_FXTranslator swig_types[99]
+#define SWIGTYPE_p_FXTreeItem swig_types[100]
+#define SWIGTYPE_p_FXTreeListBox swig_types[101]
+#define SWIGTYPE_p_FXVerticalFrame swig_types[102]
+#define SWIGTYPE_p_FXVerticalSeparator swig_types[103]
+#define SWIGTYPE_p_FXVisual swig_types[104]
+#define SWIGTYPE_p_FXWindow swig_types[105]
+#define SWIGTYPE_p_char swig_types[106]
+#define SWIGTYPE_p_double swig_types[107]
+#define SWIGTYPE_p_float swig_types[108]
+#define SWIGTYPE_p_int swig_types[109]
+#define SWIGTYPE_p_long swig_types[110]
+#define SWIGTYPE_p_short swig_types[111]
+#define SWIGTYPE_p_unsigned_char swig_types[112]
+#define SWIGTYPE_p_unsigned_int swig_types[113]
+#define SWIGTYPE_p_unsigned_long swig_types[114]
+#define SWIGTYPE_p_unsigned_short swig_types[115]
+static swig_type_info *swig_types[117];
+static swig_module_info swig_module = {swig_types, 116, 0, 0, 0, 0};
+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
+
+/* -------- TYPES TABLE (END) -------- */
+
+#define SWIG_init    Init_ui
+#define SWIG_name    "Ui"
+
+
+
+#define SWIG_RUBY_THREAD_BEGIN_BLOCK
+#define SWIG_RUBY_THREAD_END_BLOCK
+
+
+#define SWIGVERSION 0x030012 
+#define SWIG_VERSION SWIGVERSION
+
+
+#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
+
+
+#include <stdexcept>
+
+
+#include "FXRbCommon.h"
+
+
+inline FXColor to_FXColor(VALUE obj){
+  if(TYPE(obj)==T_STRING){
+    return fxcolorfromname(StringValuePtr(obj));
+    }
+  else if(TYPE(obj)==T_SYMBOL){
+    return fxcolorfromname(rb_id2name(SYM2ID(obj)));
+    }
+  else{
+    return NUM2ULONG(obj);
+    }
+  }
+
+
+inline FXString to_FXString(VALUE obj){
+  if(!NIL_P(obj)){
+    Check_Type(obj,T_STRING);
+    return FXString(StringValuePtr(obj));
+    }
+  else{
+    return FXString::null;
+    }
+  }
+
+
+inline FXbool to_FXbool(VALUE obj){
+  if (obj == Qtrue || obj == Qfalse){
+    return (obj == Qtrue) ? TRUE : FALSE;
+    }
+  else{
+    return static_cast<FXbool>(NUM2UINT(obj));
+    }
+  }
+
+
+static swig_type_info* FXEventTypeInfo=0;
+
+inline void* to_FXEvent(VALUE obj){
+  void* ptr;
+  if(!FXEventTypeInfo){
+    FXEventTypeInfo=SWIG_TypeQuery("FXEvent *");
+    FXASSERT(FXEventTypeInfo!=0);
+    }
+  SWIG_ConvertPtr(obj,&ptr,FXEventTypeInfo,1);
+  return ptr;
+  }
+
+
+#include <limits.h>
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
+#endif
+
+
+  #define SWIG_From_long   LONG2NUM 
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_int  (int value)
+{    
+  return SWIG_From_long  (value);
+}
+
+SWIGINTERN FX7Segment *new_FX7Segment(FXComposite *p,FXString const &text,FXuint opts=SEVENSEGMENT_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRb7Segment(p,text,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_long  (unsigned long value)
+{
+  return ULONG2NUM(value); 
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_int  (unsigned int value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+
+SWIGINTERNINLINE VALUE
+SWIG_From_bool  (bool value)
+{
+  return value ? Qtrue : Qfalse;
+}
+
+
+SWIGINTERN swig_type_info*
+SWIG_pchar_descriptor(void)
+{
+  static int init = 0;
+  static swig_type_info* info = 0;
+  if (!init) {
+    info = SWIG_TypeQuery("_p_char");
+    init = 1;
+  }
+  return info;
+}
+
+
+SWIGINTERN int
+SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
+{
+  if (TYPE(obj) == T_STRING) {
+    char *cstr = StringValuePtr(obj); 
+    size_t size = RSTRING_LEN(obj) + 1;
+    if (cptr)  {
+      if (alloc) {
+	if (*alloc == SWIG_NEWOBJ) {
+	  *cptr = reinterpret_cast< char* >(memcpy(new char[size], cstr, sizeof(char)*(size)));
+	} else {
+	  *cptr = cstr;
+	  *alloc = SWIG_OLDOBJ;
+	}
+      }
+    }
+    if (psize) *psize = size;
+    return SWIG_OK;
+  } else {
+    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+    if (pchar_descriptor) {
+      void* vptr = 0;
+      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
+	if (cptr) *cptr = (char *)vptr;
+	if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
+	if (alloc) *alloc = SWIG_OLDOBJ;
+	return SWIG_OK;
+      }
+    }
+  }  
+  return SWIG_TypeError;
+}
+
+
+
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
+{
+  if (carray) {
+    if (size > LONG_MAX) {
+      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+      return pchar_descriptor ? 
+	SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : Qnil;
+    } else {
+      return rb_str_new(carray, static_cast< long >(size));
+    }
+  } else {
+    return Qnil;
+  }
+}
+
+
+SWIGINTERNINLINE VALUE 
+SWIG_FromCharPtr(const char *cptr)
+{ 
+  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
+}
+
+SWIGINTERN FXSpinner *new_FXSpinner(FXComposite *p,FXint cols,FXObject *tgt=0,FXSelector sel=0,FXuint opts=SPIN_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbSpinner(p,cols,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN void FXSpinner_setRange(FXSpinner *self,VALUE range,FXbool notify=0){
+      FXint lo,hi;
+      FXRbRange2LoHi(range,lo,hi);
+      self->setRange(lo,hi);
+      }
+SWIGINTERN VALUE FXSpinner_getRange(FXSpinner const *self){
+      FXint lo,hi;
+      self->getRange(lo,hi);
+      return rb_range_new(INT2NUM(lo),INT2NUM(hi),0);
+      }
+SWIGINTERN FXRealSpinner *new_FXRealSpinner(FXComposite *p,FXint cols,FXObject *tgt=0,FXSelector sel=0,FXuint opts=REALSPIN_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbRealSpinner(p,cols,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+
+SWIGINTERN VALUE
+SWIG_ruby_failed(VALUE, VALUE)
+{
+  return Qnil;
+} 
+
+
+/*@SWIG:/usr/share/swig3.0/ruby/rubyprimtypes.swg,19,%ruby_aux_method@*/
+SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE pargs){VALUE *args=(VALUE *)pargs;
+  VALUE obj = args[0];
+  VALUE type = TYPE(obj);
+  double *res = (double *)(args[1]);
+  *res = NUM2DBL(obj); (void)type;
+  return obj;
+}
+/*@SWIG@*/
+
+SWIGINTERN int
+SWIG_AsVal_double (VALUE obj, double *val)
+{
+  VALUE type = TYPE(obj);
+  if ((type == T_FLOAT) || (type == T_FIXNUM) || (type == T_BIGNUM)) {
+    double v;
+    VALUE a[2];
+    a[0] = obj;
+    a[1] = (VALUE)(&v);
+    if (rb_rescue(RUBY_VALUE_METHOD_FUNC(SWIG_AUX_NUM2DBL), (VALUE)a, RUBY_VALUE_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
+      if (val) *val = v;
+      return SWIG_OK;
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+  #define SWIG_From_double   rb_float_new 
+
+SWIGINTERN void FXRealSpinner_setRange(FXRealSpinner *self,VALUE range,FXbool notify=0){
+      FXdouble lo,hi;
+      FXRbRange2LoHi(range,lo,hi);
+      self->setRange(lo,hi);
+      }
+SWIGINTERN VALUE FXRealSpinner_getRange(FXRealSpinner const *self){
+      FXdouble lo,hi;
+      self->getRange(lo,hi);
+      return rb_range_new(rb_float_new(lo),rb_float_new(hi),0);
+      }
+SWIGINTERN FXCanvas *new_FXCanvas(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=FRAME_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbCanvas(p,tgt,sel,opts,x,y,w,h);
+      }
+
+static swig_type_info *FXCanvas_dynamic_cast(void **ptr) {
+    FXCanvas **ppCanvas = reinterpret_cast<FXCanvas **>(ptr);
+    FXGLCanvas *pGLCanvas=dynamic_cast<FXGLCanvas*>(*ppCanvas);
+    if(pGLCanvas){
+      *ptr=reinterpret_cast<void*>(pGLCanvas);
+      return SWIG_TypeQuery("FXGLCanvas *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXToolTip *new_FXToolTip(FXApp *a,FXuint opts=TOOLTIP_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbToolTip(a,opts,x,y,w,h);
+      }
+SWIGINTERN FXDockBar *new_FXDockBar__SWIG_0(FXComposite *p,FXComposite *q,FXuint opts=LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=3,FXint pr=3,FXint pt=2,FXint pb=2,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING){
+      return new FXRbDockBar(p,q,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+SWIGINTERN FXDockBar *new_FXDockBar__SWIG_1(FXComposite *p,FXuint opts,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=2,FXint pr=3,FXint pt=3,FXint pb=2,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING){
+      return new FXRbDockBar(p,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+
+SWIGINTERNINLINE VALUE
+SWIG_From_unsigned_SS_char  (unsigned char value)
+{    
+  return SWIG_From_unsigned_SS_long  (value);
+}
+
+
+static swig_type_info *FXDockBar_dynamic_cast(void **ptr) {
+    FXDockBar **ppDockBar = reinterpret_cast<FXDockBar **>(ptr);
+    FXToolBar *pToolBar=dynamic_cast<FXToolBar*>(*ppDockBar);
+    if(pToolBar){
+      *ptr=reinterpret_cast<void*>(pToolBar);
+      return SWIG_TypeQuery("FXToolBar *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXToolBar *new_FXToolBar__SWIG_0(FXComposite *p,FXComposite *q,FXuint opts=LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=3,FXint pr=3,FXint pt=2,FXint pb=2,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING){
+      return new FXRbToolBar(p,q,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+SWIGINTERN FXToolBar *new_FXToolBar__SWIG_1(FXComposite *p,FXuint opts=LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=2,FXint pr=3,FXint pt=3,FXint pb=2,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING){
+      return new FXRbToolBar(p,opts,x,y,w,h,pl,pr,pt,pb,hs,vs);
+      }
+SWIGINTERN FXTabBar *new_FXTabBar(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=TABBOOK_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_SPACING,FXint pr=DEFAULT_SPACING,FXint pt=DEFAULT_SPACING,FXint pb=DEFAULT_SPACING){
+      return new FXRbTabBar(p,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+
+static swig_type_info *FXTabBar_dynamic_cast(void **ptr) {
+    FXTabBar **ppTabBar = reinterpret_cast<FXTabBar **>(ptr);
+    FXTabBook *pTabBook=dynamic_cast<FXTabBook*>(*ppTabBar);
+    if(pTabBook){
+      *ptr=reinterpret_cast<void*>(pTabBook);
+      return SWIG_TypeQuery("FXTabBook *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXTabBook *new_FXTabBook(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=TABBOOK_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_SPACING,FXint pr=DEFAULT_SPACING,FXint pt=DEFAULT_SPACING,FXint pb=DEFAULT_SPACING){
+      return new FXRbTabBook(p,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN FXScrollBar *new_FXScrollBar(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=SCROLLBAR_VERTICAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbScrollBar(p,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN FXint FXScrollBar_position__SWIG_0(FXScrollBar const *self){
+      return self->getPosition();
+      }
+SWIGINTERN FXScrollCorner *new_FXScrollCorner(FXComposite *p){
+      return new FXRbScrollCorner(p);
+      }
+SWIGINTERN FXComboBox *new_FXComboBox(FXComposite *p,FXint cols,FXObject *tgt=0,FXSelector sel=0,FXuint opts=COMBOBOX_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbComboBox(p,cols,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN void FXComboBox_setItemData(FXComboBox *self,FXint index,VALUE ptr){
+      self->setItemData(index, (void*) ptr);
+      }
+SWIGINTERN VALUE FXComboBox_getItemData(FXComboBox const *self,FXint index){
+      return self->getItemData(index) ? (VALUE) self->getItemData(index) : Qnil;
+      }
+SWIGINTERN FXListBox *new_FXListBox(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=FRAME_SUNKEN|FRAME_THICK|LISTBOX_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbListBox(p,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN void FXListBox_setItemData(FXListBox *self,FXint index,VALUE ptr){
+      self->setItemData(index, (void*) ptr);
+      }
+SWIGINTERN VALUE FXListBox_getItemData(FXListBox const *self,FXint index){
+      return self->getItemData(index) ? (VALUE) self->getItemData(index) : Qnil;
+      }
+
+static swig_type_info *FXListBox_dynamic_cast(void **ptr) {
+    FXListBox **ppListBox = reinterpret_cast<FXListBox **>(ptr);
+    FXDriveBox *pDriveBox=dynamic_cast<FXDriveBox*>(*ppListBox);
+    if(pDriveBox){
+      *ptr=reinterpret_cast<void*>(pDriveBox);
+      return SWIG_TypeQuery("FXDriveBox *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXTreeListBox *new_FXTreeListBox(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=FRAME_SUNKEN|FRAME_THICK|TREELISTBOX_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbTreeListBox(p,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN FXTreeItem *FXTreeListBox_insertItem__SWIG_0(FXTreeListBox *self,FXTreeItem *other,FXTreeItem *father,FXTreeItem *item){
+      if(item->isMemberOf(FXMETACLASS(FXRbTreeItem))){
+        dynamic_cast<FXRbTreeItem*>(item)->owned=1;
+        }
+      return self->insertItem(other,father,item);
+      }
+SWIGINTERN FXTreeItem *FXTreeListBox_appendItem__SWIG_0(FXTreeListBox *self,FXTreeItem *father,FXTreeItem *item){
+      if(item->isMemberOf(FXMETACLASS(FXRbTreeItem))){
+        dynamic_cast<FXRbTreeItem*>(item)->owned=1;
+        }
+      return self->appendItem(father,item);
+      }
+SWIGINTERN FXTreeItem *FXTreeListBox_prependItem__SWIG_0(FXTreeListBox *self,FXTreeItem *father,FXTreeItem *item){
+      if(item->isMemberOf(FXMETACLASS(FXRbTreeItem))){
+        dynamic_cast<FXRbTreeItem*>(item)->owned=1;
+        }
+      return self->prependItem(father,item);
+      }
+SWIGINTERN void FXTreeListBox_removeItem(FXTreeListBox *self,FXTreeItem *item){
+      // Save pointer(s) to the soon-to-be-destroyed items
+      FXObjectListOf<FXTreeItem> items;
+      FXRbTreeList::enumerateItem(item,items);
+
+      // Do the deed
+      self->removeItem(item);
+
+      // Now zero-out pointers held by still-alive Ruby objects
+      for(FXint i=0;i<items.no();i++){
+        FXRbUnregisterRubyObj(items[i]);
+        }
+      }
+SWIGINTERN void FXTreeListBox_removeItems(FXTreeListBox *self,FXTreeItem *fm,FXTreeItem *to){
+      // Save pointer(s) to the soon-to-be-destroyed items
+      FXObjectListOf<FXTreeItem> items;
+      FXRbTreeList::enumerateItems(fm,to,items);
+
+      // Do the deed
+      self->removeItems(fm,to);
+
+      // Now zero-out pointers held by still-alive Ruby objects
+      for(FXint i=0;i<items.no();i++){
+        FXRbUnregisterRubyObj(items[i]);
+        }
+      }
+SWIGINTERN void FXTreeListBox_clearItems(FXTreeListBox *self){
+      // Save pointer(s) to the soon-to-be-destroyed items
+      FXObjectListOf<FXTreeItem> items;
+      FXRbTreeList::enumerateItems(self->getFirstItem(),self->getLastItem(),items);
+
+      // Do the deed
+      self->clearItems();
+
+      // Now zero-out pointers held by still-alive Ruby objects
+      for(FXint i=0;i<items.no();i++){
+        FXRbUnregisterRubyObj(items[i]);
+        }
+      }
+SWIGINTERN void FXTreeListBox_setItemData(FXTreeListBox *self,FXTreeItem *item,VALUE ptr){
+      self->setItemData(item,(void*) ptr);
+      }
+SWIGINTERN VALUE FXTreeListBox_getItemData(FXTreeListBox const *self,FXTreeItem const *item){
+      return self->getItemData(item) ? (VALUE) self->getItemData(item) : Qnil;
+      }
+
+static swig_type_info *FXTreeListBox_dynamic_cast(void **ptr) {
+    FXTreeListBox **ppTreeListBox = reinterpret_cast<FXTreeListBox **>(ptr);
+    FXDirBox *pDirBox=dynamic_cast<FXDirBox*>(*ppTreeListBox);
+    if(pDirBox){
+      *ptr=reinterpret_cast<void*>(pDirBox);
+      return SWIG_TypeQuery("FXDirBox *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXImageView *new_FXImageView(FXComposite *p,FXImage *img=0,FXObject *tgt=0,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbImageView(p,img,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN VALUE FXImageView_position__SWIG_1(FXImageView const *self){
+    FXint x, y;
+    self->getPosition(x, y);
+    VALUE pos = rb_ary_new();
+    rb_ary_push(pos, INT2NUM(x));
+    rb_ary_push(pos, INT2NUM(y));
+    return pos;
+  }
+SWIGINTERN FXDragCorner *new_FXDragCorner(FXComposite *p){
+      return new FXRbDragCorner(p);
+      }
+SWIGINTERN FXDirBox *new_FXDirBox(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=FRAME_SUNKEN|FRAME_THICK|TREELISTBOX_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbDirBox(p,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN FXDriveBox *new_FXDriveBox(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=FRAME_SUNKEN|FRAME_THICK|LISTBOX_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD){
+      return new FXRbDriveBox(p,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN FXDirSelector *new_FXDirSelector(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbDirSelector(p,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN FXFileSelector *new_FXFileSelector(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbFileSelector(p,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN VALUE FXFileSelector_getFilenames(FXFileSelector const *self){
+        VALUE result = rb_ary_new();
+        FXString *filenames = self->getFilenames();
+        if (filenames) {
+            register FXString *p = filenames;
+            while ((*p) != FXString::null) {
+                rb_ary_push(result, to_ruby(*p));
+                p++;
+            }
+            delete [] filenames;
+        }
+        return result;
+    }
+SWIGINTERN void FXFileSelector_setPatternList(FXFileSelector *self,VALUE ary){
+      FXString patterns;
+      if(TYPE(ary)==T_STRING){
+        patterns=FXString(StringValuePtr(ary));
+        }
+      else if(TYPE(ary)==T_ARRAY){
+        for(long i=0; i<RARRAY_LEN(ary); i++){
+          VALUE obj=rb_ary_entry(ary,i);
+          Check_Type(obj,T_STRING);
+          patterns+=FXString(StringValuePtr(obj))+FXString("\n");
+          }
+        }
+      else{
+        rb_raise(rb_eArgError,"expected either a string, or an array of strings, as input");
+        }
+      self->setPatternList(patterns);
+      }
+SWIGINTERN VALUE FXFileSelector_getPatternList(FXFileSelector const *self){
+      FXString pat;
+      FXString patterns;
+      VALUE ary;
+      patterns=self->getPatternList();
+      ary=rb_ary_new();
+      for(FXint start=0;!(pat=patterns.section('\n',start)).empty();start++){
+	rb_ary_push(ary,to_ruby(pat.text()));
+        }
+      return ary;
+    }
+SWIGINTERN FXColorSelector *new_FXColorSelector(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbColorSelector(p,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN FXFontSelector *new_FXFontSelector(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbFontSelector(p,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN FXFontDesc FXFontSelector_getFontSelection(FXFontSelector const *self){
+      FXFontDesc fontdesc;
+      self->getFontSelection(fontdesc);
+      return fontdesc;
+    }
+
+static swig_type_info *FXDockHandler_dynamic_cast(void **ptr) {
+    FXDockHandler **ppDockHandler = reinterpret_cast<FXDockHandler **>(ptr);
+    FXDockTitle *pDockTitle=dynamic_cast<FXDockTitle*>(*ppDockHandler);
+    if(pDockTitle){
+      *ptr=reinterpret_cast<void*>(pDockTitle);
+      return SWIG_TypeQuery("FXDockTitle *");
+      }
+    FXToolBarGrip *pToolBarGrip=dynamic_cast<FXToolBarGrip*>(*ppDockHandler);
+    if(pToolBarGrip){
+      *ptr=reinterpret_cast<void*>(pToolBarGrip);
+      return SWIG_TypeQuery("FXToolBarGrip *");
+      }
+    return 0;
+}
+
+SWIGINTERN FXDockTitle *new_FXDockTitle(FXComposite *p,FXString const &text,FXObject *tgt=0,FXSelector sel=0,FXuint opts=FRAME_NORMAL|JUSTIFY_CENTER_X|JUSTIFY_CENTER_Y,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=0,FXint pr=0,FXint pt=0,FXint pb=0){
+      return new FXRbDockTitle(p,text,tgt,sel,opts,x,y,w,h,pl,pr,pt,pb);
+      }
+SWIGINTERN FXToolBarGrip *new_FXToolBarGrip(FXToolBar *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=TOOLBARGRIP_SINGLE,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbToolBarGrip(p,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN FXToolBarShell *new_FXToolBarShell(FXWindow *owner,FXuint opts=FRAME_RAISED|FRAME_THICK,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint hs=4,FXint vs=4){
+      return new FXRbToolBarShell(owner,opts,x,y,w,h,hs,vs);
+      }
+SWIGINTERN FXRulerView *new_FXRulerView(FXComposite *p,FXObject *tgt=0,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0){
+      return new FXRbRulerView(p,tgt,sel,opts,x,y,w,h);
+      }
+SWIGINTERN VALUE FXRulerView_position__SWIG_1(FXRulerView const *self){
+    FXint x, y;
+    self->getPosition(x, y);
+    VALUE pos = rb_ary_new();
+    rb_ary_push(pos, INT2NUM(x));
+    rb_ary_push(pos, INT2NUM(y));
+    return pos;
+  }
+static swig_class SwigClassFX7Segment;
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_onPaint(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdSetValue", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdSetIntValue", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_onCmdSetRealValue(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","onCmdSetRealValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetRealValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdSetRealValue", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdSetRealValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_onCmdSetStringValue(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","onCmdSetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdSetStringValue", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdSetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetIntValue", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_onCmdGetRealValue(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","onCmdGetRealValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetRealValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetRealValue", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetRealValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_onCmdGetStringValue(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","onCmdGetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetStringValue", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_onCmdSetHelp(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","onCmdSetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdSetHelp", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdSetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_onCmdGetHelp(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","onCmdGetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetHelp", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_onCmdSetTip(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","onCmdSetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdSetTip", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdSetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_onCmdGetTip(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","onCmdGetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetTip", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onQueryHelp", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onQueryTip", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FX7Segment_allocate(VALUE self)
+#else
+_wrap_FX7Segment_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FX7Segment);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FX7Segment(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXString *arg2 = 0 ;
+  FXuint arg3 = (FXuint) SEVENSEGMENT_NORMAL ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) DEFAULT_PAD ;
+  FXint arg9 = (FXint) DEFAULT_PAD ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FX7Segment *result = 0 ;
+  
+  if ((argc < 2) || (argc > 11)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FX7Segment", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FX7Segment *)new_FX7Segment(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_texte___(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","setText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_text(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment const *","getText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  result = ((FX7Segment const *)arg1)->getText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_textColore___(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","setTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_textColor(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment const *","getTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  result = (FXColor)((FX7Segment const *)arg1)->getTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_cellWidthe___(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","setCellWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setCellWidth(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_cellWidth(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment const *","getCellWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  result = (FXint)((FX7Segment const *)arg1)->getCellWidth();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_cellHeighte___(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","setCellHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setCellHeight(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_cellHeight(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment const *","getCellHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  result = (FXint)((FX7Segment const *)arg1)->getCellHeight();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_thicknesse___(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","setThickness", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setThickness(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_thickness(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment const *","getThickness", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  result = (FXint)((FX7Segment const *)arg1)->getThickness();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_set7SegmentStyle(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","set7SegmentStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->set7SegmentStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_get7SegmentStyle(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment const *","get7SegmentStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  result = (FXuint)((FX7Segment const *)arg1)->get7SegmentStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_justifye___(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","setJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setJustify(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_justify(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment const *","getJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  result = (FXuint)((FX7Segment const *)arg1)->getJustify();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_helpTexte___(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_helpText(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  result = (FXString *) &((FX7Segment const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_tipTexte___(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_tipText(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  result = (FXString *) &((FX7Segment const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_save(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FX7Segment_save((FX7Segment const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_load(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FX7Segment_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_create(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  FX7Segment_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_detach(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  FX7Segment_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_destroy(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  FX7Segment_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_resize(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FX7Segment_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  result = (FXint)FX7Segment_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  result = (FXint)FX7Segment_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FX7Segment_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FX7Segment_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_canFocus(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  result = (bool)FX7Segment_canFocus((FX7Segment const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_setFocus(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  FX7Segment_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_killFocus(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  FX7Segment_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FX7Segment_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_setDefault(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FX7Segment_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_enable(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  FX7Segment_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_disable(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  FX7Segment_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  FX7Segment_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_lower(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  FX7Segment_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_move(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FX7Segment_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_position(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FX7Segment_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_layout(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  FX7Segment_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_recalc(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  FX7Segment_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_reparent(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FX7Segment_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_show(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  FX7Segment_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_hide(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  FX7Segment_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_isComposite(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  result = (bool)FX7Segment_isComposite((FX7Segment const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_contains(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FX7Segment_contains((FX7Segment const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  result = (bool)FX7Segment_doesSaveUnder((FX7Segment const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FX7Segment_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_tr(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FX7Segment_tr((FX7Segment const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  FX7Segment_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  FX7Segment_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FX7Segment_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FX7Segment_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FX7Segment_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FX7Segment_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FX7Segment, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FX7Segment_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FX7Segment, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FX7Segment_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FX7Segment, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FX7Segment_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FX7Segment_clearShape(int argc, VALUE *argv, VALUE self) {
+  FX7Segment *arg1 = (FX7Segment *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FX7Segment, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FX7Segment *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FX7Segment * >(argp1);
+  FX7Segment_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXSpinner;
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_onUpdIncrement(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","onUpdIncrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdIncrement", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdIncrement(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_onCmdIncrement(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","onCmdIncrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdIncrement", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onCmdIncrement(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_onUpdDecrement(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","onUpdDecrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdDecrement", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdDecrement(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_onCmdDecrement(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","onCmdDecrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDecrement", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onCmdDecrement(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_onCmdEntry(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","onCmdEntry", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdEntry", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdEntry(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_onChgEntry(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","onChgEntry", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onChgEntry", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onChgEntry(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_onWheelEntry(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","onWheelEntry", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onWheelEntry", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onWheelEntry(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXint) NUM2INT(argv[2]);
+    arg4 = static_cast<void*>(&value4);
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_onCmdSetIntRange(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint values4[2] ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","onCmdSetIntRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    Check_Type(argv[2], T_ARRAY);
+    values4[0] = (FXint) NUM2INT(rb_ary_entry(argv[2], 0));
+    values4[1] = (FXint) NUM2INT(rb_ary_entry(argv[2], 1));
+    arg4 = static_cast<void*>(values4);
+  }
+  result = (long)(arg1)->onCmdSetIntRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_onCmdGetIntRange(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","onCmdGetIntRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetIntRange", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetIntRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_onFocusSelf(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","onFocusSelf", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusSelf", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusSelf(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXSpinner_allocate(VALUE self)
+#else
+_wrap_FXSpinner_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXSpinner);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXSpinner(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXint arg2 ;
+  FXObject *arg3 = (FXObject *) 0 ;
+  FXSelector arg4 = (FXSelector) 0 ;
+  FXuint arg5 = (FXuint) SPIN_NORMAL ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  FXint arg13 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXSpinner *result = 0 ;
+  
+  if ((argc < 2) || (argc > 13)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXSpinner", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  arg2 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXObject *","FXSpinner", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXObject * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXSpinner *)new_FXSpinner(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_increment(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","increment", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->increment(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_incrementByAmount(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","incrementByAmount", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->incrementByAmount(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_decrement(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","decrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->decrement(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_decrementByAmount(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","decrementByAmount", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->decrementByAmount(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_isCyclic(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner const *","isCyclic", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  result = (FXbool)((FXSpinner const *)arg1)->isCyclic();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_setCyclic(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","setCyclic", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->setCyclic(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_isTextVisible(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner const *","isTextVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  result = (FXbool)((FXSpinner const *)arg1)->isTextVisible();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_setTextVisible(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","setTextVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->setTextVisible(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_getValue(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner const *","getValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  result = (FXint)((FXSpinner const *)arg1)->getValue();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_setRange(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","setRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  arg2 = argv[0];
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXSpinner_setRange(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_getRange(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner const *","getRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  result = (VALUE)FXSpinner_getRange((FXSpinner const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_setIncrement(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","setIncrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setIncrement(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_getIncrement(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner const *","getIncrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  result = (FXint)((FXSpinner const *)arg1)->getIncrement();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_setFont(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  (arg1)->setFont(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_getFont(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  result = (FXFont *)((FXSpinner const *)arg1)->getFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  result = (FXString *) &((FXSpinner const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_setTipText(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_getTipText(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  result = (FXString *) &((FXSpinner const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_setSpinnerStyle(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","setSpinnerStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setSpinnerStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_getSpinnerStyle(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner const *","getSpinnerStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  result = (FXuint)((FXSpinner const *)arg1)->getSpinnerStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_setEditable(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","setEditable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->setEditable(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_isEditable(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner const *","isEditable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  result = (FXbool)((FXSpinner const *)arg1)->isEditable();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_setUpArrowColor(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","setUpArrowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setUpArrowColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_getUpArrowColor(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner const *","getUpArrowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  result = (FXColor)((FXSpinner const *)arg1)->getUpArrowColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_setDownArrowColor(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","setDownArrowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setDownArrowColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_getDownArrowColor(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner const *","getDownArrowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  result = (FXColor)((FXSpinner const *)arg1)->getDownArrowColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_setTextColor(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","setTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_getTextColor(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner const *","getTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  result = (FXColor)((FXSpinner const *)arg1)->getTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_setSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","setSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelBackColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_getSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner const *","getSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  result = (FXColor)((FXSpinner const *)arg1)->getSelBackColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_setSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","setSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_getSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner const *","getSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  result = (FXColor)((FXSpinner const *)arg1)->getSelTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_setCursorColor(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","setCursorColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setCursorColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_getCursorColor(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner const *","getCursorColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  result = (FXColor)((FXSpinner const *)arg1)->getCursorColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_setNumColumns(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","setNumColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setNumColumns(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_getNumColumns(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner const *","getNumColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  result = (FXint)((FXSpinner const *)arg1)->getNumColumns();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_save(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXSpinner_save((FXSpinner const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_load(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXSpinner_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_create(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  FXSpinner_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_detach(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  FXSpinner_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_destroy(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  FXSpinner_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_resize(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXSpinner_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  result = (FXint)FXSpinner_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  result = (FXint)FXSpinner_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXSpinner_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXSpinner_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  result = (bool)FXSpinner_canFocus((FXSpinner const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  FXSpinner_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  FXSpinner_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXSpinner_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXSpinner_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_enable(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  FXSpinner_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_disable(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  FXSpinner_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  FXSpinner_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_lower(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  FXSpinner_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_move(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXSpinner_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_position(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXSpinner_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_layout(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  FXSpinner_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_recalc(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  FXSpinner_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_reparent(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXSpinner_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_show(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  FXSpinner_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_hide(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  FXSpinner_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  result = (bool)FXSpinner_isComposite((FXSpinner const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_contains(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXSpinner_contains((FXSpinner const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  result = (bool)FXSpinner_doesSaveUnder((FXSpinner const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXSpinner_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_tr(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXSpinner_tr((FXSpinner const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  FXSpinner_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  FXSpinner_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXSpinner_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXSpinner_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXSpinner_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXSpinner_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSpinner, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSpinner_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSpinner, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSpinner_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXSpinner, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXSpinner_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  FXSpinner_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXSpinner_setValue(int argc, VALUE *argv, VALUE self) {
+  FXSpinner *arg1 = (FXSpinner *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXSpinner *","setValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXSpinner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXSpinner_setValue(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXRealSpinner;
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_onUpdIncrement(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","onUpdIncrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdIncrement", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdIncrement(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_onCmdIncrement(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","onCmdIncrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdIncrement", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onCmdIncrement(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_onUpdDecrement(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","onUpdDecrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdDecrement", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdDecrement(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_onCmdDecrement(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","onCmdDecrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDecrement", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onCmdDecrement(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_onCmdEntry(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","onCmdEntry", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdEntry", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdEntry(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_onChgEntry(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","onChgEntry", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onChgEntry", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onChgEntry(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_onWheelEntry(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","onWheelEntry", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onWheelEntry", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onWheelEntry(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXint) NUM2INT(argv[2]);
+    arg4 = static_cast<void*>(&value4);
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_onCmdSetIntRange(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint values4[2] ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","onCmdSetIntRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    Check_Type(argv[2], T_ARRAY);
+    values4[0] = (FXint) NUM2INT(rb_ary_entry(argv[2], 0));
+    values4[1] = (FXint) NUM2INT(rb_ary_entry(argv[2], 1));
+    arg4 = static_cast<void*>(values4);
+  }
+  result = (long)(arg1)->onCmdSetIntRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_onCmdGetIntRange(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","onCmdGetIntRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetIntRange", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetIntRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_onCmdSetRealValue(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXdouble value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","onCmdSetRealValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetRealValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXdouble) NUM2DBL(argv[2]);
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetRealValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_onCmdGetRealValue(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","onCmdGetRealValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetRealValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetRealValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_onCmdSetRealRange(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXdouble values4[2] ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","onCmdSetRealRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetRealRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    Check_Type(argv[2], T_ARRAY);
+    values4[0] = (FXdouble) NUM2DBL(rb_ary_entry(argv[2], 0));
+    values4[1] = (FXdouble) NUM2DBL(rb_ary_entry(argv[2], 1));
+    arg4 = (void *) values4;
+  }
+  result = (long)(arg1)->onCmdSetRealRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_onCmdGetRealRange(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","onCmdGetRealRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetRealRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetRealRange", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetRealRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_onFocusSelf(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","onFocusSelf", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusSelf", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusSelf(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXRealSpinner_allocate(VALUE self)
+#else
+_wrap_FXRealSpinner_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXRealSpinner);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRealSpinner(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXint arg2 ;
+  FXObject *arg3 = (FXObject *) 0 ;
+  FXSelector arg4 = (FXSelector) 0 ;
+  FXuint arg5 = (FXuint) REALSPIN_NORMAL ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  FXint arg13 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXRealSpinner *result = 0 ;
+  
+  if ((argc < 2) || (argc > 13)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXRealSpinner", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  arg2 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXObject *","FXRealSpinner", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXObject * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXRealSpinner *)new_FXRealSpinner(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_increment(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","increment", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->increment(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_incrementByAmount(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXdouble arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","incrementByAmount", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","incrementByAmount", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->incrementByAmount(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_decrement(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","decrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->decrement(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_decrementByAmount(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXdouble arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","decrementByAmount", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","decrementByAmount", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->decrementByAmount(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_isCyclic(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","isCyclic", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  result = (FXbool)((FXRealSpinner const *)arg1)->isCyclic();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_setCyclic(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setCyclic", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->setCyclic(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_isTextVisible(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","isTextVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  result = (FXbool)((FXRealSpinner const *)arg1)->isTextVisible();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_setTextVisible(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setTextVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->setTextVisible(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_getValue(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","getValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  result = (FXdouble)((FXRealSpinner const *)arg1)->getValue();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_setRange(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  arg2 = argv[0];
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXRealSpinner_setRange(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_getRange(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","getRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  result = (VALUE)FXRealSpinner_getRange((FXRealSpinner const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_setIncrement(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setIncrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","setIncrement", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  (arg1)->setIncrement(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_getIncrement(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","getIncrement", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  result = (FXdouble)((FXRealSpinner const *)arg1)->getIncrement();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_granularitye___(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXdouble arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setGranularity", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","setGranularity", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  (arg1)->setGranularity(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_granularity(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","getGranularity", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  result = (FXdouble)((FXRealSpinner const *)arg1)->getGranularity();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_setFont(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  (arg1)->setFont(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_getFont(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  result = (FXFont *)((FXRealSpinner const *)arg1)->getFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  result = (FXString *) &((FXRealSpinner const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_setTipText(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_getTipText(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  result = (FXString *) &((FXRealSpinner const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_setSpinnerStyle(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setSpinnerStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setSpinnerStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_getSpinnerStyle(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","getSpinnerStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  result = (FXuint)((FXRealSpinner const *)arg1)->getSpinnerStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_setEditable(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setEditable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->setEditable(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_isEditable(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","isEditable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  result = (FXbool)((FXRealSpinner const *)arg1)->isEditable();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_setUpArrowColor(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setUpArrowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setUpArrowColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_getUpArrowColor(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","getUpArrowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  result = (FXColor)((FXRealSpinner const *)arg1)->getUpArrowColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_setDownArrowColor(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setDownArrowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setDownArrowColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_getDownArrowColor(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","getDownArrowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  result = (FXColor)((FXRealSpinner const *)arg1)->getDownArrowColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_setTextColor(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_getTextColor(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","getTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  result = (FXColor)((FXRealSpinner const *)arg1)->getTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_setSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelBackColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_getSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","getSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  result = (FXColor)((FXRealSpinner const *)arg1)->getSelBackColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_setSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_getSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","getSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  result = (FXColor)((FXRealSpinner const *)arg1)->getSelTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_setCursorColor(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setCursorColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setCursorColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_getCursorColor(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","getCursorColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  result = (FXColor)((FXRealSpinner const *)arg1)->getCursorColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_setNumColumns(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setNumColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setNumColumns(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_getNumColumns(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","getNumColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  result = (FXint)((FXRealSpinner const *)arg1)->getNumColumns();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_save(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXRealSpinner_save((FXRealSpinner const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_load(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXRealSpinner_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_create(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  FXRealSpinner_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_detach(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  FXRealSpinner_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_destroy(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  FXRealSpinner_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_resize(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXRealSpinner_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  result = (FXint)FXRealSpinner_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  result = (FXint)FXRealSpinner_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXRealSpinner_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXRealSpinner_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  result = (bool)FXRealSpinner_canFocus((FXRealSpinner const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  FXRealSpinner_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  FXRealSpinner_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXRealSpinner_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXRealSpinner_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_enable(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  FXRealSpinner_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_disable(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  FXRealSpinner_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  FXRealSpinner_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_lower(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  FXRealSpinner_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_move(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXRealSpinner_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_position(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXRealSpinner_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_layout(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  FXRealSpinner_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_recalc(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  FXRealSpinner_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_reparent(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXRealSpinner_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_show(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  FXRealSpinner_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_hide(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  FXRealSpinner_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  result = (bool)FXRealSpinner_isComposite((FXRealSpinner const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_contains(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXRealSpinner_contains((FXRealSpinner const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  result = (bool)FXRealSpinner_doesSaveUnder((FXRealSpinner const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXRealSpinner_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_tr(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXRealSpinner_tr((FXRealSpinner const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  FXRealSpinner_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  FXRealSpinner_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXRealSpinner_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXRealSpinner_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXRealSpinner_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXRealSpinner_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRealSpinner, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRealSpinner_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRealSpinner, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRealSpinner_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRealSpinner, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRealSpinner_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  FXRealSpinner_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRealSpinner_setValue(int argc, VALUE *argv, VALUE self) {
+  FXRealSpinner *arg1 = (FXRealSpinner *) 0 ;
+  FXdouble arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRealSpinner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRealSpinner *","setValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRealSpinner * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","setValue", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXRealSpinner_setValue(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXCanvas;
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXCanvas_allocate(VALUE self)
+#else
+_wrap_FXCanvas_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXCanvas);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXCanvas(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) FRAME_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXCanvas *result = 0 ;
+  
+  if ((argc < 1) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXCanvas", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXCanvas", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXCanvas *)new_FXCanvas(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_save(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXCanvas_save((FXCanvas const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_load(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXCanvas_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_create(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  FXCanvas_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_detach(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  FXCanvas_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_destroy(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  FXCanvas_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_resize(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXCanvas_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  result = (FXint)FXCanvas_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  result = (FXint)FXCanvas_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXCanvas_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXCanvas_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  result = (bool)FXCanvas_canFocus((FXCanvas const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  FXCanvas_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  FXCanvas_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXCanvas_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXCanvas_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_enable(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  FXCanvas_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_disable(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  FXCanvas_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  FXCanvas_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_lower(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  FXCanvas_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_move(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXCanvas_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_position(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXCanvas_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_layout(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  FXCanvas_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_recalc(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  FXCanvas_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_reparent(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXCanvas_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_show(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  FXCanvas_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_hide(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  FXCanvas_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  result = (bool)FXCanvas_isComposite((FXCanvas const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_contains(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXCanvas_contains((FXCanvas const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  result = (bool)FXCanvas_doesSaveUnder((FXCanvas const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXCanvas_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_tr(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXCanvas_tr((FXCanvas const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  FXCanvas_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  FXCanvas_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXCanvas_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXCanvas_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXCanvas_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXCanvas_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXCanvas, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXCanvas_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXCanvas, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXCanvas_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXCanvas, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXCanvas_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXCanvas_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXCanvas *arg1 = (FXCanvas *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXCanvas, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXCanvas *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXCanvas * >(argp1);
+  FXCanvas_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXToolTip;
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_onUpdate(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","onUpdate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdate", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdate(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_onTipShow(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","onTipShow", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTipShow", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onTipShow(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_onTipHide(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","onTipHide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTipHide", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onTipHide(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_onCmdGetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","onCmdGetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_onCmdSetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","onCmdSetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXToolTip_allocate(VALUE self)
+#else
+_wrap_FXToolTip_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXToolTip);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXToolTip(int argc, VALUE *argv, VALUE self) {
+  FXApp *arg1 = (FXApp *) 0 ;
+  FXuint arg2 = (FXuint) TOOLTIP_NORMAL ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXToolTip *result = 0 ;
+  
+  if ((argc < 1) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXApp, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXApp *","FXToolTip", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXApp * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXToolTip *)new_FXToolTip(arg1,arg2,arg3,arg4,arg5,arg6);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_setText(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","setText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_getText(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip const *","getText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  result = ((FXToolTip const *)arg1)->getText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_setFont(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  (arg1)->setFont(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_getFont(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  result = (FXFont *)((FXToolTip const *)arg1)->getFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_getTextColor(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip const *","getTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  result = (FXColor)((FXToolTip const *)arg1)->getTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_setTextColor(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","setTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_save(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXToolTip_save((FXToolTip const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_load(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXToolTip_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_create(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  FXToolTip_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_detach(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  FXToolTip_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_destroy(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  FXToolTip_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_resize(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXToolTip_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  result = (FXint)FXToolTip_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  result = (FXint)FXToolTip_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXToolTip_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXToolTip_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  result = (bool)FXToolTip_canFocus((FXToolTip const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  FXToolTip_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  FXToolTip_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXToolTip_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXToolTip_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_enable(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  FXToolTip_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_disable(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  FXToolTip_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  FXToolTip_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_lower(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  FXToolTip_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_move(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXToolTip_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_position(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXToolTip_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_layout(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  FXToolTip_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_recalc(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  FXToolTip_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_reparent(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXToolTip_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_show(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  FXToolTip_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_hide(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  FXToolTip_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  result = (bool)FXToolTip_isComposite((FXToolTip const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_contains(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXToolTip_contains((FXToolTip const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  result = (bool)FXToolTip_doesSaveUnder((FXToolTip const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXToolTip_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_tr(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXToolTip_tr((FXToolTip const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  FXToolTip_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  FXToolTip_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXToolTip_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXToolTip_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXToolTip_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXToolTip_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToolTip, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXToolTip_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToolTip, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXToolTip_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToolTip, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXToolTip_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolTip_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXToolTip *arg1 = (FXToolTip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolTip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolTip *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolTip * >(argp1);
+  FXToolTip_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXDockBar;
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_onCmdUndock(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","onCmdUndock", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdUndock", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdUndock(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_onUpdUndock(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","onUpdUndock", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdUndock", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdUndock(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_onCmdDockTop(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","onCmdDockTop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDockTop", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDockTop(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_onUpdDockTop(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","onUpdDockTop", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdDockTop", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdDockTop(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_onCmdDockBottom(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","onCmdDockBottom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDockBottom", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDockBottom(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_onUpdDockBottom(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","onUpdDockBottom", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdDockBottom", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdDockBottom(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_onCmdDockLeft(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","onCmdDockLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDockLeft", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDockLeft(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_onUpdDockLeft(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","onUpdDockLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdDockLeft", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdDockLeft(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_onCmdDockRight(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","onCmdDockRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDockRight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDockRight(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_onUpdDockRight(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","onUpdDockRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdDockRight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdDockRight(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_onUpdDockFlip(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","onUpdDockFlip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdDockFlip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdDockFlip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_onBeginDragGrip(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","onBeginDragGrip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onBeginDragGrip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onBeginDragGrip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_onEndDragGrip(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","onEndDragGrip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEndDragGrip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEndDragGrip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_onDraggedGrip(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","onDraggedGrip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDraggedGrip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onDraggedGrip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_onPopupMenu(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","onPopupMenu", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPopupMenu", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPopupMenu(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_onDockTimer(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","onDockTimer", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDockTimer", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onDockTimer", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onDockTimer(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXDockBar__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXComposite *arg2 = (FXComposite *) 0 ;
+  FXuint arg3 = (FXuint) LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 3 ;
+  FXint arg9 = (FXint) 3 ;
+  FXint arg10 = (FXint) 2 ;
+  FXint arg11 = (FXint) 2 ;
+  FXint arg12 = (FXint) DEFAULT_SPACING ;
+  FXint arg13 = (FXint) DEFAULT_SPACING ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXDockBar *result = 0 ;
+  
+  if ((argc < 2) || (argc > 13)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXDockBar", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXComposite *","FXDockBar", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXComposite * >(argp2);
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXDockBar *)new_FXDockBar__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXDockBar_allocate(VALUE self)
+#else
+_wrap_FXDockBar_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXDockBar);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXDockBar__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXuint arg2 ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 2 ;
+  FXint arg8 = (FXint) 3 ;
+  FXint arg9 = (FXint) 3 ;
+  FXint arg10 = (FXint) 2 ;
+  FXint arg11 = (FXint) DEFAULT_SPACING ;
+  FXint arg12 = (FXint) DEFAULT_SPACING ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXDockBar *result = 0 ;
+  
+  if ((argc < 2) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXDockBar", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  arg2 = NUM2UINT(argv[1]);
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXDockBar *)new_FXDockBar__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXDockBar(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[13];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 13) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 2) && (argc <= 13)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComposite, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXComposite, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_new_FXDockBar__SWIG_0(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXDockBar__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXDockBar__SWIG_0(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXDockBar__SWIG_0(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXDockBar__SWIG_0(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  if (argc <= 7) {
+                    return _wrap_new_FXDockBar__SWIG_0(nargs, args, self);
+                  }
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    if (argc <= 8) {
+                      return _wrap_new_FXDockBar__SWIG_0(nargs, args, self);
+                    }
+                    {
+                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
+                    }
+                    if (_v) {
+                      if (argc <= 9) {
+                        return _wrap_new_FXDockBar__SWIG_0(nargs, args, self);
+                      }
+                      {
+                        _v = (TYPE(argv[9]) == T_FIXNUM || TYPE(argv[9]) == T_BIGNUM) ? 1 : 0;
+                      }
+                      if (_v) {
+                        if (argc <= 10) {
+                          return _wrap_new_FXDockBar__SWIG_0(nargs, args, self);
+                        }
+                        {
+                          _v = (TYPE(argv[10]) == T_FIXNUM || TYPE(argv[10]) == T_BIGNUM) ? 1 : 0;
+                        }
+                        if (_v) {
+                          if (argc <= 11) {
+                            return _wrap_new_FXDockBar__SWIG_0(nargs, args, self);
+                          }
+                          {
+                            _v = (TYPE(argv[11]) == T_FIXNUM || TYPE(argv[11]) == T_BIGNUM) ? 1 : 0;
+                          }
+                          if (_v) {
+                            if (argc <= 12) {
+                              return _wrap_new_FXDockBar__SWIG_0(nargs, args, self);
+                            }
+                            {
+                              _v = (TYPE(argv[12]) == T_FIXNUM || TYPE(argv[12]) == T_BIGNUM) ? 1 : 0;
+                            }
+                            if (_v) {
+                              return _wrap_new_FXDockBar__SWIG_0(nargs, args, self);
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 2) && (argc <= 12)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComposite, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_new_FXDockBar__SWIG_1(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXDockBar__SWIG_1(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXDockBar__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXDockBar__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXDockBar__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  if (argc <= 7) {
+                    return _wrap_new_FXDockBar__SWIG_1(nargs, args, self);
+                  }
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    if (argc <= 8) {
+                      return _wrap_new_FXDockBar__SWIG_1(nargs, args, self);
+                    }
+                    {
+                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
+                    }
+                    if (_v) {
+                      if (argc <= 9) {
+                        return _wrap_new_FXDockBar__SWIG_1(nargs, args, self);
+                      }
+                      {
+                        _v = (TYPE(argv[9]) == T_FIXNUM || TYPE(argv[9]) == T_BIGNUM) ? 1 : 0;
+                      }
+                      if (_v) {
+                        if (argc <= 10) {
+                          return _wrap_new_FXDockBar__SWIG_1(nargs, args, self);
+                        }
+                        {
+                          _v = (TYPE(argv[10]) == T_FIXNUM || TYPE(argv[10]) == T_BIGNUM) ? 1 : 0;
+                        }
+                        if (_v) {
+                          if (argc <= 11) {
+                            return _wrap_new_FXDockBar__SWIG_1(nargs, args, self);
+                          }
+                          {
+                            _v = (TYPE(argv[11]) == T_FIXNUM || TYPE(argv[11]) == T_BIGNUM) ? 1 : 0;
+                          }
+                          if (_v) {
+                            return _wrap_new_FXDockBar__SWIG_1(nargs, args, self);
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 13, "FXDockBar.new", 
+    "    FXDockBar.new(FXComposite *p, FXComposite *q, FXuint opts, FXint x, FXint y, FXint w, FXint h, FXint pl, FXint pr, FXint pt, FXint pb, FXint hs, FXint vs)\n"
+    "    FXDockBar.new(FXComposite *p, FXuint opts, FXint x, FXint y, FXint w, FXint h, FXint pl, FXint pr, FXint pt, FXint pb, FXint hs, FXint vs)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_dockedq___(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar const *","isDocked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  result = (FXbool)((FXDockBar const *)arg1)->isDocked();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_insideDockq___(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXDockSite *arg2 = (FXDockSite *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","insideDock", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDockSite *","insideDock", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXDockSite * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  result = (FXbool)(arg1)->insideDock(arg2,arg3,arg4);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_dryDocke___(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXComposite *arg2 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","setDryDock", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXComposite *","setDryDock", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXComposite * >(argp2);
+  (arg1)->setDryDock(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_wetDocke___(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXComposite *arg2 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","setWetDock", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXComposite *","setWetDock", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXComposite * >(argp2);
+  (arg1)->setWetDock(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_dryDock(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXComposite *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar const *","getDryDock", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  result = (FXComposite *)((FXDockBar const *)arg1)->getDryDock();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXComposite, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_wetDock(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXComposite *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar const *","getWetDock", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  result = (FXComposite *)((FXDockBar const *)arg1)->getWetDock();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXComposite, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_findDockAtSide(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXuint arg2 = (FXuint) LAYOUT_SIDE_TOP ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXDockSite *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","findDockAtSide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  result = (FXDockSite *)(arg1)->findDockAtSide(arg2);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXDockSite, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_findDockNear(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXDockSite *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","findDockNear", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (FXDockSite *)(arg1)->findDockNear(arg2,arg3);
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXDockSite, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_allowedSidese___(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXuchar arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","allowedSides", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->allowedSides(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_allowedSides(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuchar result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar const *","allowedSides", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  result = (FXuchar)((FXDockBar const *)arg1)->allowedSides();
+  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_save(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDockBar_save((FXDockBar const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_load(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDockBar_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_create(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  FXDockBar_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_detach(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  FXDockBar_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_destroy(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  FXDockBar_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_resize(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDockBar_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  result = (FXint)FXDockBar_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  result = (FXint)FXDockBar_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDockBar_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDockBar_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  result = (bool)FXDockBar_canFocus((FXDockBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  FXDockBar_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  FXDockBar_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXDockBar_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXDockBar_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_enable(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  FXDockBar_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_disable(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  FXDockBar_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  FXDockBar_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_lower(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  FXDockBar_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_move(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDockBar_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_position(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDockBar_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_layout(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  FXDockBar_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_recalc(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  FXDockBar_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_reparent(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXDockBar_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_show(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  FXDockBar_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_hide(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  FXDockBar_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  result = (bool)FXDockBar_isComposite((FXDockBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_contains(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXDockBar_contains((FXDockBar const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  result = (bool)FXDockBar_doesSaveUnder((FXDockBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXDockBar_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_tr(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXDockBar_tr((FXDockBar const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  FXDockBar_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  FXDockBar_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXDockBar_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXDockBar_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXDockBar_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDockBar_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDockBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDockBar_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDockBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDockBar_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDockBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDockBar_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  FXDockBar_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_dock__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXDockSite *arg2 = (FXDockSite *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","dock", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDockSite *","dock", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXDockSite * >(argp2);
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","dock", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXWindow * >(argp3);
+  }
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  FXDockBar_dock(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_dock__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXDockSite *arg2 = (FXDockSite *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXbool arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","dock", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDockSite *","dock", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXDockSite * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = to_FXbool(argv[3]);
+  FXDockBar_dock(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDockBar_dock(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 2) && (argc <= 4)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDockBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXDockSite, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_FXDockBar_dock__SWIG_0(nargs, args, self);
+        }
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXWindow, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXDockBar_dock__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (argv[3] == Qtrue || argv[3] == Qfalse) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_FXDockBar_dock__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDockBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXDockSite, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (argv[4] == Qtrue || argv[4] == Qfalse) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXDockBar_dock__SWIG_1(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "dock", 
+    "    void dock(FXDockSite *docksite, FXWindow *before, FXbool notify)\n"
+    "    void dock(FXDockSite *docksite, FXint localx, FXint localy, FXbool notify)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockBar_undock(int argc, VALUE *argv, VALUE self) {
+  FXDockBar *arg1 = (FXDockBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockBar *","undock", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  FXDockBar_undock(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXToolBar;
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_onCmdDockFlip(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","onCmdDockFlip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDockFlip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onCmdDockFlip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_onUpdDockFlip(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","onUpdDockFlip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdDockFlip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUpdDockFlip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXToolBar__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXComposite *arg2 = (FXComposite *) 0 ;
+  FXuint arg3 = (FXuint) LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 3 ;
+  FXint arg9 = (FXint) 3 ;
+  FXint arg10 = (FXint) 2 ;
+  FXint arg11 = (FXint) 2 ;
+  FXint arg12 = (FXint) DEFAULT_SPACING ;
+  FXint arg13 = (FXint) DEFAULT_SPACING ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXToolBar *result = 0 ;
+  
+  if ((argc < 2) || (argc > 13)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXToolBar", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXComposite *","FXToolBar", 2, argv[1] )); 
+  }
+  arg2 = reinterpret_cast< FXComposite * >(argp2);
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXToolBar *)new_FXToolBar__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXToolBar_allocate(VALUE self)
+#else
+_wrap_FXToolBar_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXToolBar);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXToolBar__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXuint arg2 = (FXuint) LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 2 ;
+  FXint arg8 = (FXint) 3 ;
+  FXint arg9 = (FXint) 3 ;
+  FXint arg10 = (FXint) 2 ;
+  FXint arg11 = (FXint) DEFAULT_SPACING ;
+  FXint arg12 = (FXint) DEFAULT_SPACING ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXToolBar *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXToolBar", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXToolBar *)new_FXToolBar__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_new_FXToolBar(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[13];
+  int ii;
+  
+  argc = nargs;
+  if (argc > 13) SWIG_fail;
+  for (ii = 0; (ii < argc); ++ii) {
+    argv[ii] = args[ii];
+  }
+  if ((argc >= 1) && (argc <= 12)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComposite, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      if (argc <= 1) {
+        return _wrap_new_FXToolBar__SWIG_1(nargs, args, self);
+      }
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_new_FXToolBar__SWIG_1(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXToolBar__SWIG_1(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXToolBar__SWIG_1(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXToolBar__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXToolBar__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  if (argc <= 7) {
+                    return _wrap_new_FXToolBar__SWIG_1(nargs, args, self);
+                  }
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    if (argc <= 8) {
+                      return _wrap_new_FXToolBar__SWIG_1(nargs, args, self);
+                    }
+                    {
+                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
+                    }
+                    if (_v) {
+                      if (argc <= 9) {
+                        return _wrap_new_FXToolBar__SWIG_1(nargs, args, self);
+                      }
+                      {
+                        _v = (TYPE(argv[9]) == T_FIXNUM || TYPE(argv[9]) == T_BIGNUM) ? 1 : 0;
+                      }
+                      if (_v) {
+                        if (argc <= 10) {
+                          return _wrap_new_FXToolBar__SWIG_1(nargs, args, self);
+                        }
+                        {
+                          _v = (TYPE(argv[10]) == T_FIXNUM || TYPE(argv[10]) == T_BIGNUM) ? 1 : 0;
+                        }
+                        if (_v) {
+                          if (argc <= 11) {
+                            return _wrap_new_FXToolBar__SWIG_1(nargs, args, self);
+                          }
+                          {
+                            _v = (TYPE(argv[11]) == T_FIXNUM || TYPE(argv[11]) == T_BIGNUM) ? 1 : 0;
+                          }
+                          if (_v) {
+                            return _wrap_new_FXToolBar__SWIG_1(nargs, args, self);
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 2) && (argc <= 13)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComposite, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXComposite, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_new_FXToolBar__SWIG_0(nargs, args, self);
+        }
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_new_FXToolBar__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_new_FXToolBar__SWIG_0(nargs, args, self);
+            }
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_new_FXToolBar__SWIG_0(nargs, args, self);
+              }
+              {
+                _v = (TYPE(argv[5]) == T_FIXNUM || TYPE(argv[5]) == T_BIGNUM) ? 1 : 0;
+              }
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_new_FXToolBar__SWIG_0(nargs, args, self);
+                }
+                {
+                  _v = (TYPE(argv[6]) == T_FIXNUM || TYPE(argv[6]) == T_BIGNUM) ? 1 : 0;
+                }
+                if (_v) {
+                  if (argc <= 7) {
+                    return _wrap_new_FXToolBar__SWIG_0(nargs, args, self);
+                  }
+                  {
+                    _v = (TYPE(argv[7]) == T_FIXNUM || TYPE(argv[7]) == T_BIGNUM) ? 1 : 0;
+                  }
+                  if (_v) {
+                    if (argc <= 8) {
+                      return _wrap_new_FXToolBar__SWIG_0(nargs, args, self);
+                    }
+                    {
+                      _v = (TYPE(argv[8]) == T_FIXNUM || TYPE(argv[8]) == T_BIGNUM) ? 1 : 0;
+                    }
+                    if (_v) {
+                      if (argc <= 9) {
+                        return _wrap_new_FXToolBar__SWIG_0(nargs, args, self);
+                      }
+                      {
+                        _v = (TYPE(argv[9]) == T_FIXNUM || TYPE(argv[9]) == T_BIGNUM) ? 1 : 0;
+                      }
+                      if (_v) {
+                        if (argc <= 10) {
+                          return _wrap_new_FXToolBar__SWIG_0(nargs, args, self);
+                        }
+                        {
+                          _v = (TYPE(argv[10]) == T_FIXNUM || TYPE(argv[10]) == T_BIGNUM) ? 1 : 0;
+                        }
+                        if (_v) {
+                          if (argc <= 11) {
+                            return _wrap_new_FXToolBar__SWIG_0(nargs, args, self);
+                          }
+                          {
+                            _v = (TYPE(argv[11]) == T_FIXNUM || TYPE(argv[11]) == T_BIGNUM) ? 1 : 0;
+                          }
+                          if (_v) {
+                            if (argc <= 12) {
+                              return _wrap_new_FXToolBar__SWIG_0(nargs, args, self);
+                            }
+                            {
+                              _v = (TYPE(argv[12]) == T_FIXNUM || TYPE(argv[12]) == T_BIGNUM) ? 1 : 0;
+                            }
+                            if (_v) {
+                              return _wrap_new_FXToolBar__SWIG_0(nargs, args, self);
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 13, "FXToolBar.new", 
+    "    FXToolBar.new(FXComposite *p, FXComposite *q, FXuint opts, FXint x, FXint y, FXint w, FXint h, FXint pl, FXint pr, FXint pt, FXint pb, FXint hs, FXint vs)\n"
+    "    FXToolBar.new(FXComposite *p, FXuint opts, FXint x, FXint y, FXint w, FXint h, FXint pl, FXint pr, FXint pt, FXint pb, FXint hs, FXint vs)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_dockingSidee___(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  FXuint arg2 = (FXuint) LAYOUT_SIDE_TOP ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","setDockingSide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  if (argc > 0) {
+    arg2 = NUM2UINT(argv[0]);
+  }
+  (arg1)->setDockingSide(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_dockingSide(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar const *","getDockingSide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  result = (FXuint)((FXToolBar const *)arg1)->getDockingSide();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_save(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXToolBar_save((FXToolBar const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_load(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXToolBar_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_create(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  FXToolBar_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_detach(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  FXToolBar_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_destroy(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  FXToolBar_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_resize(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXToolBar_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  result = (FXint)FXToolBar_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  result = (FXint)FXToolBar_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXToolBar_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXToolBar_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  result = (bool)FXToolBar_canFocus((FXToolBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  FXToolBar_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  FXToolBar_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXToolBar_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXToolBar_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_enable(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  FXToolBar_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_disable(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  FXToolBar_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  FXToolBar_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_lower(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  FXToolBar_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_move(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXToolBar_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_position(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXToolBar_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_layout(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  FXToolBar_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_recalc(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  FXToolBar_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_reparent(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXToolBar_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_show(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  FXToolBar_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_hide(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  FXToolBar_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  result = (bool)FXToolBar_isComposite((FXToolBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_contains(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXToolBar_contains((FXToolBar const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  result = (bool)FXToolBar_doesSaveUnder((FXToolBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXToolBar_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_tr(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXToolBar_tr((FXToolBar const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  FXToolBar_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  FXToolBar_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXToolBar_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXToolBar_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXToolBar_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXToolBar_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToolBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXToolBar_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToolBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXToolBar_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToolBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXToolBar_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  FXToolBar_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_dock__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  FXDockSite *arg2 = (FXDockSite *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","dock", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDockSite *","dock", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXDockSite * >(argp2);
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","dock", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXWindow * >(argp3);
+  }
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  FXToolBar_dock(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_dock__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  FXDockSite *arg2 = (FXDockSite *) 0 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXbool arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","dock", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXDockSite, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXDockSite *","dock", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXDockSite * >(argp2);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = to_FXbool(argv[3]);
+  FXToolBar_dock(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXToolBar_dock(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if ((argc >= 2) && (argc <= 4)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToolBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXDockSite, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        if (argc <= 2) {
+          return _wrap_FXToolBar_dock__SWIG_0(nargs, args, self);
+        }
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXWindow, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXToolBar_dock__SWIG_0(nargs, args, self);
+          }
+          {
+            _v = (argv[3] == Qtrue || argv[3] == Qfalse) ? 1 : 0;
+          }
+          if (_v) {
+            return _wrap_FXToolBar_dock__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToolBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXDockSite, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (argv[4] == Qtrue || argv[4] == Qfalse) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXToolBar_dock__SWIG_1(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "dock", 
+    "    void dock(FXDockSite *docksite, FXWindow *before, FXbool notify)\n"
+    "    void dock(FXDockSite *docksite, FXint localx, FXint localy, FXbool notify)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBar_undock(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","undock", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  FXToolBar_undock(arg1,arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXTabBar;
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_onFocusNext(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","onFocusNext", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusNext", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusNext(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_onFocusPrev(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","onFocusPrev", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusPrev", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusPrev(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_onFocusUp(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","onFocusUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_onFocusDown(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","onFocusDown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusDown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusDown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_onFocusLeft(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","onFocusLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusLeft", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusLeft(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_onFocusRight(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","onFocusRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusRight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusRight(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_onCmdOpenItem(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","onCmdOpenItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdOpenItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdOpenItem(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXint) NUM2INT(argv[2]);
+    arg4 = static_cast<void*>(&value4);
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_onCmdOpen(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","onCmdOpen", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdOpen", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdOpen(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_onUpdOpen(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","onUpdOpen", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdOpen", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdOpen(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXTabBar_allocate(VALUE self)
+#else
+_wrap_FXTabBar_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXTabBar);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXTabBar(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) TABBOOK_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) DEFAULT_SPACING ;
+  FXint arg10 = (FXint) DEFAULT_SPACING ;
+  FXint arg11 = (FXint) DEFAULT_SPACING ;
+  FXint arg12 = (FXint) DEFAULT_SPACING ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXTabBar *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXTabBar", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXTabBar", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXTabBar *)new_FXTabBar(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_getCurrent(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar const *","getCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  result = (FXint)((FXTabBar const *)arg1)->getCurrent();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_getTabStyle(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar const *","getTabStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  result = (FXuint)((FXTabBar const *)arg1)->getTabStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_setTabStyle(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","setTabStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setTabStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_save(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTabBar_save((FXTabBar const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_load(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTabBar_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_create(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  FXTabBar_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_detach(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  FXTabBar_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_destroy(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  FXTabBar_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_resize(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXTabBar_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  result = (FXint)FXTabBar_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  result = (FXint)FXTabBar_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXTabBar_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXTabBar_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  result = (bool)FXTabBar_canFocus((FXTabBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  FXTabBar_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  FXTabBar_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXTabBar_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXTabBar_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_enable(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  FXTabBar_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_disable(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  FXTabBar_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  FXTabBar_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_lower(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  FXTabBar_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_move(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXTabBar_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_position(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXTabBar_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_layout(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  FXTabBar_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_recalc(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  FXTabBar_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_reparent(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXTabBar_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_show(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  FXTabBar_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_hide(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  FXTabBar_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  result = (bool)FXTabBar_isComposite((FXTabBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_contains(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXTabBar_contains((FXTabBar const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  result = (bool)FXTabBar_doesSaveUnder((FXTabBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXTabBar_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_tr(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXTabBar_tr((FXTabBar const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  FXTabBar_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  FXTabBar_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXTabBar_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXTabBar_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXTabBar_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXTabBar_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTabBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTabBar_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTabBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTabBar_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTabBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTabBar_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  FXTabBar_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBar_setCurrent(int argc, VALUE *argv, VALUE self) {
+  FXTabBar *arg1 = (FXTabBar *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBar *","setCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXTabBar_setCurrent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXTabBook;
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_onFocusNext(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","onFocusNext", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusNext", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusNext(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_onFocusPrev(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","onFocusPrev", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusPrev", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusPrev(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_onFocusUp(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","onFocusUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_onFocusDown(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","onFocusDown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusDown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusDown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_onFocusLeft(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","onFocusLeft", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusLeft", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusLeft(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_onFocusRight(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","onFocusRight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusRight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusRight(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_onCmdOpenItem(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","onCmdOpenItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdOpenItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdOpenItem(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXTabBook_allocate(VALUE self)
+#else
+_wrap_FXTabBook_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXTabBook);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXTabBook(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) TABBOOK_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) DEFAULT_SPACING ;
+  FXint arg10 = (FXint) DEFAULT_SPACING ;
+  FXint arg11 = (FXint) DEFAULT_SPACING ;
+  FXint arg12 = (FXint) DEFAULT_SPACING ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXTabBook *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXTabBook", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXTabBook", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXTabBook *)new_FXTabBook(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_save(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTabBook_save((FXTabBook const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_load(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTabBook_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_create(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  FXTabBook_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_detach(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  FXTabBook_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_destroy(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  FXTabBook_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_resize(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXTabBook_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  result = (FXint)FXTabBook_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  result = (FXint)FXTabBook_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXTabBook_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXTabBook_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  result = (bool)FXTabBook_canFocus((FXTabBook const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  FXTabBook_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  FXTabBook_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXTabBook_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXTabBook_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_enable(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  FXTabBook_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_disable(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  FXTabBook_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  FXTabBook_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_lower(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  FXTabBook_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_move(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXTabBook_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_position(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXTabBook_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_layout(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  FXTabBook_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_recalc(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  FXTabBook_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_reparent(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXTabBook_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_show(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  FXTabBook_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_hide(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  FXTabBook_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  result = (bool)FXTabBook_isComposite((FXTabBook const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_contains(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXTabBook_contains((FXTabBook const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  result = (bool)FXTabBook_doesSaveUnder((FXTabBook const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXTabBook_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_tr(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXTabBook_tr((FXTabBook const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  FXTabBook_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  FXTabBook_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXTabBook_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXTabBook_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXTabBook_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXTabBook_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTabBook, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTabBook_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTabBook, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTabBook_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTabBook, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTabBook_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  FXTabBook_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTabBook_setCurrent(int argc, VALUE *argv, VALUE self) {
+  FXTabBook *arg1 = (FXTabBook *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTabBook, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTabBook *","setCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTabBook * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXTabBook_setCurrent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXScrollBar;
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_onMouseWheel(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","onMouseWheel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMouseWheel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMouseWheel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_onMiddleBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","onMiddleBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMiddleBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMiddleBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_onMiddleBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","onMiddleBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMiddleBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMiddleBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_onRightBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","onRightBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onRightBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_onRightBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","onRightBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onRightBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_onUngrabbed(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","onUngrabbed", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUngrabbed", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onUngrabbed(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_onTimeWheel(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","onTimeWheel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTimeWheel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onTimeWheel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_onAutoScroll(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","onAutoScroll", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onAutoScroll", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onAutoScroll(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXint) NUM2INT(argv[2]);
+    arg4 = static_cast<void*>(&value4);
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_onCmdSetIntRange(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint values4[2] ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","onCmdSetIntRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    Check_Type(argv[2], T_ARRAY);
+    values4[0] = (FXint) NUM2INT(rb_ary_entry(argv[2], 0));
+    values4[1] = (FXint) NUM2INT(rb_ary_entry(argv[2], 1));
+    arg4 = static_cast<void*>(values4);
+  }
+  result = (long)(arg1)->onCmdSetIntRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_onCmdGetIntRange(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","onCmdGetIntRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntRange", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetIntRange", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetIntRange(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXScrollBar_allocate(VALUE self)
+#else
+_wrap_FXScrollBar_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXScrollBar);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXScrollBar(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) SCROLLBAR_VERTICAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXScrollBar *result = 0 ;
+  
+  if ((argc < 1) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXScrollBar", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXScrollBar", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXScrollBar *)new_FXScrollBar(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_setRange(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","setRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setRange(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_getRange(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar const *","getRange", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  result = (FXint)((FXScrollBar const *)arg1)->getRange();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_setPage(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","setPage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setPage(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_getPage(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar const *","getPage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  result = (FXint)((FXScrollBar const *)arg1)->getPage();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_setLine(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","setLine", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setLine(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_getLine(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar const *","getLine", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  result = (FXint)((FXScrollBar const *)arg1)->getLine();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_setPosition(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","setPosition", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setPosition(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar const *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  result = (FXint)FXScrollBar_position__SWIG_0((FXScrollBar const *)arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_setHiliteColor(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","setHiliteColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setHiliteColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_getHiliteColor(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar const *","getHiliteColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  result = (FXColor)((FXScrollBar const *)arg1)->getHiliteColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_setShadowColor(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","setShadowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setShadowColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_getShadowColor(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar const *","getShadowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  result = (FXColor)((FXScrollBar const *)arg1)->getShadowColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_getBorderColor(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar const *","getBorderColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  result = (FXColor)((FXScrollBar const *)arg1)->getBorderColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_setBorderColor(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","setBorderColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setBorderColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_getScrollBarStyle(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar const *","getScrollBarStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  result = (FXuint)((FXScrollBar const *)arg1)->getScrollBarStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_setScrollBarStyle(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","setScrollBarStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setScrollBarStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_barSizee___(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","setBarSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setBarSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_barSize(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar const *","getBarSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  result = (FXint)((FXScrollBar const *)arg1)->getBarSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_save(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXScrollBar_save((FXScrollBar const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_load(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXScrollBar_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_create(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  FXScrollBar_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_detach(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  FXScrollBar_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_destroy(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  FXScrollBar_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_resize(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXScrollBar_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  result = (FXint)FXScrollBar_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  result = (FXint)FXScrollBar_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXScrollBar_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXScrollBar_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  result = (bool)FXScrollBar_canFocus((FXScrollBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  FXScrollBar_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  FXScrollBar_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXScrollBar_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXScrollBar_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_enable(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  FXScrollBar_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_disable(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  FXScrollBar_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  FXScrollBar_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_lower(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  FXScrollBar_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_move(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXScrollBar_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXScrollBar_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXScrollBar_position(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScrollBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXScrollBar_position__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScrollBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXScrollBar_position__SWIG_1(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "position", 
+    "    FXint position()\n"
+    "    void position(FXint x, FXint y, FXint w, FXint h)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_layout(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  FXScrollBar_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_recalc(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  FXScrollBar_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_reparent(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXScrollBar_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_show(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  FXScrollBar_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_hide(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  FXScrollBar_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  result = (bool)FXScrollBar_isComposite((FXScrollBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_contains(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXScrollBar_contains((FXScrollBar const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  result = (bool)FXScrollBar_doesSaveUnder((FXScrollBar const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXScrollBar_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_tr(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXScrollBar_tr((FXScrollBar const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  FXScrollBar_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  FXScrollBar_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXScrollBar_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXScrollBar_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXScrollBar_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXScrollBar_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScrollBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXScrollBar_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScrollBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXScrollBar_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScrollBar, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXScrollBar_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollBar_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXScrollBar *arg1 = (FXScrollBar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollBar *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollBar * >(argp1);
+  FXScrollBar_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXScrollCorner;
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXScrollCorner_allocate(VALUE self)
+#else
+_wrap_FXScrollCorner_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXScrollCorner);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXScrollCorner(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXScrollCorner *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXScrollCorner", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXScrollCorner *)new_FXScrollCorner(arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_save(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXScrollCorner_save((FXScrollCorner const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_load(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXScrollCorner_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_create(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  FXScrollCorner_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_detach(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  FXScrollCorner_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_destroy(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  FXScrollCorner_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_resize(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXScrollCorner_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  result = (FXint)FXScrollCorner_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  result = (FXint)FXScrollCorner_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXScrollCorner_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXScrollCorner_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  result = (bool)FXScrollCorner_canFocus((FXScrollCorner const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  FXScrollCorner_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  FXScrollCorner_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXScrollCorner_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXScrollCorner_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_enable(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  FXScrollCorner_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_disable(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  FXScrollCorner_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  FXScrollCorner_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_lower(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  FXScrollCorner_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_move(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXScrollCorner_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_position(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXScrollCorner_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_layout(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  FXScrollCorner_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_recalc(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  FXScrollCorner_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_reparent(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXScrollCorner_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_show(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  FXScrollCorner_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_hide(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  FXScrollCorner_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  result = (bool)FXScrollCorner_isComposite((FXScrollCorner const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_contains(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXScrollCorner_contains((FXScrollCorner const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  result = (bool)FXScrollCorner_doesSaveUnder((FXScrollCorner const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXScrollCorner_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_tr(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXScrollCorner_tr((FXScrollCorner const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  FXScrollCorner_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  FXScrollCorner_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXScrollCorner_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXScrollCorner_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXScrollCorner_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXScrollCorner_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScrollCorner, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXScrollCorner_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScrollCorner, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXScrollCorner_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXScrollCorner, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXScrollCorner_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXScrollCorner_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXScrollCorner *arg1 = (FXScrollCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXScrollCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXScrollCorner *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXScrollCorner * >(argp1);
+  FXScrollCorner_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXComboBox;
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_onFocusUp(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","onFocusUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_onFocusDown(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","onFocusDown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusDown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusDown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_onFocusSelf(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","onFocusSelf", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusSelf", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusSelf(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_onMouseWheel(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","onMouseWheel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMouseWheel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMouseWheel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_onTextButton(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","onTextButton", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTextButton", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onTextButton(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_onTextChanged(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","onTextChanged", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTextChanged", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = static_cast<void*>(StringValuePtr(argv[2]));
+  result = (long)(arg1)->onTextChanged(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_onTextCommand(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","onTextCommand", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTextCommand", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = static_cast<void*>(StringValuePtr(argv[2]));
+  result = (long)(arg1)->onTextCommand(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_onListClicked(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","onListClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onListClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onListClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_onFwdToText(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","onFwdToText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFwdToText", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onFwdToText(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_onUpdFmText(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","onUpdFmText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdFmText", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdFmText(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXComboBox_allocate(VALUE self)
+#else
+_wrap_FXComboBox_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXComboBox);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXComboBox(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXint arg2 ;
+  FXObject *arg3 = (FXObject *) 0 ;
+  FXSelector arg4 = (FXSelector) 0 ;
+  FXuint arg5 = (FXuint) COMBOBOX_NORMAL ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  FXint arg13 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXComboBox *result = 0 ;
+  
+  if ((argc < 2) || (argc > 13)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXComboBox", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  arg2 = NUM2INT(argv[1]);
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXObject *","FXComboBox", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXObject * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXComboBox *)new_FXComboBox(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_isEditable(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","isEditable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  result = (FXbool)((FXComboBox const *)arg1)->isEditable();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_setEditable(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","setEditable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->setEditable(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_setText(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","setText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_getText(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","getText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  result = ((FXComboBox const *)arg1)->getText();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_setNumColumns(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","setNumColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setNumColumns(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_getNumColumns(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","getNumColumns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  result = (FXint)((FXComboBox const *)arg1)->getNumColumns();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_justifye___(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","setJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setJustify(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_justify(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","getJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  result = (FXuint)((FXComboBox const *)arg1)->getJustify();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_getNumItems(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","getNumItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  result = (FXint)((FXComboBox const *)arg1)->getNumItems();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_getNumVisible(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","getNumVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  result = (FXint)((FXComboBox const *)arg1)->getNumVisible();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_setNumVisible(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","setNumVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setNumVisible(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_isItemCurrent(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","isItemCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "combobox item index out of bounds");
+    }
+  }
+  result = (FXbool)((FXComboBox const *)arg1)->isItemCurrent(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_setCurrentItem(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","setCurrentItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < -1 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "combobox item index out of bounds");
+    }
+  }
+  (arg1)->setCurrentItem(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_getCurrentItem(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","getCurrentItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  result = (FXint)((FXComboBox const *)arg1)->getCurrentItem();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_getItem(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","getItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "combobox item index out of bounds");
+    }
+  }
+  result = ((FXComboBox const *)arg1)->getItem(arg2);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_setItem(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","setItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  if (argc > 2) {
+    arg4 = (argv[2] == Qnil) ? NULL : (void *) argv[2];
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "combobox item index out of bounds");
+    }
+  }
+  result = (FXint)(arg1)->setItem(arg2,(FXString const &)*arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_fillItems(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXchar **arg2 = (FXchar **) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","fillItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  {
+    arg2 = NULL;
+    if(!NIL_P(argv[0])){
+      Check_Type(argv[0], T_ARRAY);
+      if (FXMALLOC(&arg2, FXchar *, RARRAY_LEN(argv[0])+1)) {
+        for (long i = 0; i < RARRAY_LEN(argv[0]); i++) {
+          VALUE e = rb_ary_entry(argv[0], i);
+          arg2[i] = (FXchar *) StringValuePtr(e);
+        }
+        arg2[RARRAY_LEN(argv[0])] = 0;
+      }
+    }
+  }
+  result = (FXint)(arg1)->fillItems((FXchar const **)arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  FXFREE(&arg2);
+  return vresult;
+fail:
+  FXFREE(&arg2);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_insertItem(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","insertItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  if (argc > 2) {
+    arg4 = (argv[2] == Qnil) ? NULL : (void *) argv[2];
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "combobox item index out of bounds");
+    }
+  }
+  result = (FXint)(arg1)->insertItem(arg2,(FXString const &)*arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_appendItem(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXString *arg2 = 0 ;
+  void *arg3 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","appendItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    arg3 = (argv[1] == Qnil) ? NULL : (void *) argv[1];
+  }
+  result = (FXint)(arg1)->appendItem((FXString const &)*arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_prependItem(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXString *arg2 = 0 ;
+  void *arg3 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","prependItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    arg3 = (argv[1] == Qnil) ? NULL : (void *) argv[1];
+  }
+  result = (FXint)(arg1)->prependItem((FXString const &)*arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_moveItem(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","moveItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "combobox item index out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "combobox item index out of bounds");
+    }
+  }
+  result = (FXint)(arg1)->moveItem(arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_removeItem(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","removeItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "combobox item index out of bounds");
+    }
+  }
+  (arg1)->removeItem(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_clearItems(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","clearItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  (arg1)->clearItems();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_findItem(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXString *arg2 = 0 ;
+  FXint arg3 = (FXint) -1 ;
+  FXuint arg4 = (FXuint) SEARCH_FORWARD|SEARCH_WRAP ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","findItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2UINT(argv[2]);
+  }
+  result = (FXint)((FXComboBox const *)arg1)->findItem((FXString const &)*arg2,arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_findItemByData(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXint arg3 = (FXint) -1 ;
+  FXuint arg4 = (FXuint) SEARCH_FORWARD|SEARCH_WRAP ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","findItemByData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = (argv[0] == Qnil) ? NULL : (void *) argv[0];
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2UINT(argv[2]);
+  }
+  result = (FXint)((FXComboBox const *)arg1)->findItemByData((void const *)arg2,arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_setItemText(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","setItemText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "combobox item index out of bounds");
+    }
+  }
+  (arg1)->setItemText(arg2,(FXString const &)*arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_getItemText(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","getItemText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "combobox item index out of bounds");
+    }
+  }
+  result = ((FXComboBox const *)arg1)->getItemText(arg2);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_setItemData(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXint arg2 ;
+  VALUE arg3 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","setItemData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = argv[1];
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "combobox item index out of bounds");
+    }
+  }
+  FXComboBox_setItemData(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_getItemData(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","getItemData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "combobox item index out of bounds");
+    }
+  }
+  result = (VALUE)FXComboBox_getItemData((FXComboBox const *)arg1,arg2);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_isPaneShown(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","isPaneShown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  result = (FXbool)((FXComboBox const *)arg1)->isPaneShown();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_sortItems(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","sortItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  (arg1)->sortItems();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_setFont(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  (arg1)->setFont(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_getFont(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  result = (FXFont *)((FXComboBox const *)arg1)->getFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_setComboStyle(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","setComboStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setComboStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_getComboStyle(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","getComboStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  result = (FXuint)((FXComboBox const *)arg1)->getComboStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_getBackColor(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","getBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  result = (FXColor)((FXComboBox const *)arg1)->getBackColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_setTextColor(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","setTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_getTextColor(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","getTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  result = (FXColor)((FXComboBox const *)arg1)->getTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_setSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","setSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelBackColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_getSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","getSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  result = (FXColor)((FXComboBox const *)arg1)->getSelBackColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_setSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","setSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_getSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","getSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  result = (FXColor)((FXComboBox const *)arg1)->getSelTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  result = (FXString *) &((FXComboBox const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_setTipText(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_getTipText(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  result = (FXString *) &((FXComboBox const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_save(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXComboBox_save((FXComboBox const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_load(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXComboBox_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_create(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  FXComboBox_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_detach(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  FXComboBox_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_destroy(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  FXComboBox_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_resize(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXComboBox_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  result = (FXint)FXComboBox_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  result = (FXint)FXComboBox_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXComboBox_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXComboBox_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  result = (bool)FXComboBox_canFocus((FXComboBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  FXComboBox_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  FXComboBox_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXComboBox_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXComboBox_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_enable(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  FXComboBox_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_disable(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  FXComboBox_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  FXComboBox_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_lower(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  FXComboBox_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_move(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXComboBox_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_position(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXComboBox_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_layout(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  FXComboBox_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_recalc(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  FXComboBox_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_reparent(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXComboBox_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_show(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  FXComboBox_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_hide(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  FXComboBox_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  result = (bool)FXComboBox_isComposite((FXComboBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_contains(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXComboBox_contains((FXComboBox const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  result = (bool)FXComboBox_doesSaveUnder((FXComboBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXComboBox_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_tr(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXComboBox_tr((FXComboBox const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  FXComboBox_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  FXComboBox_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXComboBox_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXComboBox_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXComboBox_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXComboBox_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComboBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXComboBox_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComboBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXComboBox_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXComboBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXComboBox_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXComboBox_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXComboBox *arg1 = (FXComboBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXComboBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComboBox *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXComboBox * >(argp1);
+  FXComboBox_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXListBox;
+
+SWIGINTERN VALUE
+_wrap_FXListBox_onFocusUp(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","onFocusUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_onFocusDown(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","onFocusDown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusDown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusDown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_onFocusSelf(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","onFocusSelf", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusSelf", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusSelf(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_onMouseWheel(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","onMouseWheel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMouseWheel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMouseWheel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_onFieldButton(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","onFieldButton", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFieldButton", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onFieldButton(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_onListUpdate(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","onListUpdate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onListUpdate", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onListUpdate(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_onListClicked(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","onListClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onListClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onListClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_onListChanged(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","onListChanged", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onListChanged", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onListChanged(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_onCmdGetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","onCmdGetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_onCmdSetIntValue(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXint value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","onCmdSetIntValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetIntValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = (FXint) NUM2INT(argv[2]);
+    arg4 = static_cast<void*>(&value4);
+  }
+  result = (long)(arg1)->onCmdSetIntValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXListBox_allocate(VALUE self)
+#else
+_wrap_FXListBox_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXListBox);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXListBox(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) FRAME_SUNKEN|FRAME_THICK|LISTBOX_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) DEFAULT_PAD ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXListBox *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXListBox", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXListBox", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXListBox *)new_FXListBox(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_getNumItems(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","getNumItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  result = (FXint)((FXListBox const *)arg1)->getNumItems();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_getNumVisible(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","getNumVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  result = (FXint)((FXListBox const *)arg1)->getNumVisible();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_setNumVisible(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","setNumVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setNumVisible(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_isItemCurrent(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","isItemCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list box item index out of bounds");
+    }
+  }
+  result = (FXbool)((FXListBox const *)arg1)->isItemCurrent(arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_getCurrentItem(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","getCurrentItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  result = (FXint)((FXListBox const *)arg1)->getCurrentItem();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_getItem(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","getItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list box item index out of bounds");
+    }
+  }
+  result = ((FXListBox const *)arg1)->getItem(arg2);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_setItem(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  void *arg5 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","setItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  if (argc > 2) {
+    res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","setItem", 4, argv[2] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 3) {
+    arg5 = (argv[3] == Qnil) ? NULL : (void *) argv[3];
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list box item index out of bounds");
+    }
+  }
+  result = (FXint)(arg1)->setItem(arg2,(FXString const &)*arg3,arg4,arg5);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_fillItems(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXchar **arg2 = (FXchar **) 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","fillItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  {
+    arg2 = NULL;
+    if(!NIL_P(argv[0])){
+      Check_Type(argv[0], T_ARRAY);
+      if (FXMALLOC(&arg2, FXchar *, RARRAY_LEN(argv[0])+1)) {
+        for (long i = 0; i < RARRAY_LEN(argv[0]); i++) {
+          VALUE e = rb_ary_entry(argv[0], i);
+          arg2[i] = (FXchar *) StringValuePtr(e);
+        }
+        arg2[RARRAY_LEN(argv[0])] = 0;
+      }
+    }
+  }
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","fillItems", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 2) {
+    arg4 = (argv[2] == Qnil) ? NULL : (void *) argv[2];
+  }
+  result = (FXint)(arg1)->fillItems((FXchar const **)arg2,arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  FXFREE(&arg2);
+  return vresult;
+fail:
+  FXFREE(&arg2);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_insertItem(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  void *arg5 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","insertItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  if (argc > 2) {
+    res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","insertItem", 4, argv[2] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 3) {
+    arg5 = (argv[3] == Qnil) ? NULL : (void *) argv[3];
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list box item index out of bounds");
+    }
+  }
+  result = (FXint)(arg1)->insertItem(arg2,(FXString const &)*arg3,arg4,arg5);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_appendItem(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","appendItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","appendItem", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 2) {
+    arg4 = (argv[2] == Qnil) ? NULL : (void *) argv[2];
+  }
+  result = (FXint)(arg1)->appendItem((FXString const &)*arg2,arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_prependItem(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXString *arg2 = 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","prependItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","prependItem", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXIcon * >(argp3);
+  }
+  if (argc > 2) {
+    arg4 = (argv[2] == Qnil) ? NULL : (void *) argv[2];
+  }
+  result = (FXint)(arg1)->prependItem((FXString const &)*arg2,arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_moveItem(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","moveItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list box item index out of bounds");
+    }
+  }
+  {
+    if (arg3 < 0 || arg3 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list box item index out of bounds");
+    }
+  }
+  result = (FXint)(arg1)->moveItem(arg2,arg3);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_extractItem(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXListItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","extractItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list box item index out of bounds");
+    }
+  }
+  result = (FXListItem *)(arg1)->extractItem(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXListItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_removeItem(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","removeItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list box item index out of bounds");
+    }
+  }
+  (arg1)->removeItem(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_clearItems(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","clearItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  (arg1)->clearItems();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_findItem(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXString *arg2 = 0 ;
+  FXint arg3 = (FXint) -1 ;
+  FXuint arg4 = (FXuint) SEARCH_FORWARD|SEARCH_WRAP ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","findItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2UINT(argv[2]);
+  }
+  result = (FXint)((FXListBox const *)arg1)->findItem((FXString const &)*arg2,arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_findItemByData(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXint arg3 = (FXint) -1 ;
+  FXuint arg4 = (FXuint) SEARCH_FORWARD|SEARCH_WRAP ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","findItemByData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = (argv[0] == Qnil) ? NULL : (void *) argv[0];
+  if (argc > 1) {
+    arg3 = NUM2INT(argv[1]);
+  }
+  if (argc > 2) {
+    arg4 = NUM2UINT(argv[2]);
+  }
+  result = (FXint)((FXListBox const *)arg1)->findItemByData((void const *)arg2,arg3,arg4);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_setItemText(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","setItemText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list box item index out of bounds");
+    }
+  }
+  (arg1)->setItemText(arg2,(FXString const &)*arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_getItemText(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","getItemText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list box item index out of bounds");
+    }
+  }
+  result = ((FXListBox const *)arg1)->getItemText(arg2);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_setItemIcon(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXint arg2 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","setItemIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","setItemIcon", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXIcon * >(argp3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list box item index out of bounds");
+    }
+  }
+  (arg1)->setItemIcon(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_getItemIcon(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","getItemIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list box item index out of bounds");
+    }
+  }
+  result = (FXIcon *)((FXListBox const *)arg1)->getItemIcon(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_setItemData(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXint arg2 ;
+  VALUE arg3 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","setItemData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = argv[1];
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list box item index out of bounds");
+    }
+  }
+  FXListBox_setItemData(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_getItemData(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","getItemData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list box item index out of bounds");
+    }
+  }
+  result = (VALUE)FXListBox_getItemData((FXListBox const *)arg1,arg2);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_isPaneShown(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","isPaneShown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  result = (FXbool)((FXListBox const *)arg1)->isPaneShown();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_sortItems(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","sortItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  (arg1)->sortItems();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_setFont(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  (arg1)->setFont(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_getFont(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  result = (FXFont *)((FXListBox const *)arg1)->getFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_getBackColor(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","getBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  result = (FXColor)((FXListBox const *)arg1)->getBackColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_setTextColor(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","setTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_getTextColor(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","getTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  result = (FXColor)((FXListBox const *)arg1)->getTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_setSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","setSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelBackColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_getSelBackColor(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","getSelBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  result = (FXColor)((FXListBox const *)arg1)->getSelBackColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_setSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","setSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setSelTextColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_getSelTextColor(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","getSelTextColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  result = (FXColor)((FXListBox const *)arg1)->getSelTextColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  result = (FXString *) &((FXListBox const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_setTipText(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_getTipText(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  result = (FXString *) &((FXListBox const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_save(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXListBox_save((FXListBox const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_load(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXListBox_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_create(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  FXListBox_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_detach(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  FXListBox_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_destroy(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  FXListBox_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_resize(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXListBox_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  result = (FXint)FXListBox_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  result = (FXint)FXListBox_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXListBox_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXListBox_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  result = (bool)FXListBox_canFocus((FXListBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  FXListBox_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  FXListBox_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXListBox_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXListBox_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_enable(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  FXListBox_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_disable(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  FXListBox_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  FXListBox_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_lower(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  FXListBox_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_move(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXListBox_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_position(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXListBox_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_layout(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  FXListBox_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_recalc(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  FXListBox_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_reparent(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXListBox_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_show(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  FXListBox_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_hide(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  FXListBox_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  result = (bool)FXListBox_isComposite((FXListBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_contains(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXListBox_contains((FXListBox const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  result = (bool)FXListBox_doesSaveUnder((FXListBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXListBox_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_tr(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXListBox_tr((FXListBox const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  FXListBox_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  FXListBox_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXListBox_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXListBox_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXListBox_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXListBox_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXListBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXListBox_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXListBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXListBox_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXListBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXListBox_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  FXListBox_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXListBox_setCurrentItem(int argc, VALUE *argv, VALUE self) {
+  FXListBox *arg1 = (FXListBox *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXListBox *","setCurrentItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  {
+    if (arg2 < 0 || arg2 >= arg1->getNumItems()) {
+      rb_raise(rb_eIndexError, "list box item index out of bounds");
+    }
+  }
+  FXListBox_setCurrentItem(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXTreeListBox;
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_onFocusUp(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","onFocusUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_onFocusDown(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","onFocusDown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusDown", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusDown(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_onFocusSelf(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","onFocusSelf", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFocusSelf", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onFocusSelf(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_onMouseWheel(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","onMouseWheel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMouseWheel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMouseWheel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_onFieldButton(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","onFieldButton", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onFieldButton", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onFieldButton(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_onTreeUpdate(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","onTreeUpdate", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTreeUpdate", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onTreeUpdate(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_onTreeChanged(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","onTreeChanged", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTreeChanged", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  SWIG_ConvertPtr(argv[2],&arg4,SWIGTYPE_p_FXTreeItem,1);
+  result = (long)(arg1)->onTreeChanged(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_onTreeClicked(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","onTreeClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTreeClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  SWIG_ConvertPtr(argv[2],&arg4,SWIGTYPE_p_FXTreeItem,1);
+  result = (long)(arg1)->onTreeClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXTreeListBox_allocate(VALUE self)
+#else
+_wrap_FXTreeListBox_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXTreeListBox);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXTreeListBox(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) FRAME_SUNKEN|FRAME_THICK|TREELISTBOX_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) DEFAULT_PAD ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXTreeListBox *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXTreeListBox", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXTreeListBox", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXTreeListBox *)new_FXTreeListBox(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_getNumItems(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","getNumItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  result = (FXint)((FXTreeListBox const *)arg1)->getNumItems();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_getNumVisible(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","getNumVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  result = (FXint)((FXTreeListBox const *)arg1)->getNumVisible();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_setNumVisible(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","setNumVisible", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setNumVisible(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_getFirstItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","getFirstItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  result = (FXTreeItem *)((FXTreeListBox const *)arg1)->getFirstItem();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_getLastItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","getLastItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  result = (FXTreeItem *)((FXTreeListBox const *)arg1)->getLastItem();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_fillItems(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXchar **arg3 = (FXchar **) 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  void *arg6 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","fillItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","fillItems", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  {
+    arg3 = NULL;
+    if(!NIL_P(argv[1])){
+      Check_Type(argv[1], T_ARRAY);
+      if (FXMALLOC(&arg3, FXchar *, RARRAY_LEN(argv[1])+1)) {
+        for (long i = 0; i < RARRAY_LEN(argv[1]); i++) {
+          VALUE e = rb_ary_entry(argv[1], i);
+          arg3[i] = (FXchar *) StringValuePtr(e);
+        }
+        arg3[RARRAY_LEN(argv[1])] = 0;
+      }
+    }
+  }
+  if (argc > 2) {
+    res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","fillItems", 4, argv[2] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 3) {
+    res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","fillItems", 5, argv[3] )); 
+    }
+    arg5 = reinterpret_cast< FXIcon * >(argp5);
+  }
+  if (argc > 4) {
+    arg6 = (argv[4] == Qnil) ? NULL : (void *) argv[4];
+  }
+  result = (FXint)(arg1)->fillItems(arg2,(FXchar const **)arg3,arg4,arg5,arg6);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  FXFREE(&arg3);
+  return vresult;
+fail:
+  FXFREE(&arg3);
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_insertItem__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg3 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg4 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","insertItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","insertItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXTreeItem *","insertItem", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXTreeItem * >(argp3);
+  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXTreeItem *","insertItem", 4, argv[2] )); 
+  }
+  arg4 = reinterpret_cast< FXTreeItem * >(argp4);
+  result = (FXTreeItem *)FXTreeListBox_insertItem__SWIG_0(arg1,arg2,arg3,arg4);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_insertItem__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg3 = (FXTreeItem *) 0 ;
+  FXString *arg4 = 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  FXIcon *arg6 = (FXIcon *) 0 ;
+  void *arg7 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  SwigValueWrapper< FXString > p4 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  void *argp6 = 0 ;
+  int res6 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 6)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","insertItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","insertItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXTreeItem *","insertItem", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXTreeItem * >(argp3);
+  p4 = to_FXString(argv[2]); arg4 = &p4;
+  if (argc > 3) {
+    res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","insertItem", 5, argv[3] )); 
+    }
+    arg5 = reinterpret_cast< FXIcon * >(argp5);
+  }
+  if (argc > 4) {
+    res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res6)) {
+      SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "FXIcon *","insertItem", 6, argv[4] )); 
+    }
+    arg6 = reinterpret_cast< FXIcon * >(argp6);
+  }
+  if (argc > 5) {
+    arg7 = (argv[5] == Qnil) ? NULL : (void *) argv[5];
+  }
+  result = (FXTreeItem *)(arg1)->insertItem(arg2,arg3,(FXString const &)*arg4,arg5,arg6,arg7);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXTreeListBox_insertItem(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[8];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 8) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTreeListBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXTreeItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXTreeItem, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXTreeItem, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            return _wrap_FXTreeListBox_insertItem__SWIG_0(nargs, args, self);
+          }
+        }
+      }
+    }
+  }
+  if ((argc >= 4) && (argc <= 7)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTreeListBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXTreeItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXTreeItem, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          {
+            _v = (NIL_P(argv[3]) || TYPE(argv[3]) == T_STRING) ? 1 : 0;
+          }
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXTreeListBox_insertItem__SWIG_1(nargs, args, self);
+            }
+            void *vptr = 0;
+            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_FXIcon, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_FXTreeListBox_insertItem__SWIG_1(nargs, args, self);
+              }
+              void *vptr = 0;
+              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_FXIcon, 0);
+              _v = SWIG_CheckState(res);
+              if (_v) {
+                if (argc <= 6) {
+                  return _wrap_FXTreeListBox_insertItem__SWIG_1(nargs, args, self);
+                }
+                {
+                  _v = 1;
+                }
+                if (_v) {
+                  return _wrap_FXTreeListBox_insertItem__SWIG_1(nargs, args, self);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 8, "insertItem", 
+    "    FXTreeItem insertItem(FXTreeItem *other, FXTreeItem *father, FXTreeItem *item)\n"
+    "    FXTreeItem * insertItem(FXTreeItem *other, FXTreeItem *father, FXString const &text, FXIcon *oi, FXIcon *ci, void *ITEMDATA)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_appendItem__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg3 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","appendItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","appendItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXTreeItem *","appendItem", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXTreeItem * >(argp3);
+  result = (FXTreeItem *)FXTreeListBox_appendItem__SWIG_0(arg1,arg2,arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_appendItem__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXString *arg3 = 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  void *arg6 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","appendItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","appendItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  if (argc > 2) {
+    res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","appendItem", 4, argv[2] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 3) {
+    res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","appendItem", 5, argv[3] )); 
+    }
+    arg5 = reinterpret_cast< FXIcon * >(argp5);
+  }
+  if (argc > 4) {
+    arg6 = (argv[4] == Qnil) ? NULL : (void *) argv[4];
+  }
+  result = (FXTreeItem *)(arg1)->appendItem(arg2,(FXString const &)*arg3,arg4,arg5,arg6);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXTreeListBox_appendItem(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[7];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 7) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTreeListBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXTreeItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXTreeItem, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_FXTreeListBox_appendItem__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  if ((argc >= 3) && (argc <= 6)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTreeListBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXTreeItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXTreeListBox_appendItem__SWIG_1(nargs, args, self);
+          }
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXTreeListBox_appendItem__SWIG_1(nargs, args, self);
+            }
+            void *vptr = 0;
+            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_FXIcon, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_FXTreeListBox_appendItem__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = 1;
+              }
+              if (_v) {
+                return _wrap_FXTreeListBox_appendItem__SWIG_1(nargs, args, self);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 7, "appendItem", 
+    "    FXTreeItem appendItem(FXTreeItem *father, FXTreeItem *item)\n"
+    "    FXTreeItem * appendItem(FXTreeItem *father, FXString const &text, FXIcon *oi, FXIcon *ci, void *ITEMDATA)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_prependItem__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg3 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","prependItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","prependItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXTreeItem *","prependItem", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXTreeItem * >(argp3);
+  result = (FXTreeItem *)FXTreeListBox_prependItem__SWIG_0(arg1,arg2,arg3);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_prependItem__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXString *arg3 = 0 ;
+  FXIcon *arg4 = (FXIcon *) 0 ;
+  FXIcon *arg5 = (FXIcon *) 0 ;
+  void *arg6 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  void *argp5 = 0 ;
+  int res5 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 5)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","prependItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","prependItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  if (argc > 2) {
+    res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXIcon *","prependItem", 4, argv[2] )); 
+    }
+    arg4 = reinterpret_cast< FXIcon * >(argp4);
+  }
+  if (argc > 3) {
+    res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_FXIcon, 0 |  0 );
+    if (!SWIG_IsOK(res5)) {
+      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "FXIcon *","prependItem", 5, argv[3] )); 
+    }
+    arg5 = reinterpret_cast< FXIcon * >(argp5);
+  }
+  if (argc > 4) {
+    arg6 = (argv[4] == Qnil) ? NULL : (void *) argv[4];
+  }
+  result = (FXTreeItem *)(arg1)->prependItem(arg2,(FXString const &)*arg3,arg4,arg5,arg6);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXTreeListBox_prependItem(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[7];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 7) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTreeListBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXTreeItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_FXTreeItem, 0);
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_FXTreeListBox_prependItem__SWIG_0(nargs, args, self);
+        }
+      }
+    }
+  }
+  if ((argc >= 3) && (argc <= 6)) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTreeListBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXTreeItem, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        {
+          _v = (NIL_P(argv[2]) || TYPE(argv[2]) == T_STRING) ? 1 : 0;
+        }
+        if (_v) {
+          if (argc <= 3) {
+            return _wrap_FXTreeListBox_prependItem__SWIG_1(nargs, args, self);
+          }
+          void *vptr = 0;
+          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_FXIcon, 0);
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            if (argc <= 4) {
+              return _wrap_FXTreeListBox_prependItem__SWIG_1(nargs, args, self);
+            }
+            void *vptr = 0;
+            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_FXIcon, 0);
+            _v = SWIG_CheckState(res);
+            if (_v) {
+              if (argc <= 5) {
+                return _wrap_FXTreeListBox_prependItem__SWIG_1(nargs, args, self);
+              }
+              {
+                _v = 1;
+              }
+              if (_v) {
+                return _wrap_FXTreeListBox_prependItem__SWIG_1(nargs, args, self);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 7, "prependItem", 
+    "    FXTreeItem prependItem(FXTreeItem *father, FXTreeItem *item)\n"
+    "    FXTreeItem * prependItem(FXTreeItem *father, FXString const &text, FXIcon *oi, FXIcon *ci, void *ITEMDATA)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_removeItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","removeItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","removeItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  FXTreeListBox_removeItem(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_removeItems(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg3 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","removeItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","removeItems", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXTreeItem *","removeItems", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXTreeItem * >(argp3);
+  FXTreeListBox_removeItems(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_clearItems(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","clearItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  FXTreeListBox_clearItems(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_moveItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg3 = (FXTreeItem *) 0 ;
+  FXTreeItem *arg4 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  void *argp4 = 0 ;
+  int res4 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","moveItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","moveItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXTreeItem *","moveItem", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXTreeItem * >(argp3);
+  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "FXTreeItem *","moveItem", 4, argv[2] )); 
+  }
+  arg4 = reinterpret_cast< FXTreeItem * >(argp4);
+  result = (FXTreeItem *)(arg1)->moveItem(arg2,arg3,arg4);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_extractItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","extractItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","extractItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXTreeItem *)(arg1)->extractItem(arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_findItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXString *arg2 = 0 ;
+  FXTreeItem *arg3 = (FXTreeItem *) 0 ;
+  FXuint arg4 = (FXuint) SEARCH_FORWARD|SEARCH_WRAP ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","findItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXTreeItem *","findItem", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXTreeItem * >(argp3);
+  }
+  if (argc > 2) {
+    arg4 = NUM2UINT(argv[2]);
+  }
+  result = (FXTreeItem *)((FXTreeListBox const *)arg1)->findItem((FXString const &)*arg2,arg3,arg4);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_findItemByData(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *arg2 = (void *) 0 ;
+  FXTreeItem *arg3 = (FXTreeItem *) 0 ;
+  FXuint arg4 = (FXuint) SEARCH_FORWARD|SEARCH_WRAP ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","findItemByData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  arg2 = (argv[0] == Qnil) ? NULL : (void *) argv[0];
+  if (argc > 1) {
+    res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXTreeItem *","findItemByData", 3, argv[1] )); 
+    }
+    arg3 = reinterpret_cast< FXTreeItem * >(argp3);
+  }
+  if (argc > 2) {
+    arg4 = NUM2UINT(argv[2]);
+  }
+  result = (FXTreeItem *)((FXTreeListBox const *)arg1)->findItemByData((void const *)arg2,arg3,arg4);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_isItemCurrent(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","isItemCurrent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","isItemCurrent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXbool)((FXTreeListBox const *)arg1)->isItemCurrent((FXTreeItem const *)arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_isItemLeaf(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","isItemLeaf", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","isItemLeaf", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXbool)((FXTreeListBox const *)arg1)->isItemLeaf((FXTreeItem const *)arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_sortRootItems(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","sortRootItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  (arg1)->sortRootItems();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_sortItems(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","sortItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  (arg1)->sortItems();
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_sortChildItems(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","sortChildItems", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","sortChildItems", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  (arg1)->sortChildItems(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_getCurrentItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXTreeItem *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","getCurrentItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  result = (FXTreeItem *)((FXTreeListBox const *)arg1)->getCurrentItem();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXTreeItem, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_setItemText(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXString *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","setItemText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","setItemText", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  (arg1)->setItemText(arg2,(FXString const &)*arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_getItemText(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","getItemText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","getItemText", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = ((FXTreeListBox const *)arg1)->getItemText((FXTreeItem const *)arg2);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_setItemOpenIcon(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","setItemOpenIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","setItemOpenIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","setItemOpenIcon", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXIcon * >(argp3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  (arg1)->setItemOpenIcon(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_getItemOpenIcon(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","getItemOpenIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","getItemOpenIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXIcon *)((FXTreeListBox const *)arg1)->getItemOpenIcon((FXTreeItem const *)arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_setItemClosedIcon(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXIcon *arg3 = (FXIcon *) 0 ;
+  FXbool arg4 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","setItemClosedIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","setItemClosedIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXIcon *","setItemClosedIcon", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXIcon * >(argp3);
+  if (argc > 2) {
+    arg4 = to_FXbool(argv[2]);
+  }
+  (arg1)->setItemClosedIcon(arg2,arg3,arg4);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_getItemClosedIcon(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXIcon *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","getItemClosedIcon", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","getItemClosedIcon", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (FXIcon *)((FXTreeListBox const *)arg1)->getItemClosedIcon((FXTreeItem const *)arg2);
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXIcon, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_setItemData(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  VALUE arg3 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","setItemData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","setItemData", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  arg3 = argv[1];
+  FXTreeListBox_setItemData(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_getItemData(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","getItemData", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem const *","getItemData", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  result = (VALUE)FXTreeListBox_getItemData((FXTreeListBox const *)arg1,(FXTreeItem const *)arg2);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_isPaneShown(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","isPaneShown", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  result = (FXbool)((FXTreeListBox const *)arg1)->isPaneShown();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_setFont(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  (arg1)->setFont(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_getFont(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  result = (FXFont *)((FXTreeListBox const *)arg1)->getFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_getListStyle(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","getListStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  result = (FXuint)((FXTreeListBox const *)arg1)->getListStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_setListStyle(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","setListStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setListStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  result = (FXString *) &((FXTreeListBox const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_setTipText(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_getTipText(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  result = (FXString *) &((FXTreeListBox const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_save(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTreeListBox_save((FXTreeListBox const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_load(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXTreeListBox_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_create(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  FXTreeListBox_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_detach(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  FXTreeListBox_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_destroy(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  FXTreeListBox_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_resize(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXTreeListBox_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  result = (FXint)FXTreeListBox_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  result = (FXint)FXTreeListBox_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXTreeListBox_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXTreeListBox_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  result = (bool)FXTreeListBox_canFocus((FXTreeListBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  FXTreeListBox_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  FXTreeListBox_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXTreeListBox_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXTreeListBox_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_enable(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  FXTreeListBox_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_disable(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  FXTreeListBox_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  FXTreeListBox_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_lower(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  FXTreeListBox_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_move(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXTreeListBox_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_position(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXTreeListBox_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_layout(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  FXTreeListBox_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_recalc(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  FXTreeListBox_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_reparent(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXTreeListBox_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_show(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  FXTreeListBox_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_hide(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  FXTreeListBox_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  result = (bool)FXTreeListBox_isComposite((FXTreeListBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_contains(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXTreeListBox_contains((FXTreeListBox const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  result = (bool)FXTreeListBox_doesSaveUnder((FXTreeListBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXTreeListBox_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_tr(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXTreeListBox_tr((FXTreeListBox const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  FXTreeListBox_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  FXTreeListBox_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXTreeListBox_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXTreeListBox_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXTreeListBox_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXTreeListBox_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTreeListBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTreeListBox_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTreeListBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTreeListBox_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXTreeListBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXTreeListBox_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  FXTreeListBox_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXTreeListBox_setCurrentItem(int argc, VALUE *argv, VALUE self) {
+  FXTreeListBox *arg1 = (FXTreeListBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXTreeListBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXTreeListBox *","setCurrentItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXTreeListBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","setCurrentItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXTreeListBox_setCurrentItem(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXImageView;
+
+SWIGINTERN VALUE
+_wrap_FXImageView_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_onRightBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","onRightBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onRightBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_onRightBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","onRightBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onRightBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onRightBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXImageView_allocate(VALUE self)
+#else
+_wrap_FXImageView_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXImageView);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXImageView(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXImage *arg2 = (FXImage *) 0 ;
+  FXObject *arg3 = (FXObject *) 0 ;
+  FXSelector arg4 = (FXSelector) 0 ;
+  FXuint arg5 = (FXuint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXImageView *result = 0 ;
+  
+  if ((argc < 1) || (argc > 9)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXImageView", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXImage, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXImage *","FXImageView", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXImage * >(argp2);
+  }
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXObject *","FXImageView", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXObject * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXImageView *)new_FXImageView(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_setImage(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  FXImage *arg2 = (FXImage *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","setImage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXImage, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXImage *","setImage", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXImage * >(argp2);
+  (arg1)->setImage(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_getImage(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXImage *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView const *","getImage", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  result = (FXImage *)((FXImageView const *)arg1)->getImage();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXImage, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_setAlignment(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","setAlignment", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setAlignment(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_getAlignment(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView const *","getAlignment", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  result = (FXuint)((FXImageView const *)arg1)->getAlignment();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_save(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXImageView_save((FXImageView const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_load(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXImageView_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_create(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  FXImageView_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_detach(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  FXImageView_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_destroy(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  FXImageView_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_resize(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXImageView_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  result = (FXint)FXImageView_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  result = (FXint)FXImageView_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXImageView_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXImageView_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  result = (bool)FXImageView_canFocus((FXImageView const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  FXImageView_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  FXImageView_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXImageView_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXImageView_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_enable(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  FXImageView_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_disable(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  FXImageView_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  FXImageView_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_lower(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  FXImageView_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_move(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXImageView_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXImageView_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_layout(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  FXImageView_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_recalc(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  FXImageView_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_reparent(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXImageView_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_show(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  FXImageView_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_hide(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  FXImageView_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  result = (bool)FXImageView_isComposite((FXImageView const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_contains(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXImageView_contains((FXImageView const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  result = (bool)FXImageView_doesSaveUnder((FXImageView const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXImageView_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_tr(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXImageView_tr((FXImageView const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  FXImageView_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  FXImageView_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXImageView_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXImageView_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXImageView_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXImageView_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXImageView, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXImageView_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXImageView, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXImageView_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXImageView, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXImageView_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  FXImageView_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_getViewportHeight(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","getViewportHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  result = (FXint)FXImageView_getViewportHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_getViewportWidth(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","getViewportWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  result = (FXint)FXImageView_getViewportWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_getContentHeight(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","getContentHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  result = (FXint)FXImageView_getContentHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_getContentWidth(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView *","getContentWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  result = (FXint)FXImageView_getContentWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXImageView_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXImageView *arg1 = (FXImageView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXImageView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXImageView const *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXImageView * >(argp1);
+  result = (VALUE)FXImageView_position__SWIG_1((FXImageView const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXImageView_position(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXImageView, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXImageView_position__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXImageView, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXImageView_position__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "position", 
+    "    void position(FXint x, FXint y, FXint w, FXint h)\n"
+    "    VALUE position()\n");
+  
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXDragCorner;
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXDragCorner_allocate(VALUE self)
+#else
+_wrap_FXDragCorner_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXDragCorner);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXDragCorner(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXDragCorner *result = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXDragCorner", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXDragCorner *)new_FXDragCorner(arg1);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_setHiliteColor(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","setHiliteColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setHiliteColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_getHiliteColor(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner const *","getHiliteColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  result = (FXColor)((FXDragCorner const *)arg1)->getHiliteColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_setShadowColor(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","setShadowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setShadowColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_getShadowColor(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner const *","getShadowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  result = (FXColor)((FXDragCorner const *)arg1)->getShadowColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_save(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDragCorner_save((FXDragCorner const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_load(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDragCorner_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_create(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  FXDragCorner_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_detach(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  FXDragCorner_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_destroy(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  FXDragCorner_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_resize(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDragCorner_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  result = (FXint)FXDragCorner_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  result = (FXint)FXDragCorner_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDragCorner_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDragCorner_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  result = (bool)FXDragCorner_canFocus((FXDragCorner const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  FXDragCorner_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  FXDragCorner_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXDragCorner_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXDragCorner_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_enable(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  FXDragCorner_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_disable(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  FXDragCorner_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  FXDragCorner_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_lower(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  FXDragCorner_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_move(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDragCorner_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_position(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDragCorner_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_layout(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  FXDragCorner_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_recalc(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  FXDragCorner_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_reparent(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXDragCorner_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_show(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  FXDragCorner_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_hide(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  FXDragCorner_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  result = (bool)FXDragCorner_isComposite((FXDragCorner const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_contains(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXDragCorner_contains((FXDragCorner const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  result = (bool)FXDragCorner_doesSaveUnder((FXDragCorner const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXDragCorner_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_tr(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXDragCorner_tr((FXDragCorner const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  FXDragCorner_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  FXDragCorner_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXDragCorner_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXDragCorner_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXDragCorner_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDragCorner_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDragCorner, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDragCorner_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDragCorner, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDragCorner_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDragCorner, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDragCorner_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDragCorner_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXDragCorner *arg1 = (FXDragCorner *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDragCorner, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDragCorner *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDragCorner * >(argp1);
+  FXDragCorner_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXDirBox;
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_onTreeChanged(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","onTreeChanged", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTreeChanged", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onTreeChanged(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_onTreeClicked(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","onTreeClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onTreeClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onTreeClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = static_cast<void*>(StringValuePtr(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_onCmdSetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","onCmdSetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_onCmdGetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","onCmdGetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXDirBox_allocate(VALUE self)
+#else
+_wrap_FXDirBox_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXDirBox);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXDirBox(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) FRAME_SUNKEN|FRAME_THICK|TREELISTBOX_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) DEFAULT_PAD ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXDirBox *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXDirBox", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXDirBox", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXDirBox *)new_FXDirBox(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_setDirectory(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","setDirectory", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setDirectory((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_getDirectory(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox const *","getDirectory", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  result = ((FXDirBox const *)arg1)->getDirectory();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_setAssociations(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXFileDict *arg2 = (FXFileDict *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","setAssociations", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFileDict, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFileDict *","setAssociations", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFileDict * >(argp2);
+  (arg1)->setAssociations(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_getAssociations(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFileDict *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox const *","getAssociations", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  result = (FXFileDict *)((FXDirBox const *)arg1)->getAssociations();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFileDict, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_save(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDirBox_save((FXDirBox const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_load(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDirBox_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_create(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  FXDirBox_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_detach(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  FXDirBox_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_destroy(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  FXDirBox_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_resize(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDirBox_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  result = (FXint)FXDirBox_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  result = (FXint)FXDirBox_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDirBox_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDirBox_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  result = (bool)FXDirBox_canFocus((FXDirBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  FXDirBox_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  FXDirBox_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXDirBox_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXDirBox_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_enable(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  FXDirBox_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_disable(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  FXDirBox_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  FXDirBox_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_lower(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  FXDirBox_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_move(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDirBox_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_position(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDirBox_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_layout(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  FXDirBox_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_recalc(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  FXDirBox_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_reparent(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXDirBox_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_show(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  FXDirBox_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_hide(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  FXDirBox_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  result = (bool)FXDirBox_isComposite((FXDirBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_contains(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXDirBox_contains((FXDirBox const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  result = (bool)FXDirBox_doesSaveUnder((FXDirBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXDirBox_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_tr(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXDirBox_tr((FXDirBox const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  FXDirBox_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  FXDirBox_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXDirBox_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXDirBox_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXDirBox_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDirBox_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDirBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDirBox_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDirBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDirBox_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDirBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDirBox_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  FXDirBox_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirBox_setCurrentItem(int argc, VALUE *argv, VALUE self) {
+  FXDirBox *arg1 = (FXDirBox *) 0 ;
+  FXTreeItem *arg2 = (FXTreeItem *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirBox *","setCurrentItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXTreeItem, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXTreeItem *","setCurrentItem", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXTreeItem * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXDirBox_setCurrentItem(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXDriveBox;
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_onListChanged(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","onListChanged", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onListChanged", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onListChanged(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_onListClicked(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","onListClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onListClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onListClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = static_cast<void*>(StringValuePtr(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_onCmdSetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXString value4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","onCmdSetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    value4 = FXString(StringValuePtr(argv[2]));
+    arg4 = (void *) &value4;
+  }
+  result = (long)(arg1)->onCmdSetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_onCmdGetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","onCmdGetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdGetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXDriveBox_allocate(VALUE self)
+#else
+_wrap_FXDriveBox_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXDriveBox);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXDriveBox(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) FRAME_SUNKEN|FRAME_THICK|LISTBOX_NORMAL ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) DEFAULT_PAD ;
+  FXint arg10 = (FXint) DEFAULT_PAD ;
+  FXint arg11 = (FXint) DEFAULT_PAD ;
+  FXint arg12 = (FXint) DEFAULT_PAD ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXDriveBox *result = 0 ;
+  
+  if ((argc < 1) || (argc > 12)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXDriveBox", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXDriveBox", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXDriveBox *)new_FXDriveBox(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_setDrive(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","setDrive", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  result = (FXbool)(arg1)->setDrive((FXString const &)*arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_getDrive(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox const *","getDrive", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  result = ((FXDriveBox const *)arg1)->getDrive();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_setAssociations(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXFileDict *arg2 = (FXFileDict *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","setAssociations", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFileDict, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFileDict *","setAssociations", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFileDict * >(argp2);
+  (arg1)->setAssociations(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_getAssociations(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFileDict *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox const *","getAssociations", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  result = (FXFileDict *)((FXDriveBox const *)arg1)->getAssociations();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFileDict, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_save(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDriveBox_save((FXDriveBox const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_load(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDriveBox_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_create(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  FXDriveBox_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_detach(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  FXDriveBox_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_destroy(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  FXDriveBox_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_resize(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDriveBox_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  result = (FXint)FXDriveBox_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  result = (FXint)FXDriveBox_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDriveBox_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDriveBox_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  result = (bool)FXDriveBox_canFocus((FXDriveBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  FXDriveBox_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  FXDriveBox_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXDriveBox_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXDriveBox_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_enable(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  FXDriveBox_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_disable(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  FXDriveBox_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  FXDriveBox_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_lower(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  FXDriveBox_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_move(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDriveBox_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_position(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDriveBox_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_layout(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  FXDriveBox_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_recalc(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  FXDriveBox_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_reparent(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXDriveBox_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_show(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  FXDriveBox_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_hide(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  FXDriveBox_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  result = (bool)FXDriveBox_isComposite((FXDriveBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_contains(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXDriveBox_contains((FXDriveBox const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  result = (bool)FXDriveBox_doesSaveUnder((FXDriveBox const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXDriveBox_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_tr(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXDriveBox_tr((FXDriveBox const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  FXDriveBox_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  FXDriveBox_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXDriveBox_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXDriveBox_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXDriveBox_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDriveBox_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDriveBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDriveBox_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDriveBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDriveBox_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDriveBox, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDriveBox_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  FXDriveBox_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDriveBox_setCurrentItem(int argc, VALUE *argv, VALUE self) {
+  FXDriveBox *arg1 = (FXDriveBox *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDriveBox, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDriveBox *","setCurrentItem", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDriveBox * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  FXDriveBox_setCurrentItem(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXDirSelector;
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_onCmdName(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","onCmdName", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdName", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdName(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_onCmdOpened(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","onCmdOpened", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdOpened", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  SWIG_ConvertPtr(argv[2],&arg4,SWIGTYPE_p_FXTreeItem,1);
+  result = (long)(arg1)->onCmdOpened(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_onCmdHome(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","onCmdHome", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdHome", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdHome(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_onCmdWork(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","onCmdWork", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdWork", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdWork(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_onCmdDirectoryUp(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","onCmdDirectoryUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDirectoryUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDirectoryUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_onPopupMenu(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","onPopupMenu", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPopupMenu", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPopupMenu(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_onCmdBookmark(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","onCmdBookmark", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdBookmark", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdBookmark(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_onCmdVisit(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","onCmdVisit", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdVisit", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdVisit", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdVisit(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_onCmdNew(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","onCmdNew", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdNew", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdNew(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_onUpdNew(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","onUpdNew", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdNew", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdNew(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_onCmdMove(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","onCmdMove", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMove", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdMove(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_onCmdCopy(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","onCmdCopy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCopy", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCopy(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_onCmdLink(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","onCmdLink", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdLink", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdLink(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_onCmdDelete(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","onCmdDelete", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDelete", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDelete(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_onUpdSelected(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","onUpdSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSelected", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdSelected(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXDirSelector_allocate(VALUE self)
+#else
+_wrap_FXDirSelector_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXDirSelector);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXDirSelector(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXDirSelector *result = 0 ;
+  
+  if ((argc < 1) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXDirSelector", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXDirSelector", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXDirSelector *)new_FXDirSelector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_acceptButton(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXButton *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector const *","acceptButton", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  result = (FXButton *)((FXDirSelector const *)arg1)->acceptButton();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXButton, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_cancelButton(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXButton *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector const *","cancelButton", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  result = (FXButton *)((FXDirSelector const *)arg1)->cancelButton();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXButton, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_setDirectory(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","setDirectory", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setDirectory((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_getDirectory(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector const *","getDirectory", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  result = ((FXDirSelector const *)arg1)->getDirectory();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_getShowFiles(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector const *","showFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  result = (FXbool)((FXDirSelector const *)arg1)->showFiles();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_setShowFiles(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","showFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->showFiles(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_getShowHiddenFiles(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector const *","showHiddenFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  result = (FXbool)((FXDirSelector const *)arg1)->showHiddenFiles();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_setShowHiddenFiles(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","showHiddenFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->showHiddenFiles(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_getMatchMode(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector const *","getMatchMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  result = (FXuint)((FXDirSelector const *)arg1)->getMatchMode();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_setMatchMode(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","setMatchMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setMatchMode(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_setDirBoxStyle(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","setDirBoxStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setDirBoxStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_getDirBoxStyle(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector const *","getDirBoxStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  result = (FXuint)((FXDirSelector const *)arg1)->getDirBoxStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_save(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDirSelector_save((FXDirSelector const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_load(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDirSelector_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_create(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  FXDirSelector_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_detach(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  FXDirSelector_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_destroy(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  FXDirSelector_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_resize(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDirSelector_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  result = (FXint)FXDirSelector_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  result = (FXint)FXDirSelector_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDirSelector_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDirSelector_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  result = (bool)FXDirSelector_canFocus((FXDirSelector const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  FXDirSelector_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  FXDirSelector_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXDirSelector_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXDirSelector_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_enable(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  FXDirSelector_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_disable(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  FXDirSelector_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  FXDirSelector_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_lower(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  FXDirSelector_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_move(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDirSelector_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_position(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDirSelector_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_layout(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  FXDirSelector_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_recalc(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  FXDirSelector_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_reparent(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXDirSelector_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_show(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  FXDirSelector_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_hide(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  FXDirSelector_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  result = (bool)FXDirSelector_isComposite((FXDirSelector const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_contains(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXDirSelector_contains((FXDirSelector const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  result = (bool)FXDirSelector_doesSaveUnder((FXDirSelector const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXDirSelector_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_tr(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXDirSelector_tr((FXDirSelector const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  FXDirSelector_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  FXDirSelector_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXDirSelector_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXDirSelector_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXDirSelector_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDirSelector_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDirSelector, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDirSelector_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDirSelector, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDirSelector_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDirSelector, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDirSelector_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDirSelector_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXDirSelector *arg1 = (FXDirSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDirSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDirSelector *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDirSelector * >(argp1);
+  FXDirSelector_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXFileSelector;
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_onCmdAccept(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","onCmdAccept", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdAccept", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdAccept(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_onCmdFilter(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","onCmdFilter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdFilter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = static_cast<void*>(StringValuePtr(argv[2]));
+  result = (long)(arg1)->onCmdFilter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_onCmdItemDblClicked(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","onCmdItemDblClicked", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdItemDblClicked", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdItemDblClicked(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_onCmdItemSelected(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","onCmdItemSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdItemSelected", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdItemSelected(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_onCmdItemDeselected(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","onCmdItemDeselected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdItemDeselected", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdItemDeselected(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_onCmdDirectoryUp(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","onCmdDirectoryUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDirectoryUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDirectoryUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_onUpdDirectoryUp(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","onUpdDirectoryUp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdDirectoryUp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdDirectoryUp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_onCmdDirTree(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","onCmdDirTree", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDirTree", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = static_cast<void*>(StringValuePtr(argv[2]));
+  result = (long)(arg1)->onCmdDirTree(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_onCmdHome(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","onCmdHome", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdHome", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdHome(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_onCmdWork(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","onCmdWork", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdWork", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdWork(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_onCmdBookmark(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","onCmdBookmark", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdBookmark", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdBookmark(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_onCmdVisit(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","onCmdVisit", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdVisit", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = static_cast<void*>(StringValuePtr(argv[2]));
+  result = (long)(arg1)->onCmdVisit(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_onCmdNew(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","onCmdNew", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdNew", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdNew(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_onUpdNew(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","onUpdNew", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdNew", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdNew(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_onCmdMove(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","onCmdMove", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdMove", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdMove(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_onCmdCopy(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","onCmdCopy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCopy", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCopy(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_onCmdLink(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","onCmdLink", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdLink", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdLink(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_onCmdDelete(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","onCmdDelete", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdDelete", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdDelete(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_onUpdSelected(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","onUpdSelected", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSelected", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdSelected(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_onPopupMenu(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","onPopupMenu", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPopupMenu", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPopupMenu(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_onCmdImageSize(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","onCmdImageSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdImageSize", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdImageSize(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_onUpdImageSize(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","onUpdImageSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdImageSize", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdImageSize(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_onUpdNavigable(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","onUpdNavigable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdNavigable", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdNavigable(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXFileSelector_allocate(VALUE self)
+#else
+_wrap_FXFileSelector_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXFileSelector);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXFileSelector(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXFileSelector *result = 0 ;
+  
+  if ((argc < 1) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXFileSelector", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXFileSelector", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXFileSelector *)new_FXFileSelector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_acceptButton(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXButton *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","acceptButton", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = (FXButton *)((FXFileSelector const *)arg1)->acceptButton();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXButton, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_cancelButton(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXButton *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","cancelButton", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = (FXButton *)((FXFileSelector const *)arg1)->cancelButton();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXButton, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_setFilename(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","setFilename", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setFilename((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_getFilename(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","getFilename", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = ((FXFileSelector const *)arg1)->getFilename();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_getFilenames(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","getFilenames", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = (VALUE)FXFileSelector_getFilenames((FXFileSelector const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_setPattern(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","setPattern", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setPattern((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_getPattern(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","getPattern", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = ((FXFileSelector const *)arg1)->getPattern();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_setPatternList(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  VALUE arg2 = (VALUE) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","setPatternList", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  arg2 = argv[0];
+  FXFileSelector_setPatternList(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_getPatternList(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","getPatternList", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = (VALUE)FXFileSelector_getPatternList((FXFileSelector const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_setCurrentPattern(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","setCurrentPattern", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setCurrentPattern(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_getCurrentPattern(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","getCurrentPattern", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = (FXint)((FXFileSelector const *)arg1)->getCurrentPattern();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_getPatternText(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","getPatternText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = ((FXFileSelector const *)arg1)->getPatternText(arg2);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_setPatternText(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXint arg2 ;
+  FXString *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p3 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","setPatternText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  p3 = to_FXString(argv[1]); arg3 = &p3;
+  (arg1)->setPatternText(arg2,(FXString const &)*arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_numPatterns(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","getNumPatterns", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = (FXint)((FXFileSelector const *)arg1)->getNumPatterns();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_setAllowPatternEntry(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","allowPatternEntry", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->allowPatternEntry(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_getAllowPatternEntry(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","allowPatternEntry", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = (FXbool)((FXFileSelector const *)arg1)->allowPatternEntry();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_setDirectory(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","setDirectory", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setDirectory((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_getDirectory(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","getDirectory", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = ((FXFileSelector const *)arg1)->getDirectory();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_patternFromText(int argc, VALUE *argv, VALUE self) {
+  FXString *arg1 = 0 ;
+  SwigValueWrapper< FXString > p1 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  p1 = to_FXString(argv[0]); arg1 = &p1;
+  result = FXFileSelector::patternFromText((FXString const &)*arg1);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_extensionFromPattern(int argc, VALUE *argv, VALUE self) {
+  FXString *arg1 = 0 ;
+  SwigValueWrapper< FXString > p1 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  p1 = to_FXString(argv[0]); arg1 = &p1;
+  result = FXFileSelector::extensionFromPattern((FXString const &)*arg1);
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_setItemSpace(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","setItemSpace", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setItemSpace(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_getItemSpace(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","getItemSpace", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = (FXint)((FXFileSelector const *)arg1)->getItemSpace();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_setFileBoxStyle(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","setFileBoxStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setFileBoxStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_getFileBoxStyle(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","getFileBoxStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = (FXuint)((FXFileSelector const *)arg1)->getFileBoxStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_setSelectMode(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","setSelectMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setSelectMode(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_getSelectMode(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","getSelectMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = (FXuint)((FXFileSelector const *)arg1)->getSelectMode();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_setMatchMode(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","setMatchMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setMatchMode(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_getMatchMode(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","getMatchMode", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = (FXuint)((FXFileSelector const *)arg1)->getMatchMode();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_getShowHiddenFiles(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","showHiddenFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = (FXbool)((FXFileSelector const *)arg1)->showHiddenFiles();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_setShowHiddenFiles(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","showHiddenFiles", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->showHiddenFiles(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_getShowImages(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","showImages", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = (FXbool)((FXFileSelector const *)arg1)->showImages();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_setShowImages(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","showImages", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->showImages(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_getImageSize(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","getImageSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = (FXint)((FXFileSelector const *)arg1)->getImageSize();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_setImageSize(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","setImageSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setImageSize(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_setReadOnlyShown(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","showReadOnly", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->showReadOnly(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_getReadOnlyShown(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","shownReadOnly", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = (FXbool)((FXFileSelector const *)arg1)->shownReadOnly();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_setReadOnly(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","setReadOnly", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->setReadOnly(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_getReadOnly(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","getReadOnly", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = (FXbool)((FXFileSelector const *)arg1)->getReadOnly();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_navigationAllowede___(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","allowNavigation", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->allowNavigation(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_navigationAllowedq___(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","allowNavigation", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = (FXbool)((FXFileSelector const *)arg1)->allowNavigation();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_save(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXFileSelector_save((FXFileSelector const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_load(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXFileSelector_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_create(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  FXFileSelector_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_detach(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  FXFileSelector_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_destroy(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  FXFileSelector_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_resize(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXFileSelector_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = (FXint)FXFileSelector_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = (FXint)FXFileSelector_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXFileSelector_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXFileSelector_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = (bool)FXFileSelector_canFocus((FXFileSelector const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  FXFileSelector_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  FXFileSelector_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXFileSelector_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXFileSelector_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_enable(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  FXFileSelector_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_disable(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  FXFileSelector_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  FXFileSelector_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_lower(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  FXFileSelector_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_move(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXFileSelector_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_position(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXFileSelector_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_layout(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  FXFileSelector_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_recalc(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  FXFileSelector_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_reparent(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXFileSelector_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_show(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  FXFileSelector_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_hide(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  FXFileSelector_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = (bool)FXFileSelector_isComposite((FXFileSelector const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_contains(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXFileSelector_contains((FXFileSelector const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  result = (bool)FXFileSelector_doesSaveUnder((FXFileSelector const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXFileSelector_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_tr(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXFileSelector_tr((FXFileSelector const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  FXFileSelector_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  FXFileSelector_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXFileSelector_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXFileSelector_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXFileSelector_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXFileSelector_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFileSelector, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXFileSelector_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFileSelector, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXFileSelector_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFileSelector, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXFileSelector_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFileSelector_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXFileSelector *arg1 = (FXFileSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFileSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFileSelector *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFileSelector * >(argp1);
+  FXFileSelector_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXColorSelector;
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onCmdWell(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onCmdWell", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdWell", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdWell(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onChgWell(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onChgWell", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onChgWell", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2UINT(argv[2]));
+  result = (long)(arg1)->onChgWell(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onCmdRGBSlider(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onCmdRGBSlider", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdRGBSlider", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdRGBSlider(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onUpdRGBSlider(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onUpdRGBSlider", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdRGBSlider", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdRGBSlider(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onCmdRGBText(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onCmdRGBText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdRGBText", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdRGBText(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onUpdRGBText(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onUpdRGBText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdRGBText", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdRGBText(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onCmdHSVSlider(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onCmdHSVSlider", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdHSVSlider", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdHSVSlider(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onUpdHSVSlider(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onUpdHSVSlider", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdHSVSlider", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdHSVSlider(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onCmdHSVText(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onCmdHSVText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdHSVText", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdHSVText(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onUpdHSVText(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onUpdHSVText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdHSVText", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdHSVText(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onCmdCMYSlider(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onCmdCMYSlider", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCMYSlider", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCMYSlider(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onUpdCMYSlider(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onUpdCMYSlider", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdCMYSlider", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdCMYSlider(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onCmdCMYText(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onCmdCMYText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCMYText", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCMYText(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onUpdCMYText(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onUpdCMYText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdCMYText", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdCMYText(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onCmdList(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onCmdList", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdList", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdList(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onCmdCustomWell(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onCmdCustomWell", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCustomWell", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2UINT(argv[2]));
+  result = (long)(arg1)->onCmdCustomWell(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onChgCustomWell(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onChgCustomWell", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onChgCustomWell", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2UINT(argv[2]));
+  result = (long)(arg1)->onChgCustomWell(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2UINT(argv[2]));
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onCmdActivePane(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onCmdActivePane", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdActivePane", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdActivePane(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onCmdAlphaSlider(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onCmdAlphaSlider", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdAlphaSlider", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdAlphaSlider(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onUpdAlphaSlider(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onUpdAlphaSlider", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdAlphaSlider", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdAlphaSlider(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onCmdAlphaText(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onCmdAlphaText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdAlphaText", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdAlphaText(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onUpdAlphaText(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onUpdAlphaText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdAlphaText", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdAlphaText(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onUpdAlphaLabel(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onUpdAlphaLabel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdAlphaLabel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdAlphaLabel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onCmdWheel(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXfloat values4[3] ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onCmdWheel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdWheel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  {
+    Check_Type(argv[2], T_ARRAY);
+    values4[0] = (FXfloat) NUM2DBL(rb_ary_entry(argv[2], 0));
+    values4[1] = (FXfloat) NUM2DBL(rb_ary_entry(argv[2], 1));
+    values4[2] = (FXfloat) NUM2DBL(rb_ary_entry(argv[2], 2));
+    arg4 = (void *) values4;
+  }
+  result = (long)(arg1)->onCmdWheel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onUpdWheel(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onUpdWheel", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdWheel", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdWheel(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_onCmdColorPick(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","onCmdColorPick", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdColorPick", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = FXRbConvertPtr(argv[2], FXRbTypeQuery("FXPoint *"));
+  result = (long)(arg1)->onCmdColorPick(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXColorSelector_allocate(VALUE self)
+#else
+_wrap_FXColorSelector_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXColorSelector);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXColorSelector(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXColorSelector *result = 0 ;
+  
+  if ((argc < 1) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXColorSelector", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXColorSelector", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXColorSelector *)new_FXColorSelector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_acceptButton(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXButton *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector const *","acceptButton", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  result = (FXButton *)((FXColorSelector const *)arg1)->acceptButton();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXButton, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_cancelButton(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXButton *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector const *","cancelButton", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  result = (FXButton *)((FXColorSelector const *)arg1)->cancelButton();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXButton, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_setRGBA(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","setRGBA", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setRGBA(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_getRGBA(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector const *","getRGBA", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  result = (FXColor)((FXColorSelector const *)arg1)->getRGBA();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_isOpaqueOnly(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector const *","isOpaqueOnly", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  result = (FXbool)((FXColorSelector const *)arg1)->isOpaqueOnly();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_setOpaqueOnly(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXbool arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","setOpaqueOnly", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  arg2 = to_FXbool(argv[0]);
+  (arg1)->setOpaqueOnly(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_save(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXColorSelector_save((FXColorSelector const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_load(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXColorSelector_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_create(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  FXColorSelector_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_detach(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  FXColorSelector_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_destroy(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  FXColorSelector_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_resize(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXColorSelector_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  result = (FXint)FXColorSelector_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  result = (FXint)FXColorSelector_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXColorSelector_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXColorSelector_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  result = (bool)FXColorSelector_canFocus((FXColorSelector const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  FXColorSelector_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  FXColorSelector_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXColorSelector_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXColorSelector_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_enable(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  FXColorSelector_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_disable(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  FXColorSelector_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  FXColorSelector_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_lower(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  FXColorSelector_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_move(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXColorSelector_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_position(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXColorSelector_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_layout(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  FXColorSelector_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_recalc(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  FXColorSelector_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_reparent(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXColorSelector_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_show(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  FXColorSelector_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_hide(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  FXColorSelector_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  result = (bool)FXColorSelector_isComposite((FXColorSelector const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_contains(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXColorSelector_contains((FXColorSelector const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  result = (bool)FXColorSelector_doesSaveUnder((FXColorSelector const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXColorSelector_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_tr(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXColorSelector_tr((FXColorSelector const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  FXColorSelector_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  FXColorSelector_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXColorSelector_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXColorSelector_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXColorSelector_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXColorSelector_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorSelector, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXColorSelector_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorSelector, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXColorSelector_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXColorSelector, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXColorSelector_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXColorSelector_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXColorSelector *arg1 = (FXColorSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXColorSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXColorSelector *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXColorSelector * >(argp1);
+  FXColorSelector_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXFontSelector;
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_onCmdFamily(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","onCmdFamily", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdFamily", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdFamily(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_onCmdWeight(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","onCmdWeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdWeight", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdWeight(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_onCmdStyle(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","onCmdStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdStyle", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdStyle(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_onCmdStyleText(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","onCmdStyleText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdStyleText", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdStyleText(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_onCmdSize(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","onCmdSize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSize", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = reinterpret_cast<void*>(NUM2INT(argv[2]));
+  result = (long)(arg1)->onCmdSize(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_onCmdSizeText(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","onCmdSizeText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSizeText", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSizeText(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_onCmdCharset(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","onCmdCharset", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdCharset", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdCharset(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_onUpdCharset(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","onUpdCharset", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdCharset", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdCharset(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_onCmdSetWidth(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","onCmdSetWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetWidth", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdSetWidth(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_onUpdSetWidth(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","onUpdSetWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdSetWidth", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdSetWidth(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_onCmdPitch(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","onCmdPitch", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdPitch", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdPitch(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_onUpdPitch(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","onUpdPitch", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdPitch", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdPitch(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_onCmdScalable(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","onCmdScalable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdScalable", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdScalable(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_onUpdScalable(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","onUpdScalable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdScalable", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdScalable(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_onCmdAllFonts(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","onCmdAllFonts", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdAllFonts", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onCmdAllFonts(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_onUpdAllFonts(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","onUpdAllFonts", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onUpdAllFonts", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = 0;
+  result = (long)(arg1)->onUpdAllFonts(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXFontSelector_allocate(VALUE self)
+#else
+_wrap_FXFontSelector_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXFontSelector);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXFontSelector(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXFontSelector *result = 0 ;
+  
+  if ((argc < 1) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXFontSelector", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXFontSelector", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXFontSelector *)new_FXFontSelector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_acceptButton(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXButton *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector const *","acceptButton", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  result = (FXButton *)((FXFontSelector const *)arg1)->acceptButton();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXButton, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_cancelButton(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXButton *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector const *","cancelButton", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  result = (FXButton *)((FXFontSelector const *)arg1)->cancelButton();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXButton, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_setFontSelection(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXFontDesc *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","setFontSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXFontDesc,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFontDesc const &","setFontSelection", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXFontDesc const &","setFontSelection", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXFontDesc * >(argp2);
+  (arg1)->setFontSelection((FXFontDesc const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_getFontSelection(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFontDesc result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector const *","getFontSelection", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  result = FXFontSelector_getFontSelection((FXFontSelector const *)arg1);
+  {
+    FXFontDesc* resultptr = new FXFontDesc(result);
+    vresult = FXRbGetRubyObj(resultptr, "FXFontDesc *");
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_save(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXFontSelector_save((FXFontSelector const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_load(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXFontSelector_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_create(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  FXFontSelector_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_detach(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  FXFontSelector_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_destroy(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  FXFontSelector_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_resize(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXFontSelector_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  result = (FXint)FXFontSelector_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  result = (FXint)FXFontSelector_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXFontSelector_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXFontSelector_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  result = (bool)FXFontSelector_canFocus((FXFontSelector const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  FXFontSelector_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  FXFontSelector_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXFontSelector_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXFontSelector_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_enable(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  FXFontSelector_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_disable(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  FXFontSelector_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  FXFontSelector_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_lower(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  FXFontSelector_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_move(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXFontSelector_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_position(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXFontSelector_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_layout(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  FXFontSelector_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_recalc(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  FXFontSelector_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_reparent(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXFontSelector_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_show(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  FXFontSelector_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_hide(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  FXFontSelector_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  result = (bool)FXFontSelector_isComposite((FXFontSelector const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_contains(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXFontSelector_contains((FXFontSelector const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  result = (bool)FXFontSelector_doesSaveUnder((FXFontSelector const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXFontSelector_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_tr(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXFontSelector_tr((FXFontSelector const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  FXFontSelector_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  FXFontSelector_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXFontSelector_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXFontSelector_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXFontSelector_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXFontSelector_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFontSelector, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXFontSelector_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFontSelector, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXFontSelector_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXFontSelector, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXFontSelector_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXFontSelector_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXFontSelector *arg1 = (FXFontSelector *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXFontSelector, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXFontSelector *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXFontSelector * >(argp1);
+  FXFontSelector_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXDockHandler;
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_onLeftBtnPress(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","onLeftBtnPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onLeftBtnPress", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onLeftBtnPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_onLeftBtnRelease(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","onLeftBtnRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeftBtnRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onLeftBtnRelease", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onLeftBtnRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onMotion", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_onKeyPress(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","onKeyPress", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyPress", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onKeyPress", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onKeyPress(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_onKeyRelease(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","onKeyRelease", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onKeyRelease", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onKeyRelease", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onKeyRelease(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onQueryTip", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onQueryHelp", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_onCmdSetTip(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","onCmdSetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdSetTip", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdSetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_onCmdGetTip(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","onCmdGetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetTip", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_onCmdSetHelp(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","onCmdSetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdSetHelp", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdSetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_onCmdGetHelp(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","onCmdGetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetHelp", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_helpTexte___(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_helpText(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  result = (FXString *) &((FXDockHandler const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_tipTexte___(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_tipText(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  result = (FXString *) &((FXDockHandler const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_save(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDockHandler_save((FXDockHandler const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_load(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDockHandler_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_create(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  FXDockHandler_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_detach(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  FXDockHandler_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_destroy(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  FXDockHandler_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_resize(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDockHandler_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  result = (FXint)FXDockHandler_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  result = (FXint)FXDockHandler_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDockHandler_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDockHandler_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  result = (bool)FXDockHandler_canFocus((FXDockHandler const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  FXDockHandler_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  FXDockHandler_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXDockHandler_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXDockHandler_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_enable(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  FXDockHandler_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_disable(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  FXDockHandler_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  FXDockHandler_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_lower(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  FXDockHandler_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_move(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDockHandler_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_position(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDockHandler_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_layout(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  FXDockHandler_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_recalc(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  FXDockHandler_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_reparent(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXDockHandler_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_show(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  FXDockHandler_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_hide(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  FXDockHandler_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  result = (bool)FXDockHandler_isComposite((FXDockHandler const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_contains(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXDockHandler_contains((FXDockHandler const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  result = (bool)FXDockHandler_doesSaveUnder((FXDockHandler const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXDockHandler_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_tr(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXDockHandler_tr((FXDockHandler const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  FXDockHandler_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  FXDockHandler_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXDockHandler_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXDockHandler_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXDockHandler_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDockHandler_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDockHandler, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDockHandler_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDockHandler, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDockHandler_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDockHandler, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDockHandler_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockHandler_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXDockHandler *arg1 = (FXDockHandler *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockHandler, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockHandler *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockHandler * >(argp1);
+  FXDockHandler_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXDockTitle;
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_onCmdSetValue(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","onCmdSetValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdSetValue", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdSetValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_onCmdSetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","onCmdSetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdSetStringValue", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdSetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_onCmdGetStringValue(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","onCmdGetStringValue", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetStringValue", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetStringValue", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetStringValue(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXDockTitle_allocate(VALUE self)
+#else
+_wrap_FXDockTitle_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXDockTitle);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXDockTitle(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXString *arg2 = 0 ;
+  FXObject *arg3 = (FXObject *) 0 ;
+  FXSelector arg4 = (FXSelector) 0 ;
+  FXuint arg5 = (FXuint) FRAME_NORMAL|JUSTIFY_CENTER_X|JUSTIFY_CENTER_Y ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  FXint arg9 = (FXint) 0 ;
+  FXint arg10 = (FXint) 0 ;
+  FXint arg11 = (FXint) 0 ;
+  FXint arg12 = (FXint) 0 ;
+  FXint arg13 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  FXDockTitle *result = 0 ;
+  
+  if ((argc < 2) || (argc > 13)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXDockTitle", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  p2 = to_FXString(argv[1]); arg2 = &p2;
+  if (argc > 2) {
+    res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXObject *","FXDockTitle", 3, argv[2] )); 
+    }
+    arg3 = reinterpret_cast< FXObject * >(argp3);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2UINT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  if (argc > 8) {
+    arg9 = NUM2INT(argv[8]);
+  }
+  if (argc > 9) {
+    arg10 = NUM2INT(argv[9]);
+  }
+  if (argc > 10) {
+    arg11 = NUM2INT(argv[10]);
+  }
+  if (argc > 11) {
+    arg12 = NUM2INT(argv[11]);
+  }
+  if (argc > 12) {
+    arg13 = NUM2INT(argv[12]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXDockTitle *)new_FXDockTitle(arg1,(FXString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_captione___(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","setCaption", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setCaption((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_caption(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle const *","getCaption", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  result = ((FXDockTitle const *)arg1)->getCaption();
+  vresult = to_ruby((&result)->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_fonte___(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","setFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  (arg1)->setFont(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_font(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle const *","getFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  result = (FXFont *)((FXDockTitle const *)arg1)->getFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_captionColor(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle const *","getCaptionColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  result = (FXColor)((FXDockTitle const *)arg1)->getCaptionColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_captionColore___(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","setCaptionColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setCaptionColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_justifye___(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","setJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setJustify(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_justify(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle const *","getJustify", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  result = (FXuint)((FXDockTitle const *)arg1)->getJustify();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_save(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDockTitle_save((FXDockTitle const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_load(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXDockTitle_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_create(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  FXDockTitle_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_detach(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  FXDockTitle_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_destroy(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  FXDockTitle_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_resize(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDockTitle_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  result = (FXint)FXDockTitle_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  result = (FXint)FXDockTitle_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDockTitle_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXDockTitle_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  result = (bool)FXDockTitle_canFocus((FXDockTitle const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  FXDockTitle_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  FXDockTitle_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXDockTitle_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXDockTitle_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_enable(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  FXDockTitle_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_disable(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  FXDockTitle_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  FXDockTitle_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_lower(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  FXDockTitle_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_move(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXDockTitle_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_position(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXDockTitle_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_layout(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  FXDockTitle_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_recalc(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  FXDockTitle_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_reparent(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXDockTitle_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_show(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  FXDockTitle_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_hide(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  FXDockTitle_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  result = (bool)FXDockTitle_isComposite((FXDockTitle const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_contains(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXDockTitle_contains((FXDockTitle const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  result = (bool)FXDockTitle_doesSaveUnder((FXDockTitle const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXDockTitle_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_tr(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXDockTitle_tr((FXDockTitle const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  FXDockTitle_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  FXDockTitle_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXDockTitle_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXDockTitle_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXDockTitle_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXDockTitle_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDockTitle, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDockTitle_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDockTitle, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDockTitle_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXDockTitle, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXDockTitle_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXDockTitle_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXDockTitle *arg1 = (FXDockTitle *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXDockTitle, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXDockTitle *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXDockTitle * >(argp1);
+  FXDockTitle_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXToolBarGrip;
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_onEnter(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","onEnter", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onEnter", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onEnter(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_onLeave(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","onLeave", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onLeave", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onLeave(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXToolBarGrip_allocate(VALUE self)
+#else
+_wrap_FXToolBarGrip_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXToolBarGrip);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXToolBarGrip(int argc, VALUE *argv, VALUE self) {
+  FXToolBar *arg1 = (FXToolBar *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) TOOLBARGRIP_SINGLE ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXToolBarGrip *result = 0 ;
+  
+  if ((argc < 1) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXToolBar, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBar *","FXToolBarGrip", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXToolBar * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXToolBarGrip", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    result = (FXToolBarGrip *)new_FXToolBarGrip(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_setDoubleBar(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","setDoubleBar", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  (arg1)->setDoubleBar(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_isDoubleBar(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip const *","isDoubleBar", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  result = (FXbool)((FXToolBarGrip const *)arg1)->isDoubleBar();
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_setActiveColor(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","setActiveColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setActiveColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_getActiveColor(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip const *","getActiveColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  result = (FXColor)((FXToolBarGrip const *)arg1)->getActiveColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_save(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXToolBarGrip_save((FXToolBarGrip const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_load(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXToolBarGrip_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_create(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  FXToolBarGrip_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_detach(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  FXToolBarGrip_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_destroy(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  FXToolBarGrip_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_resize(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXToolBarGrip_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  result = (FXint)FXToolBarGrip_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  result = (FXint)FXToolBarGrip_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXToolBarGrip_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXToolBarGrip_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  result = (bool)FXToolBarGrip_canFocus((FXToolBarGrip const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  FXToolBarGrip_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  FXToolBarGrip_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXToolBarGrip_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXToolBarGrip_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_enable(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  FXToolBarGrip_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_disable(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  FXToolBarGrip_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  FXToolBarGrip_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_lower(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  FXToolBarGrip_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_move(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXToolBarGrip_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_position(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXToolBarGrip_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_layout(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  FXToolBarGrip_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_recalc(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  FXToolBarGrip_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_reparent(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXToolBarGrip_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_show(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  FXToolBarGrip_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_hide(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  FXToolBarGrip_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  result = (bool)FXToolBarGrip_isComposite((FXToolBarGrip const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_contains(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXToolBarGrip_contains((FXToolBarGrip const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  result = (bool)FXToolBarGrip_doesSaveUnder((FXToolBarGrip const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXToolBarGrip_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_tr(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXToolBarGrip_tr((FXToolBarGrip const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  FXToolBarGrip_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  FXToolBarGrip_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXToolBarGrip_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXToolBarGrip_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXToolBarGrip_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXToolBarGrip_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToolBarGrip, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXToolBarGrip_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToolBarGrip, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXToolBarGrip_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToolBarGrip, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXToolBarGrip_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarGrip_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXToolBarGrip *arg1 = (FXToolBarGrip *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarGrip, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarGrip *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarGrip * >(argp1);
+  FXToolBarGrip_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXToolBarShell;
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXToolBarShell_allocate(VALUE self)
+#else
+_wrap_FXToolBarShell_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXToolBarShell);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXToolBarShell(int argc, VALUE *argv, VALUE self) {
+  FXWindow *arg1 = (FXWindow *) 0 ;
+  FXuint arg2 = (FXuint) FRAME_RAISED|FRAME_THICK ;
+  FXint arg3 = (FXint) 0 ;
+  FXint arg4 = (FXint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 4 ;
+  FXint arg8 = (FXint) 4 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXToolBarShell *result = 0 ;
+  
+  if ((argc < 1) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXWindow *","FXToolBarShell", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXWindow * >(argp1);
+  if (argc > 1) {
+    arg2 = NUM2UINT(argv[1]);
+  }
+  if (argc > 2) {
+    arg3 = NUM2INT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2INT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXToolBarShell *)new_FXToolBarShell(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_setFrameStyle(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","setFrameStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setFrameStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_getFrameStyle(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell const *","getFrameStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  result = (FXuint)((FXToolBarShell const *)arg1)->getFrameStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_getBorderWidth(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell const *","getBorderWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  result = (FXint)((FXToolBarShell const *)arg1)->getBorderWidth();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_setHiliteColor(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","setHiliteColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setHiliteColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_getHiliteColor(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell const *","getHiliteColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  result = (FXColor)((FXToolBarShell const *)arg1)->getHiliteColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_setShadowColor(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","setShadowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setShadowColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_getShadowColor(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell const *","getShadowColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  result = (FXColor)((FXToolBarShell const *)arg1)->getShadowColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_setBorderColor(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","setBorderColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setBorderColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_getBorderColor(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell const *","getBorderColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  result = (FXColor)((FXToolBarShell const *)arg1)->getBorderColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_setBaseColor(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","setBaseColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setBaseColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_getBaseColor(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell const *","getBaseColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  result = (FXColor)((FXToolBarShell const *)arg1)->getBaseColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_save(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXToolBarShell_save((FXToolBarShell const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_load(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXToolBarShell_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_create(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  FXToolBarShell_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_detach(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  FXToolBarShell_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_destroy(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  FXToolBarShell_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_resize(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXToolBarShell_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  result = (FXint)FXToolBarShell_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  result = (FXint)FXToolBarShell_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXToolBarShell_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXToolBarShell_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  result = (bool)FXToolBarShell_canFocus((FXToolBarShell const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  FXToolBarShell_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  FXToolBarShell_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXToolBarShell_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXToolBarShell_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_enable(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  FXToolBarShell_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_disable(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  FXToolBarShell_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  FXToolBarShell_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_lower(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  FXToolBarShell_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_move(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXToolBarShell_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_position(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXToolBarShell_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_layout(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  FXToolBarShell_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_recalc(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  FXToolBarShell_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_reparent(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXToolBarShell_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_show__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  FXToolBarShell_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_hide(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  FXToolBarShell_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  result = (bool)FXToolBarShell_isComposite((FXToolBarShell const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_contains(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXToolBarShell_contains((FXToolBarShell const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  result = (bool)FXToolBarShell_doesSaveUnder((FXToolBarShell const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXToolBarShell_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_tr(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXToolBarShell_tr((FXToolBarShell const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  FXToolBarShell_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  FXToolBarShell_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXToolBarShell_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXToolBarShell_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXToolBarShell_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXToolBarShell_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToolBarShell, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXToolBarShell_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToolBarShell, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXToolBarShell_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToolBarShell, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXToolBarShell_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  FXToolBarShell_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_show__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  FXToolBarShell_show(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXToolBarShell_show(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToolBarShell, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXToolBarShell_show__SWIG_0(nargs, args, self);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXToolBarShell, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        return _wrap_FXToolBarShell_show__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "show", 
+    "    void show()\n"
+    "    void show(FXuint placement)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_maximize(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","maximize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXToolBarShell_maximize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_minimize(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","minimize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXToolBarShell_minimize(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_restore(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","restore", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXToolBarShell_restore(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXToolBarShell_close(int argc, VALUE *argv, VALUE self) {
+  FXToolBarShell *arg1 = (FXToolBarShell *) 0 ;
+  FXbool arg2 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXbool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXToolBarShell, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXToolBarShell *","close", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXToolBarShell * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  result = (FXbool)FXToolBarShell_close(arg1,arg2);
+  vresult = result ? Qtrue : Qfalse;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+static swig_class SwigClassFXRulerView;
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_onPaint(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","onPaint", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onPaint", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onPaint(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_onMotion(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","onMotion", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onMotion", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  arg4 = to_FXEvent(argv[2]);
+  result = (long)(arg1)->onMotion(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_onCmdSetHelp(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","onCmdSetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdSetHelp", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdSetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_onCmdGetHelp(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","onCmdGetHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetHelp", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_onCmdSetTip(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","onCmdSetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdSetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdSetTip", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdSetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_onCmdGetTip(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","onCmdGetTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onCmdGetTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onCmdGetTip", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onCmdGetTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_onQueryHelp(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","onQueryHelp", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryHelp", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onQueryHelp", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onQueryHelp(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_onQueryTip(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","onQueryTip", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onQueryTip", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onQueryTip", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onQueryTip(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_onDocChanged(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 ;
+  void *arg4 = (void *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  int res4 ;
+  long result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","onDocChanged", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","onDocChanged", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXObject * >(argp2);
+  arg3 = NUM2UINT(argv[1]);
+  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
+  if (!SWIG_IsOK(res4)) {
+    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","onDocChanged", 4, argv[2] )); 
+  }
+  result = (long)(arg1)->onDocChanged(arg2,arg3,arg4);
+  vresult = SWIG_From_long(static_cast< long >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
+_wrap_FXRulerView_allocate(VALUE self)
+#else
+_wrap_FXRulerView_allocate(int argc, VALUE *argv, VALUE self)
+#endif
+{
+  VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FXRulerView);
+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
+  rb_obj_call_init(vresult, argc, argv);
+#endif
+  return vresult;
+}
+
+
+SWIGINTERN VALUE
+_wrap_new_FXRulerView(int argc, VALUE *argv, VALUE self) {
+  FXComposite *arg1 = (FXComposite *) 0 ;
+  FXObject *arg2 = (FXObject *) 0 ;
+  FXSelector arg3 = (FXSelector) 0 ;
+  FXuint arg4 = (FXuint) 0 ;
+  FXint arg5 = (FXint) 0 ;
+  FXint arg6 = (FXint) 0 ;
+  FXint arg7 = (FXint) 0 ;
+  FXint arg8 = (FXint) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  FXRulerView *result = 0 ;
+  
+  if ((argc < 1) || (argc > 8)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FXComposite, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXComposite *","FXRulerView", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< FXComposite * >(argp1);
+  if (argc > 1) {
+    res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FXObject, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXObject *","FXRulerView", 2, argv[1] )); 
+    }
+    arg2 = reinterpret_cast< FXObject * >(argp2);
+  }
+  if (argc > 2) {
+    arg3 = NUM2UINT(argv[2]);
+  }
+  if (argc > 3) {
+    arg4 = NUM2UINT(argv[3]);
+  }
+  if (argc > 4) {
+    arg5 = NUM2INT(argv[4]);
+  }
+  if (argc > 5) {
+    arg6 = NUM2INT(argv[5]);
+  }
+  if (argc > 6) {
+    arg7 = NUM2INT(argv[6]);
+  }
+  if (argc > 7) {
+    arg8 = NUM2INT(argv[7]);
+  }
+  {
+    if (!arg1) {
+      SWIG_exception(SWIG_ValueError,"Received a NULL pointer.");
+    }
+  }
+  {
+    result = (FXRulerView *)new_FXRulerView(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
+    DATA_PTR(self) = result; FXRbRegisterRubyObj(self, result);
+    if(rb_block_given_p()){
+      rb_yield(self);
+    }
+  }
+  return self;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_horizontalRuler(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXRuler *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","horizontalRuler", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXRuler *)((FXRulerView const *)arg1)->horizontalRuler();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXRuler, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_verticalRuler(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXRuler *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","verticalRuler", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXRuler *)((FXRulerView const *)arg1)->verticalRuler();
+  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FXRuler, 0 |  0 );
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getDocumentX(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getDocumentX", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)((FXRulerView const *)arg1)->getDocumentX();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getDocumentY(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getDocumentY", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)((FXRulerView const *)arg1)->getDocumentY();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setDocumentWidth(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setDocumentWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setDocumentWidth(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getDocumentWidth(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getDocumentWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)((FXRulerView const *)arg1)->getDocumentWidth();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setDocumentHeight(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setDocumentHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setDocumentHeight(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getDocumentHeight(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getDocumentHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)((FXRulerView const *)arg1)->getDocumentHeight();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setDocumentColor(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setDocumentColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  (arg1)->setDocumentColor(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getDocumentColor(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXColor result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getDocumentColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXColor)((FXRulerView const *)arg1)->getDocumentColor();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setHEdgeSpacing(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setHEdgeSpacing", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setHEdgeSpacing(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setVEdgeSpacing(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setVEdgeSpacing", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setVEdgeSpacing(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getHEdgeSpacing(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getHEdgeSpacing", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)((FXRulerView const *)arg1)->getHEdgeSpacing();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getVEdgeSpacing(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getVEdgeSpacing", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)((FXRulerView const *)arg1)->getVEdgeSpacing();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setHMarginLower(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setHMarginLower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setHMarginLower(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setHMarginUpper(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setHMarginUpper", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setHMarginUpper(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getHMarginLower(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getHMarginLower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)((FXRulerView const *)arg1)->getHMarginLower();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getHMarginUpper(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getHMarginUpper", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)((FXRulerView const *)arg1)->getHMarginUpper();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setVMarginLower(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setVMarginLower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setVMarginLower(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setVMarginUpper(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setVMarginUpper", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setVMarginUpper(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getVMarginLower(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getVMarginLower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)((FXRulerView const *)arg1)->getVMarginLower();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getVMarginUpper(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getVMarginUpper", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)((FXRulerView const *)arg1)->getVMarginUpper();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setHAlignment(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXuint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setHAlignment", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setHAlignment(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getHAlignment(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getHAlignment", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXuint)((FXRulerView const *)arg1)->getHAlignment();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setVAlignment(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXuint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setVAlignment", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setVAlignment(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getVAlignment(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getVAlignment", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXuint)((FXRulerView const *)arg1)->getVAlignment();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setArrowPosX(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setArrowPosX", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setArrowPosX(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setArrowPosY(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setArrowPosY", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  (arg1)->setArrowPosY(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getArrowPosX(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getArrowPosX", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)((FXRulerView const *)arg1)->getArrowPosX();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getArrowPosY(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getArrowPosY", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)((FXRulerView const *)arg1)->getArrowPosY();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setHRulerFont(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setHRulerFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setHRulerFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setHRulerFont(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getHRulerFont(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getHRulerFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXFont *)((FXRulerView const *)arg1)->getHRulerFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setVRulerFont(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXFont *arg2 = (FXFont *) 0 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setVRulerFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXFont, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXFont *","setVRulerFont", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXFont * >(argp2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setVRulerFont(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getVRulerFont(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXFont *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getVRulerFont", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXFont *)((FXRulerView const *)arg1)->getVRulerFont();
+  {
+    swig_type_info *ty = SWIG_TypeDynamicCast(SWIGTYPE_p_FXFont, (void **) &result);
+    vresult = FXRbGetRubyObj(result, ty);
+  }
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setHNumberTicks(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setHNumberTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setHNumberTicks(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setVNumberTicks(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setVNumberTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setVNumberTicks(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getHNumberTicks(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getHNumberTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)((FXRulerView const *)arg1)->getHNumberTicks();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getVNumberTicks(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getVNumberTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)((FXRulerView const *)arg1)->getVNumberTicks();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setHMajorTicks(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setHMajorTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setHMajorTicks(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setVMajorTicks(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setVMajorTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setVMajorTicks(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getHMajorTicks(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getHMajorTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)((FXRulerView const *)arg1)->getHMajorTicks();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getVMajorTicks(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getVMajorTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)((FXRulerView const *)arg1)->getVMajorTicks();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setHMediumTicks(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setHMediumTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setHMediumTicks(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setVMediumTicks(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setVMediumTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setVMediumTicks(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getHMediumTicks(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getHMediumTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)((FXRulerView const *)arg1)->getHMediumTicks();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getVMediumTicks(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getVMediumTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)((FXRulerView const *)arg1)->getVMediumTicks();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setHTinyTicks(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setHTinyTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setHTinyTicks(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setVTinyTicks(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setVTinyTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setVTinyTicks(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getHTinyTicks(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getHTinyTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)((FXRulerView const *)arg1)->getHTinyTicks();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getVTinyTicks(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getVTinyTicks", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)((FXRulerView const *)arg1)->getVTinyTicks();
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setHPixelsPerTick(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXdouble arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setHPixelPerTick", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","setHPixelPerTick", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setHPixelPerTick(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setVPixelsPerTick(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXdouble arg2 ;
+  FXbool arg3 = (FXbool) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  double val2 ;
+  int ecode2 = 0 ;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setVPixelPerTick", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  ecode2 = SWIG_AsVal_double(argv[0], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "FXdouble","setVPixelPerTick", 2, argv[0] ));
+  } 
+  arg2 = static_cast< FXdouble >(val2);
+  if (argc > 1) {
+    arg3 = to_FXbool(argv[1]);
+  }
+  (arg1)->setVPixelPerTick(arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getHPixelsPerTick(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getHPixelPerTick", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXdouble)((FXRulerView const *)arg1)->getHPixelPerTick();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getVPixelsPerTick(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXdouble result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getVPixelPerTick", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXdouble)((FXRulerView const *)arg1)->getVPixelPerTick();
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setHRulerStyle(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setHRulerStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setHRulerStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setVRulerStyle(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXuint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setVRulerStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2UINT(argv[0]);
+  (arg1)->setVRulerStyle(arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getHRulerStyle(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getHRulerStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXuint)((FXRulerView const *)arg1)->getHRulerStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getVRulerStyle(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXuint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getVRulerStyle", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXuint)((FXRulerView const *)arg1)->getVRulerStyle();
+  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setHelpText(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setHelpText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getHelpText(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getHelpText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXString *) &((FXRulerView const *)arg1)->getHelpText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setTipText(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXString *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  SwigValueWrapper< FXString > p2 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  p2 = to_FXString(argv[0]); arg2 = &p2;
+  (arg1)->setTipText((FXString const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getTipText(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXString *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","getTipText", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXString *) &((FXRulerView const *)arg1)->getTipText();
+  vresult = to_ruby(result->text());
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_save(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","save", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","save", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","save", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXRulerView_save((FXRulerView const *)arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_load(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXStream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","load", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXStream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXStream &","load", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXStream &","load", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXStream * >(argp2);
+  FXRulerView_load(arg1,*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_create(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","create", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  FXRulerView_create(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_detach(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","detach", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  FXRulerView_detach(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_destroy(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","destroy", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  FXRulerView_destroy(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_resize(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","resize", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXRulerView_resize(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","getDefaultWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)FXRulerView_getDefaultWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","getDefaultHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)FXRulerView_getDefaultHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getWidthForHeight(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","getWidthForHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXRulerView_getWidthForHeight(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getHeightForWidth(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","getHeightForWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  result = (FXint)FXRulerView_getHeightForWidth(arg1,arg2);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_canFocus(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","canFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (bool)FXRulerView_canFocus((FXRulerView const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setFocus(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  FXRulerView_setFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_killFocus(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","killFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  FXRulerView_killFocus(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_changeFocus(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","changeFocus", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","changeFocus", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  FXRulerView_changeFocus(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setDefault(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXbool arg2 = (FXbool) 1 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setDefault", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  if (argc > 0) {
+    arg2 = to_FXbool(argv[0]);
+  }
+  FXRulerView_setDefault(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_enable(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","enable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  FXRulerView_enable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_disable(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","disable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  FXRulerView_disable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_raiseWindow(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","raise", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  FXRulerView_raise(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_lower(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","lower", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  FXRulerView_lower(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_move(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","move", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  FXRulerView_move(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  FXint arg4 ;
+  FXint arg5 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 4) || (argc > 4)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  arg4 = NUM2INT(argv[2]);
+  arg5 = NUM2INT(argv[3]);
+  FXRulerView_position(arg1,arg2,arg3,arg4,arg5);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_layout(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","layout", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  FXRulerView_layout(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_recalc(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","recalc", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  FXRulerView_recalc(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_reparent(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXWindow *arg2 = (FXWindow *) 0 ;
+  FXWindow *arg3 = (FXWindow *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  void *argp3 = 0 ;
+  int res3 = 0 ;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","reparent", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXWindow *","reparent", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXWindow * >(argp2);
+  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_FXWindow, 0 |  0 );
+  if (!SWIG_IsOK(res3)) {
+    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "FXWindow *","reparent", 3, argv[1] )); 
+  }
+  arg3 = reinterpret_cast< FXWindow * >(argp3);
+  FXRulerView_reparent(arg1,arg2,arg3);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_show(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","show", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  FXRulerView_show(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_hide(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","hide", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  FXRulerView_hide(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_isComposite(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","isComposite", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (bool)FXRulerView_isComposite((FXRulerView const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_contains(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXint arg2 ;
+  FXint arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","contains", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NUM2INT(argv[0]);
+  arg3 = NUM2INT(argv[1]);
+  result = (bool)FXRulerView_contains((FXRulerView const *)arg1,arg2,arg3);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_doesSaveUnder(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  bool result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","doesSaveUnder", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (bool)FXRulerView_doesSaveUnder((FXRulerView const *)arg1);
+  vresult = SWIG_From_bool(static_cast< bool >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setBackColor(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXColor arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setBackColor", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = to_FXColor(argv[0]);
+  FXRulerView_setBackColor(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_tr(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXchar *arg2 = (FXchar *) 0 ;
+  FXchar *arg3 = (FXchar *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXchar *result = 0 ;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","tr", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  arg2 = NIL_P(argv[0]) ? 0 : StringValuePtr(argv[0]);
+  if (argc > 1) {
+    arg3 = NIL_P(argv[1]) ? 0 : StringValuePtr(argv[1]);
+  }
+  result = (FXchar *)FXRulerView_tr((FXRulerView const *)arg1,(char const *)arg2,(char const *)arg3);
+  vresult = SWIG_FromCharPtr((const char *)result);
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_dropEnable(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","dropEnable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  FXRulerView_dropEnable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_dropDisable(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","dropDisable", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  FXRulerView_dropDisable(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setShape__SWIG_0(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXRegion *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_FXRegion,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXRegion const &","setShape", 2, argv[0] )); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "FXRegion const &","setShape", 2, argv[0])); 
+  }
+  arg2 = reinterpret_cast< FXRegion * >(argp2);
+  FXRulerView_setShape(arg1,(FXRegion const &)*arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setShape__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXBitmap *arg2 = (FXBitmap *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXBitmap, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXBitmap *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXBitmap * >(argp2);
+  FXRulerView_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_setShape__SWIG_2(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  FXIcon *arg2 = (FXIcon *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","setShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FXIcon, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FXIcon *","setShape", 2, argv[0] )); 
+  }
+  arg2 = reinterpret_cast< FXIcon * >(argp2);
+  FXRulerView_setShape(arg1,arg2);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXRulerView_setShape(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[3];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 3) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRulerView, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXRegion, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRulerView_setShape__SWIG_0(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRulerView, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXBitmap, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRulerView_setShape__SWIG_1(nargs, args, self);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRulerView, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FXIcon, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FXRulerView_setShape__SWIG_2(nargs, args, self);
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 3, "setShape", 
+    "    void setShape(FXRegion const &region)\n"
+    "    void setShape(FXBitmap *bitmap)\n"
+    "    void setShape(FXIcon *icon)\n");
+  
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_clearShape(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","clearShape", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  FXRulerView_clearShape(arg1);
+  return Qnil;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getViewportHeight(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","getViewportHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)FXRulerView_getViewportHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getViewportWidth(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","getViewportWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)FXRulerView_getViewportWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getContentHeight(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","getContentHeight", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)FXRulerView_getContentHeight(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_getContentWidth(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  FXint result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView *","getContentWidth", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (FXint)FXRulerView_getContentWidth(arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_FXRulerView_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
+  FXRulerView *arg1 = (FXRulerView *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  VALUE result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FXRulerView, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FXRulerView const *","position", 1, self )); 
+  }
+  arg1 = reinterpret_cast< FXRulerView * >(argp1);
+  result = (VALUE)FXRulerView_position__SWIG_1((FXRulerView const *)arg1);
+  vresult = result;
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE _wrap_FXRulerView_position(int nargs, VALUE *args, VALUE self) {
+  int argc;
+  VALUE argv[6];
+  int ii;
+  
+  argc = nargs + 1;
+  argv[0] = self;
+  if (argc > 6) SWIG_fail;
+  for (ii = 1; (ii < argc); ++ii) {
+    argv[ii] = args[ii-1];
+  }
+  if (argc == 1) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRulerView, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_FXRulerView_position__SWIG_1(nargs, args, self);
+    }
+  }
+  if (argc == 5) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FXRulerView, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      {
+        _v = (TYPE(argv[1]) == T_FIXNUM || TYPE(argv[1]) == T_BIGNUM) ? 1 : 0;
+      }
+      if (_v) {
+        {
+          _v = (TYPE(argv[2]) == T_FIXNUM || TYPE(argv[2]) == T_BIGNUM) ? 1 : 0;
+        }
+        if (_v) {
+          {
+            _v = (TYPE(argv[3]) == T_FIXNUM || TYPE(argv[3]) == T_BIGNUM) ? 1 : 0;
+          }
+          if (_v) {
+            {
+              _v = (TYPE(argv[4]) == T_FIXNUM || TYPE(argv[4]) == T_BIGNUM) ? 1 : 0;
+            }
+            if (_v) {
+              return _wrap_FXRulerView_position__SWIG_0(nargs, args, self);
+            }
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  Ruby_Format_OverloadedError( argc, 6, "position", 
+    "    void position(FXint x, FXint y, FXint w, FXint h)\n"
+    "    VALUE position()\n");
+  
+  return Qnil;
+}
+
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
+
+static void *_p_FXDriveBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXToolBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolTipTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXTabBookTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXShell *) x));
+}
+static void *_p_FXStatusBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXScrollArea *) x));
+}
+static void *_p_FXPopupTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXComboBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FX4SplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXSplitter *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXPackerTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *)  ((FXPacker *) x));
+}
+static void *_p_FXDirBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXSwitcherTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXShutterTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXDockSiteTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXRulerViewTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXMatrixTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXShutterItemTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXDockBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXImageViewTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXSpringTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXComposite(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXComposite *) (FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXPopupTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *)  ((FXPopup *) x));
+}
+static void *_p_FXTopWindowTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *)  ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXToolTipTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *)  ((FXToolTip *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXShell(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXShell *) (FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXScrollWindow *) x));
+}
+static void *_p_FXImageViewTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXImageView *) x));
+}
+static void *_p_FXRulerViewTo_p_FXScrollArea(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXScrollArea *)  ((FXRulerView *) x));
+}
+static void *_p_FXMainWindowTo_p_FXTopWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTopWindow *)  ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXTopWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTopWindow *)  ((FXSplashWindow *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXTopWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTopWindow *)  ((FXToolBarShell *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXToolBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXCompositeTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXComposite *) x));
+}
+static void *_p_FXToolTipTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXTextFieldTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXTabBookTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXStatusBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXPopupTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXRulerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXCanvasTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXCanvas *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXScrollCorner *) x));
+}
+static void *_p_FXSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXStatusLineTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXComboBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXKnobTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FX4SplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FXPackerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXSpinnerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXScrollBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXScrollBar *) x));
+}
+static void *_p_FXColorWheelTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXGradientBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXDirBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXImageFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXDragCornerTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXDragCorner *) x));
+}
+static void *_p_FXSwitcherTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXShutterTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXProgressBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXDockSiteTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXDockTitleTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXRulerViewTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXListBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXHeaderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXMatrixTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXColorWellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXShutterItemTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXDialTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDockBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXFrameTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *)  ((FXFrame *) x));
+}
+static void *_p_FXTabBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FX7SegmentTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXImageViewTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXSliderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXRealSliderTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSpringTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXColorRingTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXColorBarTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXWindow(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXWindow *) (FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDocumentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDocument *) x));
+}
+static void *_p_FXGradientBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXRegistryTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *)(FXSettings *) ((FXRegistry *) x));
+}
+static void *_p_FXHeaderItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXHeaderItem *) x));
+}
+static void *_p_FXShutterItemTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXIconDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXIconDict *) x));
+}
+static void *_p_FXMatrixTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXFileDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXFileDict *) x));
+}
+static void *_p_FXRecentFilesTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXRecentFiles *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXDrawableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXDrawable *) x));
+}
+static void *_p_FXAppTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXApp *) x));
+}
+static void *_p_FXHeaderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXTranslatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXTranslator *) x));
+}
+static void *_p_FX4SplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FXSpringTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXIdTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXId *) x));
+}
+static void *_p_FXProgressBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXToolTipTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXSettingsTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXSettings *) x));
+}
+static void *_p_FXDockSiteTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDebugTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDebugTarget *) x));
+}
+static void *_p_FXDataTargetTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDataTarget *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXCanvasTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXListBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXColorWheelTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXVisualTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXVisual *) x));
+}
+static void *_p_FXScrollBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXFontTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXFont *) x));
+}
+static void *_p_FXComboBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStringDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXDict *) ((FXStringDict *) x));
+}
+static void *_p_FXStatusBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXDelegatorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDelegator *) x));
+}
+static void *_p_FXAccelTableTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXAccelTable *) x));
+}
+static void *_p_FXCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *) ((FXCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXKnobTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRulerViewTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXStatusLineTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXDockBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXDictTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *)  ((FXDict *) x));
+}
+static void *_p_FXShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXToolBarTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDirBoxTo_p_FXObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXObject *) (FXId *)(FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXToolBarTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *) (FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXDockSiteTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXDockSite *) x));
+}
+static void *_p_FXListBoxTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXListBox *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXTreeListBox *) x));
+}
+static void *_p_FXComboBoxTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXComboBox *) x));
+}
+static void *_p_FXShutterItemTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *) (FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXDockBarTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXDockBar *) x));
+}
+static void *_p_FXStatusBarTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *) (FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXDirBoxTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *) (FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXTabBarTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXTabBar *) x));
+}
+static void *_p_FXTabBookTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *) (FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXGroupBox *) x));
+}
+static void *_p_FXShutterTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *) (FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXVerticalFrame *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXHorizontalFrame *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXSpinner *) x));
+}
+static void *_p_FXMatrixTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXMatrix *) x));
+}
+static void *_p_FXSpringTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXSpring *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXFontSelector *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *) (FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXSwitcherTo_p_FXPacker(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXPacker *)  ((FXSwitcher *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXDockHandler(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDockHandler *)  ((FXToolBarGrip *) x));
+}
+static void *_p_FXDockTitleTo_p_FXDockHandler(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDockHandler *)  ((FXDockTitle *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXToolBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXCompositeTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXToolTipTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXTextFieldTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXTabBookTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXStatusBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXPopupTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *)  ((FXWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXMainWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXRulerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXCanvasTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXStatusLineTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXComboBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXKnobTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FX4SplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSplitterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FXPackerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXSpinnerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXScrollBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXColorWheelTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXGradientBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXDirBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXImageFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXDragCornerTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXSwitcherTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXShutterTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXProgressBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXDockSiteTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXDockTitleTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXRulerViewTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXListBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXHeaderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXMatrixTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXColorWellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXShutterItemTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXDialTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDockBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXFrameTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FXTabBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FX7SegmentTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXImageViewTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXRealSliderTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSpringTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXColorRingTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXColorBarTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXDrawable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDrawable *) (FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXFileStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXFileStream *) x));
+}
+static void *_p_FXMemoryStreamTo_p_FXStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXStream *)  ((FXMemoryStream *) x));
+}
+static void *_p_FXDirBoxTo_p_FXTreeListBox(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTreeListBox *)  ((FXDirBox *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXListBox(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXListBox *)  ((FXDriveBox *) x));
+}
+static void *_p_FXToolBarTo_p_FXDockBar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXDockBar *)  ((FXToolBar *) x));
+}
+static void *_p_FXGradientBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXGradientBar *) x));
+}
+static void *_p_FXShutterItemTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutterItem *) x));
+}
+static void *_p_FXColorBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorBar *) x));
+}
+static void *_p_FXTabBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTabBar *) x));
+}
+static void *_p_FXSwitcherTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSwitcher *) x));
+}
+static void *_p_FXTextFieldTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXTextField *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXToolBarTab *) x));
+}
+static void *_p_FXDriveBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXListBox *) ((FXDriveBox *) x));
+}
+static void *_p_FXMatrixTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXMatrix *) x));
+}
+static void *_p_FXScrollCornerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXScrollCorner *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXArrowButton *) x));
+}
+static void *_p_FXPopupTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXPopup *) x));
+}
+static void *_p_FXDrawableTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXDrawable *) x));
+}
+static void *_p_FXHeaderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXHeader *) x));
+}
+static void *_p_FXSplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXSplitter *) x));
+}
+static void *_p_FX4SplitterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FX4Splitter *) x));
+}
+static void *_p_FXSpringTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpring *) x));
+}
+static void *_p_FXPackerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXPacker *) x));
+}
+static void *_p_FXTabBookTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTabBar *) ((FXTabBook *) x));
+}
+static void *_p_FXImageFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXImageFrame *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSeparator *) x));
+}
+static void *_p_FXProgressBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXProgressBar *) x));
+}
+static void *_p_FXShutterTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXVerticalFrame *) ((FXShutter *) x));
+}
+static void *_p_FXToolTipTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXToolTip *) x));
+}
+static void *_p_FXCompositeTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXComposite *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXBitmapFrame *) x));
+}
+static void *_p_FXRealSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRealSlider *) x));
+}
+static void *_p_FXSliderTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXSlider *) x));
+}
+static void *_p_FXDockSiteTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockSite *) x));
+}
+static void *_p_FXGroupBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXGroupBox *) x));
+}
+static void *_p_FXColorRingTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorRing *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDockHandler *) x));
+}
+static void *_p_FXTreeListBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXTreeListBox *) x));
+}
+static void *_p_FXListBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXListBox *) x));
+}
+static void *_p_FXCanvasTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXCanvas *) x));
+}
+static void *_p_FXColorWheelTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWheel *) x));
+}
+static void *_p_FXVisualTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXVisual *) x));
+}
+static void *_p_FXScrollBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXScrollBar *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FXFontTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXFont *) x));
+}
+static void *_p_FXComboBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXComboBox *) x));
+}
+static void *_p_FXFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXFrame *) x));
+}
+static void *_p_FX7SegmentTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FX7Segment *) x));
+}
+static void *_p_FXDockTitleTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *)(FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXStatusBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXHorizontalFrame *) ((FXStatusBar *) x));
+}
+static void *_p_FXGIFCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXGIFCursor *) x));
+}
+static void *_p_FXCURCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXCursor *) ((FXCURCursor *) x));
+}
+static void *_p_FXCursorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *)  ((FXCursor *) x));
+}
+static void *_p_FXKnobTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXKnob *) x));
+}
+static void *_p_FXRealSpinnerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXRealSpinner *) x));
+}
+static void *_p_FXSpinnerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXSpinner *) x));
+}
+static void *_p_FXRulerViewTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXRulerView *) x));
+}
+static void *_p_FXStatusLineTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXStatusLine *) x));
+}
+static void *_p_FXMainWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXMainWindow *) x));
+}
+static void *_p_FXTopWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *) ((FXTopWindow *) x));
+}
+static void *_p_FXRootWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXRootWindow *) x));
+}
+static void *_p_FXWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *) ((FXWindow *) x));
+}
+static void *_p_FXSplashWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXSplashWindow *) x));
+}
+static void *_p_FXScrollWindowTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXScrollWindow *) x));
+}
+static void *_p_FXDockBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDockBar *) x));
+}
+static void *_p_FXShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXShell *) x));
+}
+static void *_p_FXScrollAreaTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *) ((FXScrollArea *) x));
+}
+static void *_p_FXColorWellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXColorWell *) x));
+}
+static void *_p_FXDragCornerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *) ((FXDragCorner *) x));
+}
+static void *_p_FXRulerTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXRuler *) x));
+}
+static void *_p_FXDialTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXFrame *) ((FXDial *) x));
+}
+static void *_p_FXHorizontalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXHorizontalFrame *) x));
+}
+static void *_p_FXVerticalFrameTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXVerticalFrame *) x));
+}
+static void *_p_FXImageViewTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXScrollArea *) ((FXImageView *) x));
+}
+static void *_p_FXFontSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFontSelector *) x));
+}
+static void *_p_FXColorSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXColorSelector *) x));
+}
+static void *_p_FXFileSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXFileSelector *) x));
+}
+static void *_p_FXDirSelectorTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *) ((FXDirSelector *) x));
+}
+static void *_p_FXToolBarTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXDockBar *) ((FXToolBar *) x));
+}
+static void *_p_FXToolBarShellTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXShell *)(FXTopWindow *) ((FXToolBarShell *) x));
+}
+static void *_p_FXDirBoxTo_p_FXId(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXId *) (FXDrawable *)(FXWindow *)(FXComposite *)(FXPacker *)(FXTreeListBox *) ((FXDirBox *) x));
+}
+static void *_p_FXTabBookTo_p_FXTabBar(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXTabBar *)  ((FXTabBook *) x));
+}
+static void *_p_FXToolBarTabTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXToolBarTab *) x));
+}
+static void *_p_FXColorRingTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXColorRing *) x));
+}
+static void *_p_FXColorBarTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXColorBar *) x));
+}
+static void *_p_FXBitmapFrameTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXBitmapFrame *) x));
+}
+static void *_p_FXDialTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXDial *) x));
+}
+static void *_p_FXRulerTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXRuler *) x));
+}
+static void *_p_FXArrowButtonTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXArrowButton *) x));
+}
+static void *_p_FXColorWheelTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXColorWheel *) x));
+}
+static void *_p_FXProgressBarTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXProgressBar *) x));
+}
+static void *_p_FXColorWellTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXColorWell *) x));
+}
+static void *_p_FXGradientBarTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXGradientBar *) x));
+}
+static void *_p_FXStatusLineTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXStatusLine *) x));
+}
+static void *_p_FXHorizontalSeparatorTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXSeparator *) ((FXHorizontalSeparator *) x));
+}
+static void *_p_FXSeparatorTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXSeparator *) x));
+}
+static void *_p_FXVerticalSeparatorTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXSeparator *) ((FXVerticalSeparator *) x));
+}
+static void *_p_FXDockTitleTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXDockHandler *) ((FXDockTitle *) x));
+}
+static void *_p_FXTextFieldTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXTextField *) x));
+}
+static void *_p_FXDockHandlerTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXDockHandler *) x));
+}
+static void *_p_FXHeaderTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXHeader *) x));
+}
+static void *_p_FXImageFrameTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXImageFrame *) x));
+}
+static void *_p_FXKnobTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXKnob *) x));
+}
+static void *_p_FXSliderTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXSlider *) x));
+}
+static void *_p_FXRealSliderTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FXRealSlider *) x));
+}
+static void *_p_FXToolBarGripTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *) (FXDockHandler *) ((FXToolBarGrip *) x));
+}
+static void *_p_FX7SegmentTo_p_FXFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((FXFrame *)  ((FX7Segment *) x));
+}
+static swig_type_info _swigt__p_FX7Segment = {"_p_FX7Segment", "FX7Segment *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXApp = {"_p_FXApp", "FXApp *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXBitmap = {"_p_FXBitmap", "FXBitmap *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXButton = {"_p_FXButton", "FXButton *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXCanvas = {"_p_FXCanvas", "FXCanvas *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXColorSelector = {"_p_FXColorSelector", "FXColorSelector *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXComboBox = {"_p_FXComboBox", "FXComboBox *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXComposite = {"_p_FXComposite", "FXComposite *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXGroupBox = {"_p_FXGroupBox", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusBar = {"_p_FXStatusBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPopup = {"_p_FXPopup", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRootWindow = {"_p_FXRootWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXScrollWindow = {"_p_FXScrollWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMainWindow = {"_p_FXMainWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplashWindow = {"_p_FXSplashWindow", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalFrame = {"_p_FXHorizontalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalFrame = {"_p_FXVerticalFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FX4Splitter = {"_p_FX4Splitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSplitter = {"_p_FXSplitter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSwitcher = {"_p_FXSwitcher", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutter = {"_p_FXShutter", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXShutterItem = {"_p_FXShutterItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMatrix = {"_p_FXMatrix", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSpring = {"_p_FXSpring", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDirBox = {"_p_FXDirBox", "FXDirBox *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDirSelector = {"_p_FXDirSelector", "FXDirSelector *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDockBar = {"_p_FXDockBar", "FXDockBar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDockHandler = {"_p_FXDockHandler", "FXDockHandler *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDockSite = {"_p_FXDockSite", "FXDockSite *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDockTitle = {"_p_FXDockTitle", "FXDockTitle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDragCorner = {"_p_FXDragCorner", "FXDragCorner *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDrawable = {"_p_FXDrawable", "FXDrawable *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDial = {"_p_FXDial", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTextField = {"_p_FXTextField", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXArrowButton = {"_p_FXArrowButton", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXVerticalSeparator = {"_p_FXVerticalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHorizontalSeparator = {"_p_FXHorizontalSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSeparator = {"_p_FXSeparator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStatusLine = {"_p_FXStatusLine", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWheel = {"_p_FXColorWheel", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXBitmapFrame = {"_p_FXBitmapFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGradientBar = {"_p_FXGradientBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImageFrame = {"_p_FXImageFrame", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXKnob = {"_p_FXKnob", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXProgressBar = {"_p_FXProgressBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHeader = {"_p_FXHeader", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorWell = {"_p_FXColorWell", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXToolBarTab = {"_p_FXToolBarTab", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSlider = {"_p_FXSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRealSlider = {"_p_FXRealSlider", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorRing = {"_p_FXColorRing", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXColorBar = {"_p_FXColorBar", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDriveBox = {"_p_FXDriveBox", "FXDriveBox *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFileDict = {"_p_FXFileDict", "FXFileDict *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFileSelector = {"_p_FXFileSelector", "FXFileSelector *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFont = {"_p_FXFont", "FXFont *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFontDesc = {"_p_FXFontDesc", "FXFontDesc *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFontSelector = {"_p_FXFontSelector", "FXFontSelector *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFrame = {"_p_FXFrame", "FXFrame *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXIcon = {"_p_FXIcon", "FXIcon *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXId = {"_p_FXId", "FXId *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXVisual = {"_p_FXVisual", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCursor = {"_p_FXCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXCURCursor = {"_p_FXCURCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXGIFCursor = {"_p_FXGIFCursor", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXImage = {"_p_FXImage", "FXImage *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXImageView = {"_p_FXImageView", "FXImageView *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXListBox = {"_p_FXListBox", "FXListBox *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXListItem = {"_p_FXListItem", "FXListItem *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXObject = {"_p_FXObject", "FXObject *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXDocument = {"_p_FXDocument", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRegistry = {"_p_FXRegistry", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXHeaderItem = {"_p_FXHeaderItem", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXIconDict = {"_p_FXIconDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXRecentFiles = {"_p_FXRecentFiles", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTranslator = {"_p_FXTranslator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDict = {"_p_FXDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXSettings = {"_p_FXSettings", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDataTarget = {"_p_FXDataTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDebugTarget = {"_p_FXDebugTarget", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXStringDict = {"_p_FXStringDict", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXDelegator = {"_p_FXDelegator", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXAccelTable = {"_p_FXAccelTable", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXPacker = {"_p_FXPacker", "FXPacker *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRealSpinner = {"_p_FXRealSpinner", "FXRealSpinner *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRegion = {"_p_FXRegion", "FXRegion *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRuler = {"_p_FXRuler", "FXRuler *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXRulerView = {"_p_FXRulerView", "FXRulerView *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXScrollArea = {"_p_FXScrollArea", "FXScrollArea *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXScrollBar = {"_p_FXScrollBar", "FXScrollBar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXScrollCorner = {"_p_FXScrollCorner", "FXScrollCorner *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXShell = {"_p_FXShell", "FXShell *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXSpinner = {"_p_FXSpinner", "FXSpinner *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXStream = {"_p_FXStream", "FXStream *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXFileStream = {"_p_FXFileStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXMemoryStream = {"_p_FXMemoryStream", 0, 0, 0, 0, 0};
+static swig_type_info _swigt__p_FXTabBar = {"_p_FXTabBar", "FXTabBar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXTabBook = {"_p_FXTabBook", "FXTabBook *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXToolBar = {"_p_FXToolBar", "FXToolBar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXToolBarGrip = {"_p_FXToolBarGrip", "FXToolBarGrip *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXToolBarShell = {"_p_FXToolBarShell", "FXToolBarShell *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXToolTip = {"_p_FXToolTip", "FXToolTip *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXTopWindow = {"_p_FXTopWindow", "FXTopWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXTreeItem = {"_p_FXTreeItem", "FXTreeItem *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXTreeListBox = {"_p_FXTreeListBox", "FXTreeListBox *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FXWindow = {"_p_FXWindow", "FXWindow *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_char = {"_p_char", "char *|FXchar *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_double = {"_p_double", "double *|FXdouble *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_float = {"_p_float", "float *|FXfloat *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "FXint *|int *|FXInputHandle *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_long = {"_p_long", "long *|FXTime *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_short = {"_p_short", "short *|FXshort *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "FXuchar *|unsigned char *|FXbool *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "FXwchar *|FXDragType *|unsigned int *|FXuint *|FXColor *|FXSelector *|FXHotKey *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|FXuval *|FXPixel *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|FXushort *", 0, 0, (void*)0, 0};
+
+static swig_type_info *swig_type_initial[] = {
+  &_swigt__p_FX4Splitter,
+  &_swigt__p_FX7Segment,
+  &_swigt__p_FXAccelTable,
+  &_swigt__p_FXApp,
+  &_swigt__p_FXArrowButton,
+  &_swigt__p_FXBitmap,
+  &_swigt__p_FXBitmapFrame,
+  &_swigt__p_FXButton,
+  &_swigt__p_FXCURCursor,
+  &_swigt__p_FXCanvas,
+  &_swigt__p_FXColorBar,
+  &_swigt__p_FXColorRing,
+  &_swigt__p_FXColorSelector,
+  &_swigt__p_FXColorWell,
+  &_swigt__p_FXColorWheel,
+  &_swigt__p_FXComboBox,
+  &_swigt__p_FXComposite,
+  &_swigt__p_FXCursor,
+  &_swigt__p_FXDataTarget,
+  &_swigt__p_FXDebugTarget,
+  &_swigt__p_FXDelegator,
+  &_swigt__p_FXDial,
+  &_swigt__p_FXDict,
+  &_swigt__p_FXDirBox,
+  &_swigt__p_FXDirSelector,
+  &_swigt__p_FXDockBar,
+  &_swigt__p_FXDockHandler,
+  &_swigt__p_FXDockSite,
+  &_swigt__p_FXDockTitle,
+  &_swigt__p_FXDocument,
+  &_swigt__p_FXDragCorner,
+  &_swigt__p_FXDrawable,
+  &_swigt__p_FXDriveBox,
+  &_swigt__p_FXFileDict,
+  &_swigt__p_FXFileSelector,
+  &_swigt__p_FXFileStream,
+  &_swigt__p_FXFont,
+  &_swigt__p_FXFontDesc,
+  &_swigt__p_FXFontSelector,
+  &_swigt__p_FXFrame,
+  &_swigt__p_FXGIFCursor,
+  &_swigt__p_FXGradientBar,
+  &_swigt__p_FXGroupBox,
+  &_swigt__p_FXHeader,
+  &_swigt__p_FXHeaderItem,
+  &_swigt__p_FXHorizontalFrame,
+  &_swigt__p_FXHorizontalSeparator,
+  &_swigt__p_FXIcon,
+  &_swigt__p_FXIconDict,
+  &_swigt__p_FXId,
+  &_swigt__p_FXImage,
+  &_swigt__p_FXImageFrame,
+  &_swigt__p_FXImageView,
+  &_swigt__p_FXKnob,
+  &_swigt__p_FXListBox,
+  &_swigt__p_FXListItem,
+  &_swigt__p_FXMainWindow,
+  &_swigt__p_FXMatrix,
+  &_swigt__p_FXMemoryStream,
+  &_swigt__p_FXObject,
+  &_swigt__p_FXPacker,
+  &_swigt__p_FXPopup,
+  &_swigt__p_FXProgressBar,
+  &_swigt__p_FXRealSlider,
+  &_swigt__p_FXRealSpinner,
+  &_swigt__p_FXRecentFiles,
+  &_swigt__p_FXRegion,
+  &_swigt__p_FXRegistry,
+  &_swigt__p_FXRootWindow,
+  &_swigt__p_FXRuler,
+  &_swigt__p_FXRulerView,
+  &_swigt__p_FXScrollArea,
+  &_swigt__p_FXScrollBar,
+  &_swigt__p_FXScrollCorner,
+  &_swigt__p_FXScrollWindow,
+  &_swigt__p_FXSeparator,
+  &_swigt__p_FXSettings,
+  &_swigt__p_FXShell,
+  &_swigt__p_FXShutter,
+  &_swigt__p_FXShutterItem,
+  &_swigt__p_FXSlider,
+  &_swigt__p_FXSpinner,
+  &_swigt__p_FXSplashWindow,
+  &_swigt__p_FXSplitter,
+  &_swigt__p_FXSpring,
+  &_swigt__p_FXStatusBar,
+  &_swigt__p_FXStatusLine,
+  &_swigt__p_FXStream,
+  &_swigt__p_FXStringDict,
+  &_swigt__p_FXSwitcher,
+  &_swigt__p_FXTabBar,
+  &_swigt__p_FXTabBook,
+  &_swigt__p_FXTextField,
+  &_swigt__p_FXToolBar,
+  &_swigt__p_FXToolBarGrip,
+  &_swigt__p_FXToolBarShell,
+  &_swigt__p_FXToolBarTab,
+  &_swigt__p_FXToolTip,
+  &_swigt__p_FXTopWindow,
+  &_swigt__p_FXTranslator,
+  &_swigt__p_FXTreeItem,
+  &_swigt__p_FXTreeListBox,
+  &_swigt__p_FXVerticalFrame,
+  &_swigt__p_FXVerticalSeparator,
+  &_swigt__p_FXVisual,
+  &_swigt__p_FXWindow,
+  &_swigt__p_char,
+  &_swigt__p_double,
+  &_swigt__p_float,
+  &_swigt__p_int,
+  &_swigt__p_long,
+  &_swigt__p_short,
+  &_swigt__p_unsigned_char,
+  &_swigt__p_unsigned_int,
+  &_swigt__p_unsigned_long,
+  &_swigt__p_unsigned_short,
+};
+
+static swig_cast_info _swigc__p_FX7Segment[] = {  {&_swigt__p_FX7Segment, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXApp[] = {  {&_swigt__p_FXApp, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBitmap[] = {  {&_swigt__p_FXBitmap, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXButton[] = {  {&_swigt__p_FXButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCanvas[] = {  {&_swigt__p_FXCanvas, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorSelector[] = {  {&_swigt__p_FXColorSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComboBox[] = {  {&_swigt__p_FXComboBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGroupBox[] = {{&_swigt__p_FXGroupBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusBar[] = {{&_swigt__p_FXStatusBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPopup[] = {{&_swigt__p_FXPopup, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRootWindow[] = {{&_swigt__p_FXRootWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollWindow[] = {{&_swigt__p_FXScrollWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMainWindow[] = {{&_swigt__p_FXMainWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplashWindow[] = {{&_swigt__p_FXSplashWindow, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalFrame[] = {{&_swigt__p_FXHorizontalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalFrame[] = {{&_swigt__p_FXVerticalFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FX4Splitter[] = {{&_swigt__p_FX4Splitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSplitter[] = {{&_swigt__p_FXSplitter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSwitcher[] = {{&_swigt__p_FXSwitcher, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutter[] = {{&_swigt__p_FXShutter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShutterItem[] = {{&_swigt__p_FXShutterItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMatrix[] = {{&_swigt__p_FXMatrix, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpring[] = {{&_swigt__p_FXSpring, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXComposite[] = {  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXComposite, 0, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXComposite, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXComposite, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXComposite, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXComposite, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXComposite, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXComposite, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXComposite, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXComposite, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXComposite, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXComposite, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXComposite, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXComposite, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXComposite, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirBox[] = {  {&_swigt__p_FXDirBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDirSelector[] = {  {&_swigt__p_FXDirSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockBar[] = {  {&_swigt__p_FXDockBar, 0, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXDockBar, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockHandler[] = {  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXDockHandler, 0, 0},  {&_swigt__p_FXDockHandler, 0, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXDockHandler, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockSite[] = {  {&_swigt__p_FXDockSite, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDockTitle[] = {  {&_swigt__p_FXDockTitle, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDragCorner[] = {  {&_swigt__p_FXDragCorner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDial[] = {{&_swigt__p_FXDial, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTextField[] = {{&_swigt__p_FXTextField, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXArrowButton[] = {{&_swigt__p_FXArrowButton, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVerticalSeparator[] = {{&_swigt__p_FXVerticalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHorizontalSeparator[] = {{&_swigt__p_FXHorizontalSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSeparator[] = {{&_swigt__p_FXSeparator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStatusLine[] = {{&_swigt__p_FXStatusLine, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWheel[] = {{&_swigt__p_FXColorWheel, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXBitmapFrame[] = {{&_swigt__p_FXBitmapFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGradientBar[] = {{&_swigt__p_FXGradientBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageFrame[] = {{&_swigt__p_FXImageFrame, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXKnob[] = {{&_swigt__p_FXKnob, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXProgressBar[] = {{&_swigt__p_FXProgressBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeader[] = {{&_swigt__p_FXHeader, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorWell[] = {{&_swigt__p_FXColorWell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarTab[] = {{&_swigt__p_FXToolBarTab, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSlider[] = {{&_swigt__p_FXSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSlider[] = {{&_swigt__p_FXRealSlider, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorRing[] = {{&_swigt__p_FXColorRing, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXColorBar[] = {{&_swigt__p_FXColorBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDrawable[] = {  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDrawable, 0, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXDrawable, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXDrawable, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXDrawable, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDriveBox[] = {  {&_swigt__p_FXDriveBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileDict[] = {  {&_swigt__p_FXFileDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileSelector[] = {  {&_swigt__p_FXFileSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFont[] = {  {&_swigt__p_FXFont, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFontDesc[] = {  {&_swigt__p_FXFontDesc, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFontSelector[] = {  {&_swigt__p_FXFontSelector, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFrame[] = {  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXFrame, 0, 0},  {&_swigt__p_FXFrame, 0, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXFrame, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXFrame, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXFrame, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXFrame, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXFrame, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXFrame, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXFrame, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXFrame, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXFrame, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXFrame, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXFrame, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXFrame, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXFrame, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXFrame, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXFrame, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXFrame, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXFrame, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXFrame, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXFrame, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXFrame, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXFrame, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXFrame, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXFrame, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXFrame, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIcon[] = {  {&_swigt__p_FXIcon, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXVisual[] = {{&_swigt__p_FXVisual, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCursor[] = {{&_swigt__p_FXCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXCURCursor[] = {{&_swigt__p_FXCURCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXGIFCursor[] = {{&_swigt__p_FXGIFCursor, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXId[] = {  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXId, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXId, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXId, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXId, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXId, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXId, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXId, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXId, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXId, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXId, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXId, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXId, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXId, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXId, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXId, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXId, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXId, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXId, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXId, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXId, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXId, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXId, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXId, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXId, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXId, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXId, 0, 0},  {&_swigt__p_FXId, 0, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXId, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXId, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXId, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXId, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXId, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXId, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXId, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXId, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXId, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXId, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXId, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXId, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXId, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXId, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXId, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXId, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXId, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXId, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXId, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXId, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXId, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXId, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXId, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXId, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImage[] = {  {&_swigt__p_FXImage, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXImageView[] = {  {&_swigt__p_FXImageView, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXListBox[] = {  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXListBox, 0, 0},  {&_swigt__p_FXListBox, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXListItem[] = {  {&_swigt__p_FXListItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDocument[] = {{&_swigt__p_FXDocument, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegistry[] = {{&_swigt__p_FXRegistry, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXHeaderItem[] = {{&_swigt__p_FXHeaderItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXIconDict[] = {{&_swigt__p_FXIconDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRecentFiles[] = {{&_swigt__p_FXRecentFiles, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTranslator[] = {{&_swigt__p_FXTranslator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDict[] = {{&_swigt__p_FXDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSettings[] = {{&_swigt__p_FXSettings, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDataTarget[] = {{&_swigt__p_FXDataTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDebugTarget[] = {{&_swigt__p_FXDebugTarget, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStringDict[] = {{&_swigt__p_FXStringDict, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXDelegator[] = {{&_swigt__p_FXDelegator, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXAccelTable[] = {{&_swigt__p_FXAccelTable, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXObject[] = {  {&_swigt__p_FXDocument, _p_FXDocumentTo_p_FXObject, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXRegistry, _p_FXRegistryTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeaderItem, _p_FXHeaderItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXObject, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXObject, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXIconDict, _p_FXIconDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileDict, _p_FXFileDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXRecentFiles, _p_FXRecentFilesTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXObject, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXObject, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXObject, 0, 0},  {&_swigt__p_FXDrawable, _p_FXDrawableTo_p_FXObject, 0, 0},  {&_swigt__p_FXFont, _p_FXFontTo_p_FXObject, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXObject, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXObject, 0, 0},  {&_swigt__p_FXTranslator, _p_FXTranslatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXObject, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXObject, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXObject, 0, 0},  {&_swigt__p_FXApp, _p_FXAppTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXObject, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXObject, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXObject, 0, 0},  {&_swigt__p_FXDict, _p_FXDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXObject, 0, 0},  {&_swigt__p_FXSettings, _p_FXSettingsTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXObject, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXObject, 0, 0},  {&_swigt__p_FXDataTarget, _p_FXDataTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDebugTarget, _p_FXDebugTargetTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXObject, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXObject, 0, 0},  {&_swigt__p_FXId, _p_FXIdTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXObject, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXVisual, _p_FXVisualTo_p_FXObject, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXObject, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXObject, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXStringDict, _p_FXStringDictTo_p_FXObject, 0, 0},  {&_swigt__p_FXDelegator, _p_FXDelegatorTo_p_FXObject, 0, 0},  {&_swigt__p_FXAccelTable, _p_FXAccelTableTo_p_FXObject, 0, 0},  {&_swigt__p_FXObject, 0, 0, 0},  {&_swigt__p_FXCursor, _p_FXCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXCURCursor, _p_FXCURCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXGIFCursor, _p_FXGIFCursorTo_p_FXObject, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXObject, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXObject, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXObject, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXObject, 0, 0},  {&_swigt__p_FXWindow, _p_FXWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXObject, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXObject, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXObject, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXObject, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXObject, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXObject, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXObject, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXObject, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXObject, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXPacker[] = {  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXPacker, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXPacker, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXPacker, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXPacker, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXPacker, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXPacker, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXPacker, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXPacker, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXPacker, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXPacker, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXPacker, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXPacker, 0, 0},  {&_swigt__p_FXPacker, 0, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXPacker, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXPacker, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXPacker, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXPacker, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXPacker, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXPacker, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXPacker, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXPacker, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXPacker, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXPacker, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXPacker, 0, 0},  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXPacker, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXPacker, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRealSpinner[] = {  {&_swigt__p_FXRealSpinner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRegion[] = {  {&_swigt__p_FXRegion, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRuler[] = {  {&_swigt__p_FXRuler, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXRulerView[] = {  {&_swigt__p_FXRulerView, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollArea[] = {  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXScrollArea, 0, 0},  {&_swigt__p_FXScrollArea, 0, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXScrollArea, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXScrollArea, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollBar[] = {  {&_swigt__p_FXScrollBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXScrollCorner[] = {  {&_swigt__p_FXScrollCorner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXShell[] = {  {&_swigt__p_FXShell, 0, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXShell, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXShell, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXShell, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXShell, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXShell, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXShell, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXSpinner[] = {  {&_swigt__p_FXSpinner, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXFileStream[] = {{&_swigt__p_FXFileStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXMemoryStream[] = {{&_swigt__p_FXMemoryStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXStream[] = {  {&_swigt__p_FXFileStream, _p_FXFileStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXMemoryStream, _p_FXMemoryStreamTo_p_FXStream, 0, 0},  {&_swigt__p_FXStream, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabBar[] = {  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXTabBar, 0, 0},  {&_swigt__p_FXTabBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTabBook[] = {  {&_swigt__p_FXTabBook, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBar[] = {  {&_swigt__p_FXToolBar, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarGrip[] = {  {&_swigt__p_FXToolBarGrip, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolBarShell[] = {  {&_swigt__p_FXToolBarShell, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXToolTip[] = {  {&_swigt__p_FXToolTip, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTopWindow[] = {  {&_swigt__p_FXTopWindow, 0, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXTopWindow, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXTopWindow, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXTopWindow, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTreeItem[] = {  {&_swigt__p_FXTreeItem, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXTreeListBox[] = {  {&_swigt__p_FXTreeListBox, 0, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXTreeListBox, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FXWindow[] = {  {&_swigt__p_FXDriveBox, _p_FXDriveBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDial, _p_FXDialTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBar, _p_FXToolBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXComposite, _p_FXCompositeTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolTip, _p_FXToolTipTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTabBook, _p_FXTabBookTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTextField, _p_FXTextFieldTo_p_FXWindow, 0, 0},  {&_swigt__p_FXArrowButton, _p_FXArrowButtonTo_p_FXWindow, 0, 0},  {&_swigt__p_FXGroupBox, _p_FXGroupBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShell, _p_FXShellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXStatusBar, _p_FXStatusBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollArea, _p_FXScrollAreaTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPopup, _p_FXPopupTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRootWindow, _p_FXRootWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollWindow, _p_FXScrollWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXWindow, 0, 0, 0},  {&_swigt__p_FXTopWindow, _p_FXTopWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMainWindow, _p_FXMainWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplashWindow, _p_FXSplashWindowTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollCorner, _p_FXScrollCornerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRuler, _p_FXRulerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXCanvas, _p_FXCanvasTo_p_FXWindow, 0, 0},  {&_swigt__p_FXComboBox, _p_FXComboBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXVerticalSeparator, _p_FXVerticalSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHorizontalSeparator, _p_FXHorizontalSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSeparator, _p_FXSeparatorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXStatusLine, _p_FXStatusLineTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHorizontalFrame, _p_FXHorizontalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXVerticalFrame, _p_FXVerticalFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FX4Splitter, _p_FX4SplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSplitter, _p_FXSplitterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRealSpinner, _p_FXRealSpinnerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSpinner, _p_FXSpinnerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXPacker, _p_FXPackerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXScrollBar, _p_FXScrollBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorWheel, _p_FXColorWheelTo_p_FXWindow, 0, 0},  {&_swigt__p_FXBitmapFrame, _p_FXBitmapFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXGradientBar, _p_FXGradientBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDirBox, _p_FXDirBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockHandler, _p_FXDockHandlerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarGrip, _p_FXToolBarGripTo_p_FXWindow, 0, 0},  {&_swigt__p_FXImageFrame, _p_FXImageFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDragCorner, _p_FXDragCornerTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDirSelector, _p_FXDirSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFileSelector, _p_FXFileSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorSelector, _p_FXColorSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFontSelector, _p_FXFontSelectorTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSwitcher, _p_FXSwitcherTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutter, _p_FXShutterTo_p_FXWindow, 0, 0},  {&_swigt__p_FXKnob, _p_FXKnobTo_p_FXWindow, 0, 0},  {&_swigt__p_FXProgressBar, _p_FXProgressBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockSite, _p_FXDockSiteTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRulerView, _p_FXRulerViewTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockTitle, _p_FXDockTitleTo_p_FXWindow, 0, 0},  {&_swigt__p_FXListBox, _p_FXListBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTreeListBox, _p_FXTreeListBoxTo_p_FXWindow, 0, 0},  {&_swigt__p_FXHeader, _p_FXHeaderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXShutterItem, _p_FXShutterItemTo_p_FXWindow, 0, 0},  {&_swigt__p_FXMatrix, _p_FXMatrixTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorWell, _p_FXColorWellTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarTab, _p_FXToolBarTabTo_p_FXWindow, 0, 0},  {&_swigt__p_FXDockBar, _p_FXDockBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXTabBar, _p_FXTabBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXFrame, _p_FXFrameTo_p_FXWindow, 0, 0},  {&_swigt__p_FXImageView, _p_FXImageViewTo_p_FXWindow, 0, 0},  {&_swigt__p_FX7Segment, _p_FX7SegmentTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSlider, _p_FXSliderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXRealSlider, _p_FXRealSliderTo_p_FXWindow, 0, 0},  {&_swigt__p_FXSpring, _p_FXSpringTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorRing, _p_FXColorRingTo_p_FXWindow, 0, 0},  {&_swigt__p_FXColorBar, _p_FXColorBarTo_p_FXWindow, 0, 0},  {&_swigt__p_FXToolBarShell, _p_FXToolBarShellTo_p_FXWindow, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_long[] = {  {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
+
+static swig_cast_info *swig_cast_initial[] = {
+  _swigc__p_FX4Splitter,
+  _swigc__p_FX7Segment,
+  _swigc__p_FXAccelTable,
+  _swigc__p_FXApp,
+  _swigc__p_FXArrowButton,
+  _swigc__p_FXBitmap,
+  _swigc__p_FXBitmapFrame,
+  _swigc__p_FXButton,
+  _swigc__p_FXCURCursor,
+  _swigc__p_FXCanvas,
+  _swigc__p_FXColorBar,
+  _swigc__p_FXColorRing,
+  _swigc__p_FXColorSelector,
+  _swigc__p_FXColorWell,
+  _swigc__p_FXColorWheel,
+  _swigc__p_FXComboBox,
+  _swigc__p_FXComposite,
+  _swigc__p_FXCursor,
+  _swigc__p_FXDataTarget,
+  _swigc__p_FXDebugTarget,
+  _swigc__p_FXDelegator,
+  _swigc__p_FXDial,
+  _swigc__p_FXDict,
+  _swigc__p_FXDirBox,
+  _swigc__p_FXDirSelector,
+  _swigc__p_FXDockBar,
+  _swigc__p_FXDockHandler,
+  _swigc__p_FXDockSite,
+  _swigc__p_FXDockTitle,
+  _swigc__p_FXDocument,
+  _swigc__p_FXDragCorner,
+  _swigc__p_FXDrawable,
+  _swigc__p_FXDriveBox,
+  _swigc__p_FXFileDict,
+  _swigc__p_FXFileSelector,
+  _swigc__p_FXFileStream,
+  _swigc__p_FXFont,
+  _swigc__p_FXFontDesc,
+  _swigc__p_FXFontSelector,
+  _swigc__p_FXFrame,
+  _swigc__p_FXGIFCursor,
+  _swigc__p_FXGradientBar,
+  _swigc__p_FXGroupBox,
+  _swigc__p_FXHeader,
+  _swigc__p_FXHeaderItem,
+  _swigc__p_FXHorizontalFrame,
+  _swigc__p_FXHorizontalSeparator,
+  _swigc__p_FXIcon,
+  _swigc__p_FXIconDict,
+  _swigc__p_FXId,
+  _swigc__p_FXImage,
+  _swigc__p_FXImageFrame,
+  _swigc__p_FXImageView,
+  _swigc__p_FXKnob,
+  _swigc__p_FXListBox,
+  _swigc__p_FXListItem,
+  _swigc__p_FXMainWindow,
+  _swigc__p_FXMatrix,
+  _swigc__p_FXMemoryStream,
+  _swigc__p_FXObject,
+  _swigc__p_FXPacker,
+  _swigc__p_FXPopup,
+  _swigc__p_FXProgressBar,
+  _swigc__p_FXRealSlider,
+  _swigc__p_FXRealSpinner,
+  _swigc__p_FXRecentFiles,
+  _swigc__p_FXRegion,
+  _swigc__p_FXRegistry,
+  _swigc__p_FXRootWindow,
+  _swigc__p_FXRuler,
+  _swigc__p_FXRulerView,
+  _swigc__p_FXScrollArea,
+  _swigc__p_FXScrollBar,
+  _swigc__p_FXScrollCorner,
+  _swigc__p_FXScrollWindow,
+  _swigc__p_FXSeparator,
+  _swigc__p_FXSettings,
+  _swigc__p_FXShell,
+  _swigc__p_FXShutter,
+  _swigc__p_FXShutterItem,
+  _swigc__p_FXSlider,
+  _swigc__p_FXSpinner,
+  _swigc__p_FXSplashWindow,
+  _swigc__p_FXSplitter,
+  _swigc__p_FXSpring,
+  _swigc__p_FXStatusBar,
+  _swigc__p_FXStatusLine,
+  _swigc__p_FXStream,
+  _swigc__p_FXStringDict,
+  _swigc__p_FXSwitcher,
+  _swigc__p_FXTabBar,
+  _swigc__p_FXTabBook,
+  _swigc__p_FXTextField,
+  _swigc__p_FXToolBar,
+  _swigc__p_FXToolBarGrip,
+  _swigc__p_FXToolBarShell,
+  _swigc__p_FXToolBarTab,
+  _swigc__p_FXToolTip,
+  _swigc__p_FXTopWindow,
+  _swigc__p_FXTranslator,
+  _swigc__p_FXTreeItem,
+  _swigc__p_FXTreeListBox,
+  _swigc__p_FXVerticalFrame,
+  _swigc__p_FXVerticalSeparator,
+  _swigc__p_FXVisual,
+  _swigc__p_FXWindow,
+  _swigc__p_char,
+  _swigc__p_double,
+  _swigc__p_float,
+  _swigc__p_int,
+  _swigc__p_long,
+  _swigc__p_short,
+  _swigc__p_unsigned_char,
+  _swigc__p_unsigned_int,
+  _swigc__p_unsigned_long,
+  _swigc__p_unsigned_short,
+};
+
+
+/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
+
+/* -----------------------------------------------------------------------------
+ * Type initialization:
+ * This problem is tough by the requirement that no dynamic
+ * memory is used. Also, since swig_type_info structures store pointers to
+ * swig_cast_info structures and swig_cast_info structures store pointers back
+ * to swig_type_info structures, we need some lookup code at initialization.
+ * The idea is that swig generates all the structures that are needed.
+ * The runtime then collects these partially filled structures.
+ * The SWIG_InitializeModule function takes these initial arrays out of
+ * swig_module, and does all the lookup, filling in the swig_module.types
+ * array with the correct data and linking the correct swig_cast_info
+ * structures together.
+ *
+ * The generated swig_type_info structures are assigned statically to an initial
+ * array. We just loop through that array, and handle each type individually.
+ * First we lookup if this type has been already loaded, and if so, use the
+ * loaded structure instead of the generated one. Then we have to fill in the
+ * cast linked list. The cast data is initially stored in something like a
+ * two-dimensional array. Each row corresponds to a type (there are the same
+ * number of rows as there are in the swig_type_initial array). Each entry in
+ * a column is one of the swig_cast_info structures for that type.
+ * The cast_initial array is actually an array of arrays, because each row has
+ * a variable number of columns. So to actually build the cast linked list,
+ * we find the array of casts associated with the type, and loop through it
+ * adding the casts to the list. The one last trick we need to do is making
+ * sure the type pointer in the swig_cast_info struct is correct.
+ *
+ * First off, we lookup the cast->type name to see if it is already loaded.
+ * There are three cases to handle:
+ *  1) If the cast->type has already been loaded AND the type we are adding
+ *     casting info to has not been loaded (it is in this module), THEN we
+ *     replace the cast->type pointer with the type pointer that has already
+ *     been loaded.
+ *  2) If BOTH types (the one we are adding casting info to, and the
+ *     cast->type) are loaded, THEN the cast info has already been loaded by
+ *     the previous module so we just ignore it.
+ *  3) Finally, if cast->type has not already been loaded, then we add that
+ *     swig_cast_info to the linked list (because the cast->type) pointer will
+ *     be correct.
+ * ----------------------------------------------------------------------------- */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* c-mode */
+#endif
+#endif
+
+#if 0
+#define SWIGRUNTIME_DEBUG
+#endif
+
+
+SWIGRUNTIME void
+SWIG_InitializeModule(void *clientdata) {
+  size_t i;
+  swig_module_info *module_head, *iter;
+  int init;
+
+  /* check to see if the circular list has been setup, if not, set it up */
+  if (swig_module.next==0) {
+    /* Initialize the swig_module */
+    swig_module.type_initial = swig_type_initial;
+    swig_module.cast_initial = swig_cast_initial;
+    swig_module.next = &swig_module;
+    init = 1;
+  } else {
+    init = 0;
+  }
+
+  /* Try and load any already created modules */
+  module_head = SWIG_GetModule(clientdata);
+  if (!module_head) {
+    /* This is the first module loaded for this interpreter */
+    /* so set the swig module into the interpreter */
+    SWIG_SetModule(clientdata, &swig_module);
+  } else {
+    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
+    iter=module_head;
+    do {
+      if (iter==&swig_module) {
+        /* Our module is already in the list, so there's nothing more to do. */
+        return;
+      }
+      iter=iter->next;
+    } while (iter!= module_head);
+
+    /* otherwise we must add our module into the list */
+    swig_module.next = module_head->next;
+    module_head->next = &swig_module;
+  }
+
+  /* When multiple interpreters are used, a module could have already been initialized in
+     a different interpreter, but not yet have a pointer in this interpreter.
+     In this case, we do not want to continue adding types... everything should be
+     set up already */
+  if (init == 0) return;
+
+  /* Now work on filling in swig_module.types */
+#ifdef SWIGRUNTIME_DEBUG
+  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
+#endif
+  for (i = 0; i < swig_module.size; ++i) {
+    swig_type_info *type = 0;
+    swig_type_info *ret;
+    swig_cast_info *cast;
+
+#ifdef SWIGRUNTIME_DEBUG
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+#endif
+
+    /* if there is another module already loaded */
+    if (swig_module.next != &swig_module) {
+      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
+    }
+    if (type) {
+      /* Overwrite clientdata field */
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found type %s\n", type->name);
+#endif
+      if (swig_module.type_initial[i]->clientdata) {
+	type->clientdata = swig_module.type_initial[i]->clientdata;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
+#endif
+      }
+    } else {
+      type = swig_module.type_initial[i];
+    }
+
+    /* Insert casting types */
+    cast = swig_module.cast_initial[i];
+    while (cast->type) {
+
+      /* Don't need to add information already in the list */
+      ret = 0;
+#ifdef SWIGRUNTIME_DEBUG
+      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
+#endif
+      if (swig_module.next != &swig_module) {
+        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
+#ifdef SWIGRUNTIME_DEBUG
+	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
+#endif
+      }
+      if (ret) {
+	if (type == swig_module.type_initial[i]) {
+#ifdef SWIGRUNTIME_DEBUG
+	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
+#endif
+	  cast->type = ret;
+	  ret = 0;
+	} else {
+	  /* Check for casting already in the list */
+	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
+#ifdef SWIGRUNTIME_DEBUG
+	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
+#endif
+	  if (!ocast) ret = 0;
+	}
+      }
+
+      if (!ret) {
+#ifdef SWIGRUNTIME_DEBUG
+	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
+#endif
+        if (type->cast) {
+          type->cast->prev = cast;
+          cast->next = type->cast;
+        }
+        type->cast = cast;
+      }
+      cast++;
+    }
+    /* Set entry in modules->types array equal to the type */
+    swig_module.types[i] = type;
+  }
+  swig_module.types[i] = 0;
+
+#ifdef SWIGRUNTIME_DEBUG
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+  for (i = 0; i < swig_module.size; ++i) {
+    int j = 0;
+    swig_cast_info *cast = swig_module.cast_initial[i];
+    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
+    while (cast->type) {
+      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
+      cast++;
+      ++j;
+    }
+  printf("---- Total casts: %d\n",j);
+  }
+  printf("**** SWIG_InitializeModule: Cast List ******\n");
+#endif
+}
+
+/* This function will propagate the clientdata field of type to
+* any new swig_type_info structures that have been added into the list
+* of equivalent types.  It is like calling
+* SWIG_TypeClientData(type, clientdata) a second time.
+*/
+SWIGRUNTIME void
+SWIG_PropagateClientData(void) {
+  size_t i;
+  swig_cast_info *equiv;
+  static int init_run = 0;
+
+  if (init_run) return;
+  init_run = 1;
+
+  for (i = 0; i < swig_module.size; i++) {
+    if (swig_module.types[i]->clientdata) {
+      equiv = swig_module.types[i]->cast;
+      while (equiv) {
+        if (!equiv->converter) {
+          if (equiv->type && !equiv->type->clientdata)
+            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
+        }
+        equiv = equiv->next;
+      }
+    }
+  }
+}
+
+#ifdef __cplusplus
+#if 0
+{ /* c-mode */
+#endif
+}
+#endif
+
+/*
+
+*/
+#ifdef __cplusplus
+extern "C"
+#endif
+SWIGEXPORT void Init_ui(void) {
+  size_t i;
+  
+  SWIG_InitRuntime();
+  
+  
+  SWIG_InitializeModule(0);
+  for (i = 0; i < swig_module.size; i++) {
+    SWIG_define_class(swig_module.types[i]);
+  }
+  
+  SWIG_RubyInitializeTrackings();
+  
+  
+  
+  rb_define_const(mFox, "SEVENSEGMENT_NORMAL", SWIG_From_int(static_cast< int >(SEVENSEGMENT_NORMAL)));
+  rb_define_const(mFox, "SEVENSEGMENT_SHADOW", SWIG_From_int(static_cast< int >(SEVENSEGMENT_SHADOW)));
+  
+  SwigClassFX7Segment.klass = rb_define_class_under(mFox, "FX7Segment", ((swig_class *) SWIGTYPE_p_FXFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FX7Segment, (void *) &SwigClassFX7Segment);
+  rb_define_alloc_func(SwigClassFX7Segment.klass, _wrap_FX7Segment_allocate);
+  rb_define_method(SwigClassFX7Segment.klass, "initialize", VALUEFUNC(_wrap_new_FX7Segment), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "onPaint", VALUEFUNC(_wrap_FX7Segment_onPaint), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "onCmdSetValue", VALUEFUNC(_wrap_FX7Segment_onCmdSetValue), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FX7Segment_onCmdSetIntValue), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "onCmdSetRealValue", VALUEFUNC(_wrap_FX7Segment_onCmdSetRealValue), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "onCmdSetStringValue", VALUEFUNC(_wrap_FX7Segment_onCmdSetStringValue), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FX7Segment_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "onCmdGetRealValue", VALUEFUNC(_wrap_FX7Segment_onCmdGetRealValue), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "onCmdGetStringValue", VALUEFUNC(_wrap_FX7Segment_onCmdGetStringValue), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "onCmdSetHelp", VALUEFUNC(_wrap_FX7Segment_onCmdSetHelp), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "onCmdGetHelp", VALUEFUNC(_wrap_FX7Segment_onCmdGetHelp), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "onCmdSetTip", VALUEFUNC(_wrap_FX7Segment_onCmdSetTip), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "onCmdGetTip", VALUEFUNC(_wrap_FX7Segment_onCmdGetTip), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "onQueryHelp", VALUEFUNC(_wrap_FX7Segment_onQueryHelp), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "onQueryTip", VALUEFUNC(_wrap_FX7Segment_onQueryTip), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "text=", VALUEFUNC(_wrap_FX7Segment_texte___), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "text", VALUEFUNC(_wrap_FX7Segment_text), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "textColor=", VALUEFUNC(_wrap_FX7Segment_textColore___), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "textColor", VALUEFUNC(_wrap_FX7Segment_textColor), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "cellWidth=", VALUEFUNC(_wrap_FX7Segment_cellWidthe___), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "cellWidth", VALUEFUNC(_wrap_FX7Segment_cellWidth), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "cellHeight=", VALUEFUNC(_wrap_FX7Segment_cellHeighte___), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "cellHeight", VALUEFUNC(_wrap_FX7Segment_cellHeight), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "thickness=", VALUEFUNC(_wrap_FX7Segment_thicknesse___), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "thickness", VALUEFUNC(_wrap_FX7Segment_thickness), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "set7SegmentStyle", VALUEFUNC(_wrap_FX7Segment_set7SegmentStyle), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "get7SegmentStyle", VALUEFUNC(_wrap_FX7Segment_get7SegmentStyle), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "justify=", VALUEFUNC(_wrap_FX7Segment_justifye___), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "justify", VALUEFUNC(_wrap_FX7Segment_justify), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "helpText=", VALUEFUNC(_wrap_FX7Segment_helpTexte___), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "helpText", VALUEFUNC(_wrap_FX7Segment_helpText), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "tipText=", VALUEFUNC(_wrap_FX7Segment_tipTexte___), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "tipText", VALUEFUNC(_wrap_FX7Segment_tipText), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "save", VALUEFUNC(_wrap_FX7Segment_save), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "load", VALUEFUNC(_wrap_FX7Segment_load), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "create", VALUEFUNC(_wrap_FX7Segment_create), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "detach", VALUEFUNC(_wrap_FX7Segment_detach), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "destroy", VALUEFUNC(_wrap_FX7Segment_destroy), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "resize", VALUEFUNC(_wrap_FX7Segment_resize), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "getDefaultWidth", VALUEFUNC(_wrap_FX7Segment_getDefaultWidth), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "getDefaultHeight", VALUEFUNC(_wrap_FX7Segment_getDefaultHeight), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "getWidthForHeight", VALUEFUNC(_wrap_FX7Segment_getWidthForHeight), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "getHeightForWidth", VALUEFUNC(_wrap_FX7Segment_getHeightForWidth), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "canFocus", VALUEFUNC(_wrap_FX7Segment_canFocus), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "setFocus", VALUEFUNC(_wrap_FX7Segment_setFocus), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "killFocus", VALUEFUNC(_wrap_FX7Segment_killFocus), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "changeFocus", VALUEFUNC(_wrap_FX7Segment_changeFocus), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "setDefault", VALUEFUNC(_wrap_FX7Segment_setDefault), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "enable", VALUEFUNC(_wrap_FX7Segment_enable), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "disable", VALUEFUNC(_wrap_FX7Segment_disable), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "raiseWindow", VALUEFUNC(_wrap_FX7Segment_raiseWindow), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "lower", VALUEFUNC(_wrap_FX7Segment_lower), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "move", VALUEFUNC(_wrap_FX7Segment_move), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "position", VALUEFUNC(_wrap_FX7Segment_position), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "layout", VALUEFUNC(_wrap_FX7Segment_layout), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "recalc", VALUEFUNC(_wrap_FX7Segment_recalc), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "reparent", VALUEFUNC(_wrap_FX7Segment_reparent), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "show", VALUEFUNC(_wrap_FX7Segment_show), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "hide", VALUEFUNC(_wrap_FX7Segment_hide), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "isComposite", VALUEFUNC(_wrap_FX7Segment_isComposite), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "contains", VALUEFUNC(_wrap_FX7Segment_contains), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "doesSaveUnder", VALUEFUNC(_wrap_FX7Segment_doesSaveUnder), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "setBackColor", VALUEFUNC(_wrap_FX7Segment_setBackColor), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "tr", VALUEFUNC(_wrap_FX7Segment_tr), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "dropEnable", VALUEFUNC(_wrap_FX7Segment_dropEnable), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "dropDisable", VALUEFUNC(_wrap_FX7Segment_dropDisable), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "setShape", VALUEFUNC(_wrap_FX7Segment_setShape), -1);
+  rb_define_method(SwigClassFX7Segment.klass, "clearShape", VALUEFUNC(_wrap_FX7Segment_clearShape), -1);
+  SwigClassFX7Segment.mark = (void (*)(void *)) FXRb7Segment::markfunc;
+  SwigClassFX7Segment.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFX7Segment.trackObjects = 0;
+  rb_define_const(mFox, "SPIN_NORMAL", SWIG_From_int(static_cast< int >(SPIN_NORMAL)));
+  rb_define_const(mFox, "SPIN_CYCLIC", SWIG_From_int(static_cast< int >(SPIN_CYCLIC)));
+  rb_define_const(mFox, "SPIN_NOTEXT", SWIG_From_int(static_cast< int >(SPIN_NOTEXT)));
+  rb_define_const(mFox, "SPIN_NOMAX", SWIG_From_int(static_cast< int >(SPIN_NOMAX)));
+  rb_define_const(mFox, "SPIN_NOMIN", SWIG_From_int(static_cast< int >(SPIN_NOMIN)));
+  
+  SwigClassFXSpinner.klass = rb_define_class_under(mFox, "FXSpinner", ((swig_class *) SWIGTYPE_p_FXPacker->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXSpinner, (void *) &SwigClassFXSpinner);
+  rb_define_alloc_func(SwigClassFXSpinner.klass, _wrap_FXSpinner_allocate);
+  rb_define_method(SwigClassFXSpinner.klass, "initialize", VALUEFUNC(_wrap_new_FXSpinner), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "onUpdIncrement", VALUEFUNC(_wrap_FXSpinner_onUpdIncrement), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "onCmdIncrement", VALUEFUNC(_wrap_FXSpinner_onCmdIncrement), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "onUpdDecrement", VALUEFUNC(_wrap_FXSpinner_onUpdDecrement), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "onCmdDecrement", VALUEFUNC(_wrap_FXSpinner_onCmdDecrement), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "onCmdEntry", VALUEFUNC(_wrap_FXSpinner_onCmdEntry), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "onChgEntry", VALUEFUNC(_wrap_FXSpinner_onChgEntry), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "onWheelEntry", VALUEFUNC(_wrap_FXSpinner_onWheelEntry), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "onKeyPress", VALUEFUNC(_wrap_FXSpinner_onKeyPress), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "onKeyRelease", VALUEFUNC(_wrap_FXSpinner_onKeyRelease), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXSpinner_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXSpinner_onCmdSetIntValue), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXSpinner_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "onCmdSetIntRange", VALUEFUNC(_wrap_FXSpinner_onCmdSetIntRange), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "onCmdGetIntRange", VALUEFUNC(_wrap_FXSpinner_onCmdGetIntRange), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "onFocusSelf", VALUEFUNC(_wrap_FXSpinner_onFocusSelf), -1);
+  rb_define_const(SwigClassFXSpinner.klass, "ID_INCREMENT", SWIG_From_int(static_cast< int >(FXSpinner::ID_INCREMENT)));
+  rb_define_const(SwigClassFXSpinner.klass, "ID_DECREMENT", SWIG_From_int(static_cast< int >(FXSpinner::ID_DECREMENT)));
+  rb_define_const(SwigClassFXSpinner.klass, "ID_ENTRY", SWIG_From_int(static_cast< int >(FXSpinner::ID_ENTRY)));
+  rb_define_const(SwigClassFXSpinner.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXSpinner::ID_LAST)));
+  rb_define_method(SwigClassFXSpinner.klass, "increment", VALUEFUNC(_wrap_FXSpinner_increment), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "incrementByAmount", VALUEFUNC(_wrap_FXSpinner_incrementByAmount), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "decrement", VALUEFUNC(_wrap_FXSpinner_decrement), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "decrementByAmount", VALUEFUNC(_wrap_FXSpinner_decrementByAmount), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "isCyclic", VALUEFUNC(_wrap_FXSpinner_isCyclic), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "setCyclic", VALUEFUNC(_wrap_FXSpinner_setCyclic), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "isTextVisible", VALUEFUNC(_wrap_FXSpinner_isTextVisible), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "setTextVisible", VALUEFUNC(_wrap_FXSpinner_setTextVisible), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "getValue", VALUEFUNC(_wrap_FXSpinner_getValue), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "setRange", VALUEFUNC(_wrap_FXSpinner_setRange), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "getRange", VALUEFUNC(_wrap_FXSpinner_getRange), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "setIncrement", VALUEFUNC(_wrap_FXSpinner_setIncrement), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "getIncrement", VALUEFUNC(_wrap_FXSpinner_getIncrement), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "setFont", VALUEFUNC(_wrap_FXSpinner_setFont), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "getFont", VALUEFUNC(_wrap_FXSpinner_getFont), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "setHelpText", VALUEFUNC(_wrap_FXSpinner_setHelpText), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "getHelpText", VALUEFUNC(_wrap_FXSpinner_getHelpText), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "setTipText", VALUEFUNC(_wrap_FXSpinner_setTipText), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "getTipText", VALUEFUNC(_wrap_FXSpinner_getTipText), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "setSpinnerStyle", VALUEFUNC(_wrap_FXSpinner_setSpinnerStyle), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "getSpinnerStyle", VALUEFUNC(_wrap_FXSpinner_getSpinnerStyle), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "setEditable", VALUEFUNC(_wrap_FXSpinner_setEditable), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "isEditable", VALUEFUNC(_wrap_FXSpinner_isEditable), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "setUpArrowColor", VALUEFUNC(_wrap_FXSpinner_setUpArrowColor), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "getUpArrowColor", VALUEFUNC(_wrap_FXSpinner_getUpArrowColor), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "setDownArrowColor", VALUEFUNC(_wrap_FXSpinner_setDownArrowColor), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "getDownArrowColor", VALUEFUNC(_wrap_FXSpinner_getDownArrowColor), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "setTextColor", VALUEFUNC(_wrap_FXSpinner_setTextColor), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "getTextColor", VALUEFUNC(_wrap_FXSpinner_getTextColor), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "setSelBackColor", VALUEFUNC(_wrap_FXSpinner_setSelBackColor), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "getSelBackColor", VALUEFUNC(_wrap_FXSpinner_getSelBackColor), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "setSelTextColor", VALUEFUNC(_wrap_FXSpinner_setSelTextColor), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "getSelTextColor", VALUEFUNC(_wrap_FXSpinner_getSelTextColor), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "setCursorColor", VALUEFUNC(_wrap_FXSpinner_setCursorColor), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "getCursorColor", VALUEFUNC(_wrap_FXSpinner_getCursorColor), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "setNumColumns", VALUEFUNC(_wrap_FXSpinner_setNumColumns), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "getNumColumns", VALUEFUNC(_wrap_FXSpinner_getNumColumns), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "save", VALUEFUNC(_wrap_FXSpinner_save), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "load", VALUEFUNC(_wrap_FXSpinner_load), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "create", VALUEFUNC(_wrap_FXSpinner_create), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "detach", VALUEFUNC(_wrap_FXSpinner_detach), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "destroy", VALUEFUNC(_wrap_FXSpinner_destroy), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "resize", VALUEFUNC(_wrap_FXSpinner_resize), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXSpinner_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXSpinner_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXSpinner_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXSpinner_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "canFocus", VALUEFUNC(_wrap_FXSpinner_canFocus), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "setFocus", VALUEFUNC(_wrap_FXSpinner_setFocus), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "killFocus", VALUEFUNC(_wrap_FXSpinner_killFocus), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "changeFocus", VALUEFUNC(_wrap_FXSpinner_changeFocus), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "setDefault", VALUEFUNC(_wrap_FXSpinner_setDefault), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "enable", VALUEFUNC(_wrap_FXSpinner_enable), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "disable", VALUEFUNC(_wrap_FXSpinner_disable), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "raiseWindow", VALUEFUNC(_wrap_FXSpinner_raiseWindow), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "lower", VALUEFUNC(_wrap_FXSpinner_lower), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "move", VALUEFUNC(_wrap_FXSpinner_move), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "position", VALUEFUNC(_wrap_FXSpinner_position), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "layout", VALUEFUNC(_wrap_FXSpinner_layout), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "recalc", VALUEFUNC(_wrap_FXSpinner_recalc), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "reparent", VALUEFUNC(_wrap_FXSpinner_reparent), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "show", VALUEFUNC(_wrap_FXSpinner_show), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "hide", VALUEFUNC(_wrap_FXSpinner_hide), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "isComposite", VALUEFUNC(_wrap_FXSpinner_isComposite), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "contains", VALUEFUNC(_wrap_FXSpinner_contains), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXSpinner_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "setBackColor", VALUEFUNC(_wrap_FXSpinner_setBackColor), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "tr", VALUEFUNC(_wrap_FXSpinner_tr), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "dropEnable", VALUEFUNC(_wrap_FXSpinner_dropEnable), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "dropDisable", VALUEFUNC(_wrap_FXSpinner_dropDisable), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "setShape", VALUEFUNC(_wrap_FXSpinner_setShape), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "clearShape", VALUEFUNC(_wrap_FXSpinner_clearShape), -1);
+  rb_define_method(SwigClassFXSpinner.klass, "setValue", VALUEFUNC(_wrap_FXSpinner_setValue), -1);
+  SwigClassFXSpinner.mark = (void (*)(void *)) FXRbSpinner::markfunc;
+  SwigClassFXSpinner.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXSpinner.trackObjects = 0;
+  rb_define_const(mFox, "REALSPIN_NORMAL", SWIG_From_int(static_cast< int >(REALSPIN_NORMAL)));
+  rb_define_const(mFox, "REALSPIN_CYCLIC", SWIG_From_int(static_cast< int >(REALSPIN_CYCLIC)));
+  rb_define_const(mFox, "REALSPIN_NOTEXT", SWIG_From_int(static_cast< int >(REALSPIN_NOTEXT)));
+  rb_define_const(mFox, "REALSPIN_NOMAX", SWIG_From_int(static_cast< int >(REALSPIN_NOMAX)));
+  rb_define_const(mFox, "REALSPIN_NOMIN", SWIG_From_int(static_cast< int >(REALSPIN_NOMIN)));
+  rb_define_const(mFox, "REALSPIN_LOG", SWIG_From_int(static_cast< int >(REALSPIN_LOG)));
+  
+  SwigClassFXRealSpinner.klass = rb_define_class_under(mFox, "FXRealSpinner", ((swig_class *) SWIGTYPE_p_FXPacker->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXRealSpinner, (void *) &SwigClassFXRealSpinner);
+  rb_define_alloc_func(SwigClassFXRealSpinner.klass, _wrap_FXRealSpinner_allocate);
+  rb_define_method(SwigClassFXRealSpinner.klass, "initialize", VALUEFUNC(_wrap_new_FXRealSpinner), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "onUpdIncrement", VALUEFUNC(_wrap_FXRealSpinner_onUpdIncrement), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "onCmdIncrement", VALUEFUNC(_wrap_FXRealSpinner_onCmdIncrement), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "onUpdDecrement", VALUEFUNC(_wrap_FXRealSpinner_onUpdDecrement), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "onCmdDecrement", VALUEFUNC(_wrap_FXRealSpinner_onCmdDecrement), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "onCmdEntry", VALUEFUNC(_wrap_FXRealSpinner_onCmdEntry), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "onChgEntry", VALUEFUNC(_wrap_FXRealSpinner_onChgEntry), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "onWheelEntry", VALUEFUNC(_wrap_FXRealSpinner_onWheelEntry), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "onKeyPress", VALUEFUNC(_wrap_FXRealSpinner_onKeyPress), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "onKeyRelease", VALUEFUNC(_wrap_FXRealSpinner_onKeyRelease), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXRealSpinner_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXRealSpinner_onCmdSetIntValue), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXRealSpinner_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "onCmdSetIntRange", VALUEFUNC(_wrap_FXRealSpinner_onCmdSetIntRange), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "onCmdGetIntRange", VALUEFUNC(_wrap_FXRealSpinner_onCmdGetIntRange), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "onCmdSetRealValue", VALUEFUNC(_wrap_FXRealSpinner_onCmdSetRealValue), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "onCmdGetRealValue", VALUEFUNC(_wrap_FXRealSpinner_onCmdGetRealValue), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "onCmdSetRealRange", VALUEFUNC(_wrap_FXRealSpinner_onCmdSetRealRange), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "onCmdGetRealRange", VALUEFUNC(_wrap_FXRealSpinner_onCmdGetRealRange), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "onFocusSelf", VALUEFUNC(_wrap_FXRealSpinner_onFocusSelf), -1);
+  rb_define_const(SwigClassFXRealSpinner.klass, "ID_INCREMENT", SWIG_From_int(static_cast< int >(FXRealSpinner::ID_INCREMENT)));
+  rb_define_const(SwigClassFXRealSpinner.klass, "ID_DECREMENT", SWIG_From_int(static_cast< int >(FXRealSpinner::ID_DECREMENT)));
+  rb_define_const(SwigClassFXRealSpinner.klass, "ID_ENTRY", SWIG_From_int(static_cast< int >(FXRealSpinner::ID_ENTRY)));
+  rb_define_const(SwigClassFXRealSpinner.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXRealSpinner::ID_LAST)));
+  rb_define_method(SwigClassFXRealSpinner.klass, "increment", VALUEFUNC(_wrap_FXRealSpinner_increment), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "incrementByAmount", VALUEFUNC(_wrap_FXRealSpinner_incrementByAmount), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "decrement", VALUEFUNC(_wrap_FXRealSpinner_decrement), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "decrementByAmount", VALUEFUNC(_wrap_FXRealSpinner_decrementByAmount), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "isCyclic", VALUEFUNC(_wrap_FXRealSpinner_isCyclic), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "setCyclic", VALUEFUNC(_wrap_FXRealSpinner_setCyclic), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "isTextVisible", VALUEFUNC(_wrap_FXRealSpinner_isTextVisible), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "setTextVisible", VALUEFUNC(_wrap_FXRealSpinner_setTextVisible), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "getValue", VALUEFUNC(_wrap_FXRealSpinner_getValue), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "setRange", VALUEFUNC(_wrap_FXRealSpinner_setRange), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "getRange", VALUEFUNC(_wrap_FXRealSpinner_getRange), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "setIncrement", VALUEFUNC(_wrap_FXRealSpinner_setIncrement), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "getIncrement", VALUEFUNC(_wrap_FXRealSpinner_getIncrement), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "granularity=", VALUEFUNC(_wrap_FXRealSpinner_granularitye___), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "granularity", VALUEFUNC(_wrap_FXRealSpinner_granularity), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "setFont", VALUEFUNC(_wrap_FXRealSpinner_setFont), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "getFont", VALUEFUNC(_wrap_FXRealSpinner_getFont), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "setHelpText", VALUEFUNC(_wrap_FXRealSpinner_setHelpText), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "getHelpText", VALUEFUNC(_wrap_FXRealSpinner_getHelpText), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "setTipText", VALUEFUNC(_wrap_FXRealSpinner_setTipText), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "getTipText", VALUEFUNC(_wrap_FXRealSpinner_getTipText), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "setSpinnerStyle", VALUEFUNC(_wrap_FXRealSpinner_setSpinnerStyle), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "getSpinnerStyle", VALUEFUNC(_wrap_FXRealSpinner_getSpinnerStyle), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "setEditable", VALUEFUNC(_wrap_FXRealSpinner_setEditable), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "isEditable", VALUEFUNC(_wrap_FXRealSpinner_isEditable), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "setUpArrowColor", VALUEFUNC(_wrap_FXRealSpinner_setUpArrowColor), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "getUpArrowColor", VALUEFUNC(_wrap_FXRealSpinner_getUpArrowColor), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "setDownArrowColor", VALUEFUNC(_wrap_FXRealSpinner_setDownArrowColor), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "getDownArrowColor", VALUEFUNC(_wrap_FXRealSpinner_getDownArrowColor), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "setTextColor", VALUEFUNC(_wrap_FXRealSpinner_setTextColor), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "getTextColor", VALUEFUNC(_wrap_FXRealSpinner_getTextColor), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "setSelBackColor", VALUEFUNC(_wrap_FXRealSpinner_setSelBackColor), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "getSelBackColor", VALUEFUNC(_wrap_FXRealSpinner_getSelBackColor), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "setSelTextColor", VALUEFUNC(_wrap_FXRealSpinner_setSelTextColor), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "getSelTextColor", VALUEFUNC(_wrap_FXRealSpinner_getSelTextColor), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "setCursorColor", VALUEFUNC(_wrap_FXRealSpinner_setCursorColor), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "getCursorColor", VALUEFUNC(_wrap_FXRealSpinner_getCursorColor), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "setNumColumns", VALUEFUNC(_wrap_FXRealSpinner_setNumColumns), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "getNumColumns", VALUEFUNC(_wrap_FXRealSpinner_getNumColumns), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "save", VALUEFUNC(_wrap_FXRealSpinner_save), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "load", VALUEFUNC(_wrap_FXRealSpinner_load), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "create", VALUEFUNC(_wrap_FXRealSpinner_create), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "detach", VALUEFUNC(_wrap_FXRealSpinner_detach), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "destroy", VALUEFUNC(_wrap_FXRealSpinner_destroy), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "resize", VALUEFUNC(_wrap_FXRealSpinner_resize), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXRealSpinner_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXRealSpinner_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXRealSpinner_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXRealSpinner_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "canFocus", VALUEFUNC(_wrap_FXRealSpinner_canFocus), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "setFocus", VALUEFUNC(_wrap_FXRealSpinner_setFocus), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "killFocus", VALUEFUNC(_wrap_FXRealSpinner_killFocus), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "changeFocus", VALUEFUNC(_wrap_FXRealSpinner_changeFocus), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "setDefault", VALUEFUNC(_wrap_FXRealSpinner_setDefault), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "enable", VALUEFUNC(_wrap_FXRealSpinner_enable), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "disable", VALUEFUNC(_wrap_FXRealSpinner_disable), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "raiseWindow", VALUEFUNC(_wrap_FXRealSpinner_raiseWindow), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "lower", VALUEFUNC(_wrap_FXRealSpinner_lower), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "move", VALUEFUNC(_wrap_FXRealSpinner_move), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "position", VALUEFUNC(_wrap_FXRealSpinner_position), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "layout", VALUEFUNC(_wrap_FXRealSpinner_layout), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "recalc", VALUEFUNC(_wrap_FXRealSpinner_recalc), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "reparent", VALUEFUNC(_wrap_FXRealSpinner_reparent), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "show", VALUEFUNC(_wrap_FXRealSpinner_show), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "hide", VALUEFUNC(_wrap_FXRealSpinner_hide), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "isComposite", VALUEFUNC(_wrap_FXRealSpinner_isComposite), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "contains", VALUEFUNC(_wrap_FXRealSpinner_contains), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXRealSpinner_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "setBackColor", VALUEFUNC(_wrap_FXRealSpinner_setBackColor), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "tr", VALUEFUNC(_wrap_FXRealSpinner_tr), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "dropEnable", VALUEFUNC(_wrap_FXRealSpinner_dropEnable), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "dropDisable", VALUEFUNC(_wrap_FXRealSpinner_dropDisable), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "setShape", VALUEFUNC(_wrap_FXRealSpinner_setShape), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "clearShape", VALUEFUNC(_wrap_FXRealSpinner_clearShape), -1);
+  rb_define_method(SwigClassFXRealSpinner.klass, "setValue", VALUEFUNC(_wrap_FXRealSpinner_setValue), -1);
+  SwigClassFXRealSpinner.mark = 0;
+  SwigClassFXRealSpinner.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXRealSpinner.trackObjects = 0;
+  
+  SwigClassFXCanvas.klass = rb_define_class_under(mFox, "FXCanvas", ((swig_class *) SWIGTYPE_p_FXWindow->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXCanvas, (void *) &SwigClassFXCanvas);
+  rb_define_alloc_func(SwigClassFXCanvas.klass, _wrap_FXCanvas_allocate);
+  rb_define_method(SwigClassFXCanvas.klass, "initialize", VALUEFUNC(_wrap_new_FXCanvas), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "onPaint", VALUEFUNC(_wrap_FXCanvas_onPaint), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "save", VALUEFUNC(_wrap_FXCanvas_save), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "load", VALUEFUNC(_wrap_FXCanvas_load), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "create", VALUEFUNC(_wrap_FXCanvas_create), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "detach", VALUEFUNC(_wrap_FXCanvas_detach), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "destroy", VALUEFUNC(_wrap_FXCanvas_destroy), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "resize", VALUEFUNC(_wrap_FXCanvas_resize), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXCanvas_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXCanvas_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXCanvas_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXCanvas_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "canFocus", VALUEFUNC(_wrap_FXCanvas_canFocus), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "setFocus", VALUEFUNC(_wrap_FXCanvas_setFocus), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "killFocus", VALUEFUNC(_wrap_FXCanvas_killFocus), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "changeFocus", VALUEFUNC(_wrap_FXCanvas_changeFocus), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "setDefault", VALUEFUNC(_wrap_FXCanvas_setDefault), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "enable", VALUEFUNC(_wrap_FXCanvas_enable), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "disable", VALUEFUNC(_wrap_FXCanvas_disable), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "raiseWindow", VALUEFUNC(_wrap_FXCanvas_raiseWindow), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "lower", VALUEFUNC(_wrap_FXCanvas_lower), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "move", VALUEFUNC(_wrap_FXCanvas_move), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "position", VALUEFUNC(_wrap_FXCanvas_position), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "layout", VALUEFUNC(_wrap_FXCanvas_layout), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "recalc", VALUEFUNC(_wrap_FXCanvas_recalc), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "reparent", VALUEFUNC(_wrap_FXCanvas_reparent), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "show", VALUEFUNC(_wrap_FXCanvas_show), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "hide", VALUEFUNC(_wrap_FXCanvas_hide), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "isComposite", VALUEFUNC(_wrap_FXCanvas_isComposite), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "contains", VALUEFUNC(_wrap_FXCanvas_contains), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXCanvas_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "setBackColor", VALUEFUNC(_wrap_FXCanvas_setBackColor), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "tr", VALUEFUNC(_wrap_FXCanvas_tr), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "dropEnable", VALUEFUNC(_wrap_FXCanvas_dropEnable), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "dropDisable", VALUEFUNC(_wrap_FXCanvas_dropDisable), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "setShape", VALUEFUNC(_wrap_FXCanvas_setShape), -1);
+  rb_define_method(SwigClassFXCanvas.klass, "clearShape", VALUEFUNC(_wrap_FXCanvas_clearShape), -1);
+  SwigClassFXCanvas.mark = (void (*)(void *)) FXRbCanvas::markfunc;
+  SwigClassFXCanvas.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXCanvas.trackObjects = 0;
+  
+  SWIGTYPE_p_FXCanvas->dcast = (swig_dycast_func) FXCanvas_dynamic_cast;
+  
+  rb_define_const(mFox, "TOOLTIP_PERMANENT", SWIG_From_int(static_cast< int >(TOOLTIP_PERMANENT)));
+  rb_define_const(mFox, "TOOLTIP_VARIABLE", SWIG_From_int(static_cast< int >(TOOLTIP_VARIABLE)));
+  rb_define_const(mFox, "TOOLTIP_NORMAL", SWIG_From_int(static_cast< int >(TOOLTIP_NORMAL)));
+  
+  SwigClassFXToolTip.klass = rb_define_class_under(mFox, "FXToolTip", ((swig_class *) SWIGTYPE_p_FXShell->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXToolTip, (void *) &SwigClassFXToolTip);
+  rb_define_alloc_func(SwigClassFXToolTip.klass, _wrap_FXToolTip_allocate);
+  rb_define_method(SwigClassFXToolTip.klass, "initialize", VALUEFUNC(_wrap_new_FXToolTip), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "onPaint", VALUEFUNC(_wrap_FXToolTip_onPaint), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "onUpdate", VALUEFUNC(_wrap_FXToolTip_onUpdate), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "onTipShow", VALUEFUNC(_wrap_FXToolTip_onTipShow), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "onTipHide", VALUEFUNC(_wrap_FXToolTip_onTipHide), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "onCmdGetStringValue", VALUEFUNC(_wrap_FXToolTip_onCmdGetStringValue), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "onCmdSetStringValue", VALUEFUNC(_wrap_FXToolTip_onCmdSetStringValue), -1);
+  rb_define_const(SwigClassFXToolTip.klass, "ID_TIP_SHOW", SWIG_From_int(static_cast< int >(FXToolTip::ID_TIP_SHOW)));
+  rb_define_const(SwigClassFXToolTip.klass, "ID_TIP_HIDE", SWIG_From_int(static_cast< int >(FXToolTip::ID_TIP_HIDE)));
+  rb_define_const(SwigClassFXToolTip.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXToolTip::ID_LAST)));
+  rb_define_method(SwigClassFXToolTip.klass, "setText", VALUEFUNC(_wrap_FXToolTip_setText), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "getText", VALUEFUNC(_wrap_FXToolTip_getText), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "setFont", VALUEFUNC(_wrap_FXToolTip_setFont), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "getFont", VALUEFUNC(_wrap_FXToolTip_getFont), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "getTextColor", VALUEFUNC(_wrap_FXToolTip_getTextColor), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "setTextColor", VALUEFUNC(_wrap_FXToolTip_setTextColor), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "save", VALUEFUNC(_wrap_FXToolTip_save), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "load", VALUEFUNC(_wrap_FXToolTip_load), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "create", VALUEFUNC(_wrap_FXToolTip_create), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "detach", VALUEFUNC(_wrap_FXToolTip_detach), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "destroy", VALUEFUNC(_wrap_FXToolTip_destroy), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "resize", VALUEFUNC(_wrap_FXToolTip_resize), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXToolTip_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXToolTip_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXToolTip_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXToolTip_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "canFocus", VALUEFUNC(_wrap_FXToolTip_canFocus), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "setFocus", VALUEFUNC(_wrap_FXToolTip_setFocus), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "killFocus", VALUEFUNC(_wrap_FXToolTip_killFocus), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "changeFocus", VALUEFUNC(_wrap_FXToolTip_changeFocus), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "setDefault", VALUEFUNC(_wrap_FXToolTip_setDefault), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "enable", VALUEFUNC(_wrap_FXToolTip_enable), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "disable", VALUEFUNC(_wrap_FXToolTip_disable), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "raiseWindow", VALUEFUNC(_wrap_FXToolTip_raiseWindow), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "lower", VALUEFUNC(_wrap_FXToolTip_lower), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "move", VALUEFUNC(_wrap_FXToolTip_move), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "position", VALUEFUNC(_wrap_FXToolTip_position), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "layout", VALUEFUNC(_wrap_FXToolTip_layout), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "recalc", VALUEFUNC(_wrap_FXToolTip_recalc), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "reparent", VALUEFUNC(_wrap_FXToolTip_reparent), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "show", VALUEFUNC(_wrap_FXToolTip_show), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "hide", VALUEFUNC(_wrap_FXToolTip_hide), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "isComposite", VALUEFUNC(_wrap_FXToolTip_isComposite), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "contains", VALUEFUNC(_wrap_FXToolTip_contains), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXToolTip_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "setBackColor", VALUEFUNC(_wrap_FXToolTip_setBackColor), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "tr", VALUEFUNC(_wrap_FXToolTip_tr), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "dropEnable", VALUEFUNC(_wrap_FXToolTip_dropEnable), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "dropDisable", VALUEFUNC(_wrap_FXToolTip_dropDisable), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "setShape", VALUEFUNC(_wrap_FXToolTip_setShape), -1);
+  rb_define_method(SwigClassFXToolTip.klass, "clearShape", VALUEFUNC(_wrap_FXToolTip_clearShape), -1);
+  SwigClassFXToolTip.mark = (void (*)(void *)) FXRbToolTip::markfunc;
+  SwigClassFXToolTip.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXToolTip.trackObjects = 0;
+  
+  SwigClassFXDockBar.klass = rb_define_class_under(mFox, "FXDockBar", ((swig_class *) SWIGTYPE_p_FXPacker->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXDockBar, (void *) &SwigClassFXDockBar);
+  rb_define_alloc_func(SwigClassFXDockBar.klass, _wrap_FXDockBar_allocate);
+  rb_define_method(SwigClassFXDockBar.klass, "initialize", VALUEFUNC(_wrap_new_FXDockBar), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "onCmdUndock", VALUEFUNC(_wrap_FXDockBar_onCmdUndock), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "onUpdUndock", VALUEFUNC(_wrap_FXDockBar_onUpdUndock), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "onCmdDockTop", VALUEFUNC(_wrap_FXDockBar_onCmdDockTop), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "onUpdDockTop", VALUEFUNC(_wrap_FXDockBar_onUpdDockTop), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "onCmdDockBottom", VALUEFUNC(_wrap_FXDockBar_onCmdDockBottom), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "onUpdDockBottom", VALUEFUNC(_wrap_FXDockBar_onUpdDockBottom), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "onCmdDockLeft", VALUEFUNC(_wrap_FXDockBar_onCmdDockLeft), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "onUpdDockLeft", VALUEFUNC(_wrap_FXDockBar_onUpdDockLeft), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "onCmdDockRight", VALUEFUNC(_wrap_FXDockBar_onCmdDockRight), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "onUpdDockRight", VALUEFUNC(_wrap_FXDockBar_onUpdDockRight), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "onUpdDockFlip", VALUEFUNC(_wrap_FXDockBar_onUpdDockFlip), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "onBeginDragGrip", VALUEFUNC(_wrap_FXDockBar_onBeginDragGrip), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "onEndDragGrip", VALUEFUNC(_wrap_FXDockBar_onEndDragGrip), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "onDraggedGrip", VALUEFUNC(_wrap_FXDockBar_onDraggedGrip), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "onPopupMenu", VALUEFUNC(_wrap_FXDockBar_onPopupMenu), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "onDockTimer", VALUEFUNC(_wrap_FXDockBar_onDockTimer), -1);
+  rb_define_const(SwigClassFXDockBar.klass, "ID_DOCK_FLOAT", SWIG_From_int(static_cast< int >(FXDockBar::ID_DOCK_FLOAT)));
+  rb_define_const(SwigClassFXDockBar.klass, "ID_DOCK_TOP", SWIG_From_int(static_cast< int >(FXDockBar::ID_DOCK_TOP)));
+  rb_define_const(SwigClassFXDockBar.klass, "ID_DOCK_BOTTOM", SWIG_From_int(static_cast< int >(FXDockBar::ID_DOCK_BOTTOM)));
+  rb_define_const(SwigClassFXDockBar.klass, "ID_DOCK_LEFT", SWIG_From_int(static_cast< int >(FXDockBar::ID_DOCK_LEFT)));
+  rb_define_const(SwigClassFXDockBar.klass, "ID_DOCK_RIGHT", SWIG_From_int(static_cast< int >(FXDockBar::ID_DOCK_RIGHT)));
+  rb_define_const(SwigClassFXDockBar.klass, "ID_DOCK_FLIP", SWIG_From_int(static_cast< int >(FXDockBar::ID_DOCK_FLIP)));
+  rb_define_const(SwigClassFXDockBar.klass, "ID_TOOLBARGRIP", SWIG_From_int(static_cast< int >(FXDockBar::ID_TOOLBARGRIP)));
+  rb_define_const(SwigClassFXDockBar.klass, "ID_TIMER", SWIG_From_int(static_cast< int >(FXDockBar::ID_TIMER)));
+  rb_define_const(SwigClassFXDockBar.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXDockBar::ID_LAST)));
+  rb_define_const(SwigClassFXDockBar.klass, "ALLOW_NOWHERE", SWIG_From_int(static_cast< int >(FXDockBar::ALLOW_NOWHERE)));
+  rb_define_const(SwigClassFXDockBar.klass, "ALLOW_TOP", SWIG_From_int(static_cast< int >(FXDockBar::ALLOW_TOP)));
+  rb_define_const(SwigClassFXDockBar.klass, "ALLOW_BOTTOM", SWIG_From_int(static_cast< int >(FXDockBar::ALLOW_BOTTOM)));
+  rb_define_const(SwigClassFXDockBar.klass, "ALLOW_LEFT", SWIG_From_int(static_cast< int >(FXDockBar::ALLOW_LEFT)));
+  rb_define_const(SwigClassFXDockBar.klass, "ALLOW_RIGHT", SWIG_From_int(static_cast< int >(FXDockBar::ALLOW_RIGHT)));
+  rb_define_const(SwigClassFXDockBar.klass, "ALLOW_HORIZONTAL", SWIG_From_int(static_cast< int >(FXDockBar::ALLOW_HORIZONTAL)));
+  rb_define_const(SwigClassFXDockBar.klass, "ALLOW_VERTICAL", SWIG_From_int(static_cast< int >(FXDockBar::ALLOW_VERTICAL)));
+  rb_define_const(SwigClassFXDockBar.klass, "ALLOW_EVERYWHERE", SWIG_From_int(static_cast< int >(FXDockBar::ALLOW_EVERYWHERE)));
+  rb_define_method(SwigClassFXDockBar.klass, "docked?", VALUEFUNC(_wrap_FXDockBar_dockedq___), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "insideDock?", VALUEFUNC(_wrap_FXDockBar_insideDockq___), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "dryDock=", VALUEFUNC(_wrap_FXDockBar_dryDocke___), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "wetDock=", VALUEFUNC(_wrap_FXDockBar_wetDocke___), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "dryDock", VALUEFUNC(_wrap_FXDockBar_dryDock), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "wetDock", VALUEFUNC(_wrap_FXDockBar_wetDock), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "findDockAtSide", VALUEFUNC(_wrap_FXDockBar_findDockAtSide), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "findDockNear", VALUEFUNC(_wrap_FXDockBar_findDockNear), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "allowedSides=", VALUEFUNC(_wrap_FXDockBar_allowedSidese___), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "allowedSides", VALUEFUNC(_wrap_FXDockBar_allowedSides), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "save", VALUEFUNC(_wrap_FXDockBar_save), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "load", VALUEFUNC(_wrap_FXDockBar_load), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "create", VALUEFUNC(_wrap_FXDockBar_create), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "detach", VALUEFUNC(_wrap_FXDockBar_detach), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "destroy", VALUEFUNC(_wrap_FXDockBar_destroy), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "resize", VALUEFUNC(_wrap_FXDockBar_resize), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXDockBar_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXDockBar_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXDockBar_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXDockBar_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "canFocus", VALUEFUNC(_wrap_FXDockBar_canFocus), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "setFocus", VALUEFUNC(_wrap_FXDockBar_setFocus), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "killFocus", VALUEFUNC(_wrap_FXDockBar_killFocus), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "changeFocus", VALUEFUNC(_wrap_FXDockBar_changeFocus), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "setDefault", VALUEFUNC(_wrap_FXDockBar_setDefault), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "enable", VALUEFUNC(_wrap_FXDockBar_enable), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "disable", VALUEFUNC(_wrap_FXDockBar_disable), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "raiseWindow", VALUEFUNC(_wrap_FXDockBar_raiseWindow), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "lower", VALUEFUNC(_wrap_FXDockBar_lower), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "move", VALUEFUNC(_wrap_FXDockBar_move), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "position", VALUEFUNC(_wrap_FXDockBar_position), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "layout", VALUEFUNC(_wrap_FXDockBar_layout), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "recalc", VALUEFUNC(_wrap_FXDockBar_recalc), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "reparent", VALUEFUNC(_wrap_FXDockBar_reparent), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "show", VALUEFUNC(_wrap_FXDockBar_show), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "hide", VALUEFUNC(_wrap_FXDockBar_hide), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "isComposite", VALUEFUNC(_wrap_FXDockBar_isComposite), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "contains", VALUEFUNC(_wrap_FXDockBar_contains), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXDockBar_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "setBackColor", VALUEFUNC(_wrap_FXDockBar_setBackColor), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "tr", VALUEFUNC(_wrap_FXDockBar_tr), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "dropEnable", VALUEFUNC(_wrap_FXDockBar_dropEnable), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "dropDisable", VALUEFUNC(_wrap_FXDockBar_dropDisable), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "setShape", VALUEFUNC(_wrap_FXDockBar_setShape), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "clearShape", VALUEFUNC(_wrap_FXDockBar_clearShape), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "dock", VALUEFUNC(_wrap_FXDockBar_dock), -1);
+  rb_define_method(SwigClassFXDockBar.klass, "undock", VALUEFUNC(_wrap_FXDockBar_undock), -1);
+  SwigClassFXDockBar.mark = (void (*)(void *)) FXRbDockBar::markfunc;
+  SwigClassFXDockBar.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXDockBar.trackObjects = 0;
+  
+  SWIGTYPE_p_FXDockBar->dcast = (swig_dycast_func) FXDockBar_dynamic_cast;
+  
+  
+  SwigClassFXToolBar.klass = rb_define_class_under(mFox, "FXToolBar", ((swig_class *) SWIGTYPE_p_FXDockBar->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXToolBar, (void *) &SwigClassFXToolBar);
+  rb_define_alloc_func(SwigClassFXToolBar.klass, _wrap_FXToolBar_allocate);
+  rb_define_method(SwigClassFXToolBar.klass, "initialize", VALUEFUNC(_wrap_new_FXToolBar), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "onCmdDockFlip", VALUEFUNC(_wrap_FXToolBar_onCmdDockFlip), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "onUpdDockFlip", VALUEFUNC(_wrap_FXToolBar_onUpdDockFlip), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "dockingSide=", VALUEFUNC(_wrap_FXToolBar_dockingSidee___), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "dockingSide", VALUEFUNC(_wrap_FXToolBar_dockingSide), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "save", VALUEFUNC(_wrap_FXToolBar_save), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "load", VALUEFUNC(_wrap_FXToolBar_load), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "create", VALUEFUNC(_wrap_FXToolBar_create), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "detach", VALUEFUNC(_wrap_FXToolBar_detach), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "destroy", VALUEFUNC(_wrap_FXToolBar_destroy), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "resize", VALUEFUNC(_wrap_FXToolBar_resize), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXToolBar_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXToolBar_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXToolBar_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXToolBar_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "canFocus", VALUEFUNC(_wrap_FXToolBar_canFocus), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "setFocus", VALUEFUNC(_wrap_FXToolBar_setFocus), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "killFocus", VALUEFUNC(_wrap_FXToolBar_killFocus), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "changeFocus", VALUEFUNC(_wrap_FXToolBar_changeFocus), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "setDefault", VALUEFUNC(_wrap_FXToolBar_setDefault), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "enable", VALUEFUNC(_wrap_FXToolBar_enable), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "disable", VALUEFUNC(_wrap_FXToolBar_disable), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "raiseWindow", VALUEFUNC(_wrap_FXToolBar_raiseWindow), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "lower", VALUEFUNC(_wrap_FXToolBar_lower), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "move", VALUEFUNC(_wrap_FXToolBar_move), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "position", VALUEFUNC(_wrap_FXToolBar_position), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "layout", VALUEFUNC(_wrap_FXToolBar_layout), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "recalc", VALUEFUNC(_wrap_FXToolBar_recalc), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "reparent", VALUEFUNC(_wrap_FXToolBar_reparent), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "show", VALUEFUNC(_wrap_FXToolBar_show), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "hide", VALUEFUNC(_wrap_FXToolBar_hide), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "isComposite", VALUEFUNC(_wrap_FXToolBar_isComposite), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "contains", VALUEFUNC(_wrap_FXToolBar_contains), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXToolBar_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "setBackColor", VALUEFUNC(_wrap_FXToolBar_setBackColor), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "tr", VALUEFUNC(_wrap_FXToolBar_tr), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "dropEnable", VALUEFUNC(_wrap_FXToolBar_dropEnable), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "dropDisable", VALUEFUNC(_wrap_FXToolBar_dropDisable), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "setShape", VALUEFUNC(_wrap_FXToolBar_setShape), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "clearShape", VALUEFUNC(_wrap_FXToolBar_clearShape), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "dock", VALUEFUNC(_wrap_FXToolBar_dock), -1);
+  rb_define_method(SwigClassFXToolBar.klass, "undock", VALUEFUNC(_wrap_FXToolBar_undock), -1);
+  SwigClassFXToolBar.mark = (void (*)(void *)) FXRbToolBar::markfunc;
+  SwigClassFXToolBar.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXToolBar.trackObjects = 0;
+  rb_define_const(mFox, "TABBOOK_TOPTABS", SWIG_From_int(static_cast< int >(TABBOOK_TOPTABS)));
+  rb_define_const(mFox, "TABBOOK_BOTTOMTABS", SWIG_From_int(static_cast< int >(TABBOOK_BOTTOMTABS)));
+  rb_define_const(mFox, "TABBOOK_SIDEWAYS", SWIG_From_int(static_cast< int >(TABBOOK_SIDEWAYS)));
+  rb_define_const(mFox, "TABBOOK_LEFTTABS", SWIG_From_int(static_cast< int >(TABBOOK_LEFTTABS)));
+  rb_define_const(mFox, "TABBOOK_RIGHTTABS", SWIG_From_int(static_cast< int >(TABBOOK_RIGHTTABS)));
+  rb_define_const(mFox, "TABBOOK_NORMAL", SWIG_From_int(static_cast< int >(TABBOOK_NORMAL)));
+  
+  SwigClassFXTabBar.klass = rb_define_class_under(mFox, "FXTabBar", ((swig_class *) SWIGTYPE_p_FXPacker->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXTabBar, (void *) &SwigClassFXTabBar);
+  rb_define_alloc_func(SwigClassFXTabBar.klass, _wrap_FXTabBar_allocate);
+  rb_define_method(SwigClassFXTabBar.klass, "initialize", VALUEFUNC(_wrap_new_FXTabBar), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "onPaint", VALUEFUNC(_wrap_FXTabBar_onPaint), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "onFocusNext", VALUEFUNC(_wrap_FXTabBar_onFocusNext), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "onFocusPrev", VALUEFUNC(_wrap_FXTabBar_onFocusPrev), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "onFocusUp", VALUEFUNC(_wrap_FXTabBar_onFocusUp), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "onFocusDown", VALUEFUNC(_wrap_FXTabBar_onFocusDown), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "onFocusLeft", VALUEFUNC(_wrap_FXTabBar_onFocusLeft), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "onFocusRight", VALUEFUNC(_wrap_FXTabBar_onFocusRight), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "onCmdOpenItem", VALUEFUNC(_wrap_FXTabBar_onCmdOpenItem), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXTabBar_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXTabBar_onCmdSetIntValue), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXTabBar_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "onCmdOpen", VALUEFUNC(_wrap_FXTabBar_onCmdOpen), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "onUpdOpen", VALUEFUNC(_wrap_FXTabBar_onUpdOpen), -1);
+  rb_define_const(SwigClassFXTabBar.klass, "ID_OPEN_ITEM", SWIG_From_int(static_cast< int >(FXTabBar::ID_OPEN_ITEM)));
+  rb_define_const(SwigClassFXTabBar.klass, "ID_OPEN_FIRST", SWIG_From_int(static_cast< int >(FXTabBar::ID_OPEN_FIRST)));
+  rb_define_const(SwigClassFXTabBar.klass, "ID_OPEN_SECOND", SWIG_From_int(static_cast< int >(FXTabBar::ID_OPEN_SECOND)));
+  rb_define_const(SwigClassFXTabBar.klass, "ID_OPEN_THIRD", SWIG_From_int(static_cast< int >(FXTabBar::ID_OPEN_THIRD)));
+  rb_define_const(SwigClassFXTabBar.klass, "ID_OPEN_FOURTH", SWIG_From_int(static_cast< int >(FXTabBar::ID_OPEN_FOURTH)));
+  rb_define_const(SwigClassFXTabBar.klass, "ID_OPEN_FIFTH", SWIG_From_int(static_cast< int >(FXTabBar::ID_OPEN_FIFTH)));
+  rb_define_const(SwigClassFXTabBar.klass, "ID_OPEN_SIXTH", SWIG_From_int(static_cast< int >(FXTabBar::ID_OPEN_SIXTH)));
+  rb_define_const(SwigClassFXTabBar.klass, "ID_OPEN_SEVENTH", SWIG_From_int(static_cast< int >(FXTabBar::ID_OPEN_SEVENTH)));
+  rb_define_const(SwigClassFXTabBar.klass, "ID_OPEN_EIGHTH", SWIG_From_int(static_cast< int >(FXTabBar::ID_OPEN_EIGHTH)));
+  rb_define_const(SwigClassFXTabBar.klass, "ID_OPEN_NINETH", SWIG_From_int(static_cast< int >(FXTabBar::ID_OPEN_NINETH)));
+  rb_define_const(SwigClassFXTabBar.klass, "ID_OPEN_TENTH", SWIG_From_int(static_cast< int >(FXTabBar::ID_OPEN_TENTH)));
+  rb_define_const(SwigClassFXTabBar.klass, "ID_OPEN_LAST", SWIG_From_int(static_cast< int >(FXTabBar::ID_OPEN_LAST)));
+  rb_define_const(SwigClassFXTabBar.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXTabBar::ID_LAST)));
+  rb_define_method(SwigClassFXTabBar.klass, "getCurrent", VALUEFUNC(_wrap_FXTabBar_getCurrent), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "getTabStyle", VALUEFUNC(_wrap_FXTabBar_getTabStyle), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "setTabStyle", VALUEFUNC(_wrap_FXTabBar_setTabStyle), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "save", VALUEFUNC(_wrap_FXTabBar_save), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "load", VALUEFUNC(_wrap_FXTabBar_load), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "create", VALUEFUNC(_wrap_FXTabBar_create), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "detach", VALUEFUNC(_wrap_FXTabBar_detach), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "destroy", VALUEFUNC(_wrap_FXTabBar_destroy), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "resize", VALUEFUNC(_wrap_FXTabBar_resize), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXTabBar_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXTabBar_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXTabBar_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXTabBar_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "canFocus", VALUEFUNC(_wrap_FXTabBar_canFocus), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "setFocus", VALUEFUNC(_wrap_FXTabBar_setFocus), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "killFocus", VALUEFUNC(_wrap_FXTabBar_killFocus), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "changeFocus", VALUEFUNC(_wrap_FXTabBar_changeFocus), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "setDefault", VALUEFUNC(_wrap_FXTabBar_setDefault), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "enable", VALUEFUNC(_wrap_FXTabBar_enable), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "disable", VALUEFUNC(_wrap_FXTabBar_disable), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "raiseWindow", VALUEFUNC(_wrap_FXTabBar_raiseWindow), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "lower", VALUEFUNC(_wrap_FXTabBar_lower), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "move", VALUEFUNC(_wrap_FXTabBar_move), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "position", VALUEFUNC(_wrap_FXTabBar_position), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "layout", VALUEFUNC(_wrap_FXTabBar_layout), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "recalc", VALUEFUNC(_wrap_FXTabBar_recalc), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "reparent", VALUEFUNC(_wrap_FXTabBar_reparent), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "show", VALUEFUNC(_wrap_FXTabBar_show), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "hide", VALUEFUNC(_wrap_FXTabBar_hide), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "isComposite", VALUEFUNC(_wrap_FXTabBar_isComposite), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "contains", VALUEFUNC(_wrap_FXTabBar_contains), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXTabBar_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "setBackColor", VALUEFUNC(_wrap_FXTabBar_setBackColor), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "tr", VALUEFUNC(_wrap_FXTabBar_tr), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "dropEnable", VALUEFUNC(_wrap_FXTabBar_dropEnable), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "dropDisable", VALUEFUNC(_wrap_FXTabBar_dropDisable), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "setShape", VALUEFUNC(_wrap_FXTabBar_setShape), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "clearShape", VALUEFUNC(_wrap_FXTabBar_clearShape), -1);
+  rb_define_method(SwigClassFXTabBar.klass, "setCurrent", VALUEFUNC(_wrap_FXTabBar_setCurrent), -1);
+  SwigClassFXTabBar.mark = (void (*)(void *)) FXRbTabBar::markfunc;
+  SwigClassFXTabBar.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXTabBar.trackObjects = 0;
+  
+  SWIGTYPE_p_FXTabBar->dcast = (swig_dycast_func) FXTabBar_dynamic_cast;
+  
+  
+  SwigClassFXTabBook.klass = rb_define_class_under(mFox, "FXTabBook", ((swig_class *) SWIGTYPE_p_FXTabBar->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXTabBook, (void *) &SwigClassFXTabBook);
+  rb_define_alloc_func(SwigClassFXTabBook.klass, _wrap_FXTabBook_allocate);
+  rb_define_method(SwigClassFXTabBook.klass, "initialize", VALUEFUNC(_wrap_new_FXTabBook), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "onPaint", VALUEFUNC(_wrap_FXTabBook_onPaint), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "onFocusNext", VALUEFUNC(_wrap_FXTabBook_onFocusNext), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "onFocusPrev", VALUEFUNC(_wrap_FXTabBook_onFocusPrev), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "onFocusUp", VALUEFUNC(_wrap_FXTabBook_onFocusUp), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "onFocusDown", VALUEFUNC(_wrap_FXTabBook_onFocusDown), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "onFocusLeft", VALUEFUNC(_wrap_FXTabBook_onFocusLeft), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "onFocusRight", VALUEFUNC(_wrap_FXTabBook_onFocusRight), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "onCmdOpenItem", VALUEFUNC(_wrap_FXTabBook_onCmdOpenItem), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "save", VALUEFUNC(_wrap_FXTabBook_save), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "load", VALUEFUNC(_wrap_FXTabBook_load), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "create", VALUEFUNC(_wrap_FXTabBook_create), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "detach", VALUEFUNC(_wrap_FXTabBook_detach), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "destroy", VALUEFUNC(_wrap_FXTabBook_destroy), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "resize", VALUEFUNC(_wrap_FXTabBook_resize), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXTabBook_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXTabBook_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXTabBook_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXTabBook_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "canFocus", VALUEFUNC(_wrap_FXTabBook_canFocus), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "setFocus", VALUEFUNC(_wrap_FXTabBook_setFocus), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "killFocus", VALUEFUNC(_wrap_FXTabBook_killFocus), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "changeFocus", VALUEFUNC(_wrap_FXTabBook_changeFocus), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "setDefault", VALUEFUNC(_wrap_FXTabBook_setDefault), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "enable", VALUEFUNC(_wrap_FXTabBook_enable), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "disable", VALUEFUNC(_wrap_FXTabBook_disable), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "raiseWindow", VALUEFUNC(_wrap_FXTabBook_raiseWindow), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "lower", VALUEFUNC(_wrap_FXTabBook_lower), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "move", VALUEFUNC(_wrap_FXTabBook_move), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "position", VALUEFUNC(_wrap_FXTabBook_position), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "layout", VALUEFUNC(_wrap_FXTabBook_layout), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "recalc", VALUEFUNC(_wrap_FXTabBook_recalc), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "reparent", VALUEFUNC(_wrap_FXTabBook_reparent), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "show", VALUEFUNC(_wrap_FXTabBook_show), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "hide", VALUEFUNC(_wrap_FXTabBook_hide), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "isComposite", VALUEFUNC(_wrap_FXTabBook_isComposite), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "contains", VALUEFUNC(_wrap_FXTabBook_contains), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXTabBook_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "setBackColor", VALUEFUNC(_wrap_FXTabBook_setBackColor), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "tr", VALUEFUNC(_wrap_FXTabBook_tr), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "dropEnable", VALUEFUNC(_wrap_FXTabBook_dropEnable), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "dropDisable", VALUEFUNC(_wrap_FXTabBook_dropDisable), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "setShape", VALUEFUNC(_wrap_FXTabBook_setShape), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "clearShape", VALUEFUNC(_wrap_FXTabBook_clearShape), -1);
+  rb_define_method(SwigClassFXTabBook.klass, "setCurrent", VALUEFUNC(_wrap_FXTabBook_setCurrent), -1);
+  SwigClassFXTabBook.mark = (void (*)(void *)) FXRbTabBook::markfunc;
+  SwigClassFXTabBook.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXTabBook.trackObjects = 0;
+  rb_define_const(mFox, "SCROLLBAR_VERTICAL", SWIG_From_int(static_cast< int >(SCROLLBAR_VERTICAL)));
+  rb_define_const(mFox, "SCROLLBAR_HORIZONTAL", SWIG_From_int(static_cast< int >(SCROLLBAR_HORIZONTAL)));
+  rb_define_const(mFox, "SCROLLBAR_WHEELJUMP", SWIG_From_int(static_cast< int >(SCROLLBAR_WHEELJUMP)));
+  
+  SwigClassFXScrollBar.klass = rb_define_class_under(mFox, "FXScrollBar", ((swig_class *) SWIGTYPE_p_FXWindow->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXScrollBar, (void *) &SwigClassFXScrollBar);
+  rb_define_alloc_func(SwigClassFXScrollBar.klass, _wrap_FXScrollBar_allocate);
+  rb_define_method(SwigClassFXScrollBar.klass, "initialize", VALUEFUNC(_wrap_new_FXScrollBar), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "onPaint", VALUEFUNC(_wrap_FXScrollBar_onPaint), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "onMotion", VALUEFUNC(_wrap_FXScrollBar_onMotion), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "onMouseWheel", VALUEFUNC(_wrap_FXScrollBar_onMouseWheel), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXScrollBar_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXScrollBar_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "onMiddleBtnPress", VALUEFUNC(_wrap_FXScrollBar_onMiddleBtnPress), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "onMiddleBtnRelease", VALUEFUNC(_wrap_FXScrollBar_onMiddleBtnRelease), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "onRightBtnPress", VALUEFUNC(_wrap_FXScrollBar_onRightBtnPress), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "onRightBtnRelease", VALUEFUNC(_wrap_FXScrollBar_onRightBtnRelease), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "onUngrabbed", VALUEFUNC(_wrap_FXScrollBar_onUngrabbed), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "onTimeWheel", VALUEFUNC(_wrap_FXScrollBar_onTimeWheel), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "onAutoScroll", VALUEFUNC(_wrap_FXScrollBar_onAutoScroll), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXScrollBar_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXScrollBar_onCmdSetIntValue), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXScrollBar_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "onCmdSetIntRange", VALUEFUNC(_wrap_FXScrollBar_onCmdSetIntRange), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "onCmdGetIntRange", VALUEFUNC(_wrap_FXScrollBar_onCmdGetIntRange), -1);
+  rb_define_const(SwigClassFXScrollBar.klass, "ID_TIMEWHEEL", SWIG_From_int(static_cast< int >(FXScrollBar::ID_TIMEWHEEL)));
+  rb_define_const(SwigClassFXScrollBar.klass, "ID_AUTOSCROLL", SWIG_From_int(static_cast< int >(FXScrollBar::ID_AUTOSCROLL)));
+  rb_define_const(SwigClassFXScrollBar.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXScrollBar::ID_LAST)));
+  rb_define_method(SwigClassFXScrollBar.klass, "setRange", VALUEFUNC(_wrap_FXScrollBar_setRange), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "getRange", VALUEFUNC(_wrap_FXScrollBar_getRange), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "setPage", VALUEFUNC(_wrap_FXScrollBar_setPage), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "getPage", VALUEFUNC(_wrap_FXScrollBar_getPage), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "setLine", VALUEFUNC(_wrap_FXScrollBar_setLine), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "getLine", VALUEFUNC(_wrap_FXScrollBar_getLine), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "setPosition", VALUEFUNC(_wrap_FXScrollBar_setPosition), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "setHiliteColor", VALUEFUNC(_wrap_FXScrollBar_setHiliteColor), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "getHiliteColor", VALUEFUNC(_wrap_FXScrollBar_getHiliteColor), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "setShadowColor", VALUEFUNC(_wrap_FXScrollBar_setShadowColor), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "getShadowColor", VALUEFUNC(_wrap_FXScrollBar_getShadowColor), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "getBorderColor", VALUEFUNC(_wrap_FXScrollBar_getBorderColor), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "setBorderColor", VALUEFUNC(_wrap_FXScrollBar_setBorderColor), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "getScrollBarStyle", VALUEFUNC(_wrap_FXScrollBar_getScrollBarStyle), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "setScrollBarStyle", VALUEFUNC(_wrap_FXScrollBar_setScrollBarStyle), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "barSize=", VALUEFUNC(_wrap_FXScrollBar_barSizee___), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "barSize", VALUEFUNC(_wrap_FXScrollBar_barSize), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "save", VALUEFUNC(_wrap_FXScrollBar_save), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "load", VALUEFUNC(_wrap_FXScrollBar_load), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "create", VALUEFUNC(_wrap_FXScrollBar_create), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "detach", VALUEFUNC(_wrap_FXScrollBar_detach), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "destroy", VALUEFUNC(_wrap_FXScrollBar_destroy), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "resize", VALUEFUNC(_wrap_FXScrollBar_resize), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXScrollBar_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXScrollBar_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXScrollBar_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXScrollBar_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "canFocus", VALUEFUNC(_wrap_FXScrollBar_canFocus), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "setFocus", VALUEFUNC(_wrap_FXScrollBar_setFocus), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "killFocus", VALUEFUNC(_wrap_FXScrollBar_killFocus), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "changeFocus", VALUEFUNC(_wrap_FXScrollBar_changeFocus), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "setDefault", VALUEFUNC(_wrap_FXScrollBar_setDefault), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "enable", VALUEFUNC(_wrap_FXScrollBar_enable), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "disable", VALUEFUNC(_wrap_FXScrollBar_disable), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "raiseWindow", VALUEFUNC(_wrap_FXScrollBar_raiseWindow), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "lower", VALUEFUNC(_wrap_FXScrollBar_lower), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "move", VALUEFUNC(_wrap_FXScrollBar_move), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "position", VALUEFUNC(_wrap_FXScrollBar_position), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "layout", VALUEFUNC(_wrap_FXScrollBar_layout), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "recalc", VALUEFUNC(_wrap_FXScrollBar_recalc), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "reparent", VALUEFUNC(_wrap_FXScrollBar_reparent), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "show", VALUEFUNC(_wrap_FXScrollBar_show), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "hide", VALUEFUNC(_wrap_FXScrollBar_hide), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "isComposite", VALUEFUNC(_wrap_FXScrollBar_isComposite), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "contains", VALUEFUNC(_wrap_FXScrollBar_contains), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXScrollBar_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "setBackColor", VALUEFUNC(_wrap_FXScrollBar_setBackColor), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "tr", VALUEFUNC(_wrap_FXScrollBar_tr), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "dropEnable", VALUEFUNC(_wrap_FXScrollBar_dropEnable), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "dropDisable", VALUEFUNC(_wrap_FXScrollBar_dropDisable), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "setShape", VALUEFUNC(_wrap_FXScrollBar_setShape), -1);
+  rb_define_method(SwigClassFXScrollBar.klass, "clearShape", VALUEFUNC(_wrap_FXScrollBar_clearShape), -1);
+  SwigClassFXScrollBar.mark = (void (*)(void *)) FXRbScrollBar::markfunc;
+  SwigClassFXScrollBar.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXScrollBar.trackObjects = 0;
+  
+  SwigClassFXScrollCorner.klass = rb_define_class_under(mFox, "FXScrollCorner", ((swig_class *) SWIGTYPE_p_FXWindow->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXScrollCorner, (void *) &SwigClassFXScrollCorner);
+  rb_define_alloc_func(SwigClassFXScrollCorner.klass, _wrap_FXScrollCorner_allocate);
+  rb_define_method(SwigClassFXScrollCorner.klass, "initialize", VALUEFUNC(_wrap_new_FXScrollCorner), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "onPaint", VALUEFUNC(_wrap_FXScrollCorner_onPaint), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "save", VALUEFUNC(_wrap_FXScrollCorner_save), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "load", VALUEFUNC(_wrap_FXScrollCorner_load), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "create", VALUEFUNC(_wrap_FXScrollCorner_create), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "detach", VALUEFUNC(_wrap_FXScrollCorner_detach), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "destroy", VALUEFUNC(_wrap_FXScrollCorner_destroy), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "resize", VALUEFUNC(_wrap_FXScrollCorner_resize), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXScrollCorner_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXScrollCorner_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXScrollCorner_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXScrollCorner_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "canFocus", VALUEFUNC(_wrap_FXScrollCorner_canFocus), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "setFocus", VALUEFUNC(_wrap_FXScrollCorner_setFocus), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "killFocus", VALUEFUNC(_wrap_FXScrollCorner_killFocus), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "changeFocus", VALUEFUNC(_wrap_FXScrollCorner_changeFocus), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "setDefault", VALUEFUNC(_wrap_FXScrollCorner_setDefault), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "enable", VALUEFUNC(_wrap_FXScrollCorner_enable), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "disable", VALUEFUNC(_wrap_FXScrollCorner_disable), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "raiseWindow", VALUEFUNC(_wrap_FXScrollCorner_raiseWindow), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "lower", VALUEFUNC(_wrap_FXScrollCorner_lower), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "move", VALUEFUNC(_wrap_FXScrollCorner_move), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "position", VALUEFUNC(_wrap_FXScrollCorner_position), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "layout", VALUEFUNC(_wrap_FXScrollCorner_layout), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "recalc", VALUEFUNC(_wrap_FXScrollCorner_recalc), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "reparent", VALUEFUNC(_wrap_FXScrollCorner_reparent), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "show", VALUEFUNC(_wrap_FXScrollCorner_show), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "hide", VALUEFUNC(_wrap_FXScrollCorner_hide), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "isComposite", VALUEFUNC(_wrap_FXScrollCorner_isComposite), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "contains", VALUEFUNC(_wrap_FXScrollCorner_contains), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXScrollCorner_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "setBackColor", VALUEFUNC(_wrap_FXScrollCorner_setBackColor), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "tr", VALUEFUNC(_wrap_FXScrollCorner_tr), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "dropEnable", VALUEFUNC(_wrap_FXScrollCorner_dropEnable), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "dropDisable", VALUEFUNC(_wrap_FXScrollCorner_dropDisable), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "setShape", VALUEFUNC(_wrap_FXScrollCorner_setShape), -1);
+  rb_define_method(SwigClassFXScrollCorner.klass, "clearShape", VALUEFUNC(_wrap_FXScrollCorner_clearShape), -1);
+  SwigClassFXScrollCorner.mark = (void (*)(void *)) FXRbScrollCorner::markfunc;
+  SwigClassFXScrollCorner.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXScrollCorner.trackObjects = 0;
+  rb_define_const(mFox, "COMBOBOX_NO_REPLACE", SWIG_From_int(static_cast< int >(COMBOBOX_NO_REPLACE)));
+  rb_define_const(mFox, "COMBOBOX_REPLACE", SWIG_From_int(static_cast< int >(COMBOBOX_REPLACE)));
+  rb_define_const(mFox, "COMBOBOX_INSERT_BEFORE", SWIG_From_int(static_cast< int >(COMBOBOX_INSERT_BEFORE)));
+  rb_define_const(mFox, "COMBOBOX_INSERT_AFTER", SWIG_From_int(static_cast< int >(COMBOBOX_INSERT_AFTER)));
+  rb_define_const(mFox, "COMBOBOX_INSERT_FIRST", SWIG_From_int(static_cast< int >(COMBOBOX_INSERT_FIRST)));
+  rb_define_const(mFox, "COMBOBOX_INSERT_LAST", SWIG_From_int(static_cast< int >(COMBOBOX_INSERT_LAST)));
+  rb_define_const(mFox, "COMBOBOX_STATIC", SWIG_From_int(static_cast< int >(COMBOBOX_STATIC)));
+  rb_define_const(mFox, "COMBOBOX_NORMAL", SWIG_From_int(static_cast< int >(COMBOBOX_NORMAL)));
+  
+  SwigClassFXComboBox.klass = rb_define_class_under(mFox, "FXComboBox", ((swig_class *) SWIGTYPE_p_FXPacker->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXComboBox, (void *) &SwigClassFXComboBox);
+  rb_define_alloc_func(SwigClassFXComboBox.klass, _wrap_FXComboBox_allocate);
+  rb_define_method(SwigClassFXComboBox.klass, "initialize", VALUEFUNC(_wrap_new_FXComboBox), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "onFocusUp", VALUEFUNC(_wrap_FXComboBox_onFocusUp), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "onFocusDown", VALUEFUNC(_wrap_FXComboBox_onFocusDown), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "onFocusSelf", VALUEFUNC(_wrap_FXComboBox_onFocusSelf), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "onMouseWheel", VALUEFUNC(_wrap_FXComboBox_onMouseWheel), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "onTextButton", VALUEFUNC(_wrap_FXComboBox_onTextButton), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "onTextChanged", VALUEFUNC(_wrap_FXComboBox_onTextChanged), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "onTextCommand", VALUEFUNC(_wrap_FXComboBox_onTextCommand), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "onListClicked", VALUEFUNC(_wrap_FXComboBox_onListClicked), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "onFwdToText", VALUEFUNC(_wrap_FXComboBox_onFwdToText), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "onUpdFmText", VALUEFUNC(_wrap_FXComboBox_onUpdFmText), -1);
+  rb_define_const(SwigClassFXComboBox.klass, "ID_LIST", SWIG_From_int(static_cast< int >(FXComboBox::ID_LIST)));
+  rb_define_const(SwigClassFXComboBox.klass, "ID_TEXT", SWIG_From_int(static_cast< int >(FXComboBox::ID_TEXT)));
+  rb_define_const(SwigClassFXComboBox.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXComboBox::ID_LAST)));
+  rb_define_method(SwigClassFXComboBox.klass, "isEditable", VALUEFUNC(_wrap_FXComboBox_isEditable), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "setEditable", VALUEFUNC(_wrap_FXComboBox_setEditable), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "setText", VALUEFUNC(_wrap_FXComboBox_setText), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "getText", VALUEFUNC(_wrap_FXComboBox_getText), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "setNumColumns", VALUEFUNC(_wrap_FXComboBox_setNumColumns), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "getNumColumns", VALUEFUNC(_wrap_FXComboBox_getNumColumns), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "justify=", VALUEFUNC(_wrap_FXComboBox_justifye___), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "justify", VALUEFUNC(_wrap_FXComboBox_justify), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "getNumItems", VALUEFUNC(_wrap_FXComboBox_getNumItems), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "getNumVisible", VALUEFUNC(_wrap_FXComboBox_getNumVisible), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "setNumVisible", VALUEFUNC(_wrap_FXComboBox_setNumVisible), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "isItemCurrent", VALUEFUNC(_wrap_FXComboBox_isItemCurrent), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "setCurrentItem", VALUEFUNC(_wrap_FXComboBox_setCurrentItem), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "getCurrentItem", VALUEFUNC(_wrap_FXComboBox_getCurrentItem), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "getItem", VALUEFUNC(_wrap_FXComboBox_getItem), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "setItem", VALUEFUNC(_wrap_FXComboBox_setItem), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "fillItems", VALUEFUNC(_wrap_FXComboBox_fillItems), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "insertItem", VALUEFUNC(_wrap_FXComboBox_insertItem), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "appendItem", VALUEFUNC(_wrap_FXComboBox_appendItem), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "prependItem", VALUEFUNC(_wrap_FXComboBox_prependItem), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "moveItem", VALUEFUNC(_wrap_FXComboBox_moveItem), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "removeItem", VALUEFUNC(_wrap_FXComboBox_removeItem), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "clearItems", VALUEFUNC(_wrap_FXComboBox_clearItems), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "findItem", VALUEFUNC(_wrap_FXComboBox_findItem), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "findItemByData", VALUEFUNC(_wrap_FXComboBox_findItemByData), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "setItemText", VALUEFUNC(_wrap_FXComboBox_setItemText), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "getItemText", VALUEFUNC(_wrap_FXComboBox_getItemText), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "setItemData", VALUEFUNC(_wrap_FXComboBox_setItemData), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "getItemData", VALUEFUNC(_wrap_FXComboBox_getItemData), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "isPaneShown", VALUEFUNC(_wrap_FXComboBox_isPaneShown), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "sortItems", VALUEFUNC(_wrap_FXComboBox_sortItems), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "setFont", VALUEFUNC(_wrap_FXComboBox_setFont), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "getFont", VALUEFUNC(_wrap_FXComboBox_getFont), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "setComboStyle", VALUEFUNC(_wrap_FXComboBox_setComboStyle), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "getComboStyle", VALUEFUNC(_wrap_FXComboBox_getComboStyle), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "getBackColor", VALUEFUNC(_wrap_FXComboBox_getBackColor), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "setTextColor", VALUEFUNC(_wrap_FXComboBox_setTextColor), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "getTextColor", VALUEFUNC(_wrap_FXComboBox_getTextColor), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "setSelBackColor", VALUEFUNC(_wrap_FXComboBox_setSelBackColor), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "getSelBackColor", VALUEFUNC(_wrap_FXComboBox_getSelBackColor), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "setSelTextColor", VALUEFUNC(_wrap_FXComboBox_setSelTextColor), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "getSelTextColor", VALUEFUNC(_wrap_FXComboBox_getSelTextColor), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "setHelpText", VALUEFUNC(_wrap_FXComboBox_setHelpText), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "getHelpText", VALUEFUNC(_wrap_FXComboBox_getHelpText), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "setTipText", VALUEFUNC(_wrap_FXComboBox_setTipText), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "getTipText", VALUEFUNC(_wrap_FXComboBox_getTipText), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "save", VALUEFUNC(_wrap_FXComboBox_save), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "load", VALUEFUNC(_wrap_FXComboBox_load), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "create", VALUEFUNC(_wrap_FXComboBox_create), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "detach", VALUEFUNC(_wrap_FXComboBox_detach), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "destroy", VALUEFUNC(_wrap_FXComboBox_destroy), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "resize", VALUEFUNC(_wrap_FXComboBox_resize), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXComboBox_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXComboBox_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXComboBox_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXComboBox_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "canFocus", VALUEFUNC(_wrap_FXComboBox_canFocus), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "setFocus", VALUEFUNC(_wrap_FXComboBox_setFocus), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "killFocus", VALUEFUNC(_wrap_FXComboBox_killFocus), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "changeFocus", VALUEFUNC(_wrap_FXComboBox_changeFocus), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "setDefault", VALUEFUNC(_wrap_FXComboBox_setDefault), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "enable", VALUEFUNC(_wrap_FXComboBox_enable), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "disable", VALUEFUNC(_wrap_FXComboBox_disable), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "raiseWindow", VALUEFUNC(_wrap_FXComboBox_raiseWindow), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "lower", VALUEFUNC(_wrap_FXComboBox_lower), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "move", VALUEFUNC(_wrap_FXComboBox_move), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "position", VALUEFUNC(_wrap_FXComboBox_position), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "layout", VALUEFUNC(_wrap_FXComboBox_layout), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "recalc", VALUEFUNC(_wrap_FXComboBox_recalc), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "reparent", VALUEFUNC(_wrap_FXComboBox_reparent), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "show", VALUEFUNC(_wrap_FXComboBox_show), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "hide", VALUEFUNC(_wrap_FXComboBox_hide), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "isComposite", VALUEFUNC(_wrap_FXComboBox_isComposite), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "contains", VALUEFUNC(_wrap_FXComboBox_contains), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXComboBox_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "setBackColor", VALUEFUNC(_wrap_FXComboBox_setBackColor), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "tr", VALUEFUNC(_wrap_FXComboBox_tr), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "dropEnable", VALUEFUNC(_wrap_FXComboBox_dropEnable), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "dropDisable", VALUEFUNC(_wrap_FXComboBox_dropDisable), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "setShape", VALUEFUNC(_wrap_FXComboBox_setShape), -1);
+  rb_define_method(SwigClassFXComboBox.klass, "clearShape", VALUEFUNC(_wrap_FXComboBox_clearShape), -1);
+  SwigClassFXComboBox.mark = (void (*)(void *)) FXRbComboBox::markfunc;
+  SwigClassFXComboBox.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXComboBox.trackObjects = 0;
+  rb_define_const(mFox, "LISTBOX_NORMAL", SWIG_From_int(static_cast< int >(LISTBOX_NORMAL)));
+  
+  SwigClassFXListBox.klass = rb_define_class_under(mFox, "FXListBox", ((swig_class *) SWIGTYPE_p_FXPacker->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXListBox, (void *) &SwigClassFXListBox);
+  rb_define_alloc_func(SwigClassFXListBox.klass, _wrap_FXListBox_allocate);
+  rb_define_method(SwigClassFXListBox.klass, "initialize", VALUEFUNC(_wrap_new_FXListBox), -1);
+  rb_define_method(SwigClassFXListBox.klass, "onFocusUp", VALUEFUNC(_wrap_FXListBox_onFocusUp), -1);
+  rb_define_method(SwigClassFXListBox.klass, "onFocusDown", VALUEFUNC(_wrap_FXListBox_onFocusDown), -1);
+  rb_define_method(SwigClassFXListBox.klass, "onFocusSelf", VALUEFUNC(_wrap_FXListBox_onFocusSelf), -1);
+  rb_define_method(SwigClassFXListBox.klass, "onMouseWheel", VALUEFUNC(_wrap_FXListBox_onMouseWheel), -1);
+  rb_define_method(SwigClassFXListBox.klass, "onFieldButton", VALUEFUNC(_wrap_FXListBox_onFieldButton), -1);
+  rb_define_method(SwigClassFXListBox.klass, "onListUpdate", VALUEFUNC(_wrap_FXListBox_onListUpdate), -1);
+  rb_define_method(SwigClassFXListBox.klass, "onListClicked", VALUEFUNC(_wrap_FXListBox_onListClicked), -1);
+  rb_define_method(SwigClassFXListBox.klass, "onListChanged", VALUEFUNC(_wrap_FXListBox_onListChanged), -1);
+  rb_define_method(SwigClassFXListBox.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXListBox_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXListBox.klass, "onCmdGetIntValue", VALUEFUNC(_wrap_FXListBox_onCmdGetIntValue), -1);
+  rb_define_method(SwigClassFXListBox.klass, "onCmdSetIntValue", VALUEFUNC(_wrap_FXListBox_onCmdSetIntValue), -1);
+  rb_define_const(SwigClassFXListBox.klass, "ID_LIST", SWIG_From_int(static_cast< int >(FXListBox::ID_LIST)));
+  rb_define_const(SwigClassFXListBox.klass, "ID_FIELD", SWIG_From_int(static_cast< int >(FXListBox::ID_FIELD)));
+  rb_define_const(SwigClassFXListBox.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXListBox::ID_LAST)));
+  rb_define_method(SwigClassFXListBox.klass, "getNumItems", VALUEFUNC(_wrap_FXListBox_getNumItems), -1);
+  rb_define_method(SwigClassFXListBox.klass, "getNumVisible", VALUEFUNC(_wrap_FXListBox_getNumVisible), -1);
+  rb_define_method(SwigClassFXListBox.klass, "setNumVisible", VALUEFUNC(_wrap_FXListBox_setNumVisible), -1);
+  rb_define_method(SwigClassFXListBox.klass, "isItemCurrent", VALUEFUNC(_wrap_FXListBox_isItemCurrent), -1);
+  rb_define_method(SwigClassFXListBox.klass, "getCurrentItem", VALUEFUNC(_wrap_FXListBox_getCurrentItem), -1);
+  rb_define_method(SwigClassFXListBox.klass, "getItem", VALUEFUNC(_wrap_FXListBox_getItem), -1);
+  rb_define_method(SwigClassFXListBox.klass, "setItem", VALUEFUNC(_wrap_FXListBox_setItem), -1);
+  rb_define_method(SwigClassFXListBox.klass, "fillItems", VALUEFUNC(_wrap_FXListBox_fillItems), -1);
+  rb_define_method(SwigClassFXListBox.klass, "insertItem", VALUEFUNC(_wrap_FXListBox_insertItem), -1);
+  rb_define_method(SwigClassFXListBox.klass, "appendItem", VALUEFUNC(_wrap_FXListBox_appendItem), -1);
+  rb_define_alias(SwigClassFXListBox.klass, "<<", "appendItem");
+  rb_define_method(SwigClassFXListBox.klass, "prependItem", VALUEFUNC(_wrap_FXListBox_prependItem), -1);
+  rb_define_method(SwigClassFXListBox.klass, "moveItem", VALUEFUNC(_wrap_FXListBox_moveItem), -1);
+  rb_define_method(SwigClassFXListBox.klass, "extractItem", VALUEFUNC(_wrap_FXListBox_extractItem), -1);
+  rb_define_method(SwigClassFXListBox.klass, "removeItem", VALUEFUNC(_wrap_FXListBox_removeItem), -1);
+  rb_define_method(SwigClassFXListBox.klass, "clearItems", VALUEFUNC(_wrap_FXListBox_clearItems), -1);
+  rb_define_method(SwigClassFXListBox.klass, "findItem", VALUEFUNC(_wrap_FXListBox_findItem), -1);
+  rb_define_method(SwigClassFXListBox.klass, "findItemByData", VALUEFUNC(_wrap_FXListBox_findItemByData), -1);
+  rb_define_method(SwigClassFXListBox.klass, "setItemText", VALUEFUNC(_wrap_FXListBox_setItemText), -1);
+  rb_define_method(SwigClassFXListBox.klass, "getItemText", VALUEFUNC(_wrap_FXListBox_getItemText), -1);
+  rb_define_method(SwigClassFXListBox.klass, "setItemIcon", VALUEFUNC(_wrap_FXListBox_setItemIcon), -1);
+  rb_define_method(SwigClassFXListBox.klass, "getItemIcon", VALUEFUNC(_wrap_FXListBox_getItemIcon), -1);
+  rb_define_method(SwigClassFXListBox.klass, "setItemData", VALUEFUNC(_wrap_FXListBox_setItemData), -1);
+  rb_define_method(SwigClassFXListBox.klass, "getItemData", VALUEFUNC(_wrap_FXListBox_getItemData), -1);
+  rb_define_method(SwigClassFXListBox.klass, "isPaneShown", VALUEFUNC(_wrap_FXListBox_isPaneShown), -1);
+  rb_define_method(SwigClassFXListBox.klass, "sortItems", VALUEFUNC(_wrap_FXListBox_sortItems), -1);
+  rb_define_method(SwigClassFXListBox.klass, "setFont", VALUEFUNC(_wrap_FXListBox_setFont), -1);
+  rb_define_method(SwigClassFXListBox.klass, "getFont", VALUEFUNC(_wrap_FXListBox_getFont), -1);
+  rb_define_method(SwigClassFXListBox.klass, "getBackColor", VALUEFUNC(_wrap_FXListBox_getBackColor), -1);
+  rb_define_method(SwigClassFXListBox.klass, "setTextColor", VALUEFUNC(_wrap_FXListBox_setTextColor), -1);
+  rb_define_method(SwigClassFXListBox.klass, "getTextColor", VALUEFUNC(_wrap_FXListBox_getTextColor), -1);
+  rb_define_method(SwigClassFXListBox.klass, "setSelBackColor", VALUEFUNC(_wrap_FXListBox_setSelBackColor), -1);
+  rb_define_method(SwigClassFXListBox.klass, "getSelBackColor", VALUEFUNC(_wrap_FXListBox_getSelBackColor), -1);
+  rb_define_method(SwigClassFXListBox.klass, "setSelTextColor", VALUEFUNC(_wrap_FXListBox_setSelTextColor), -1);
+  rb_define_method(SwigClassFXListBox.klass, "getSelTextColor", VALUEFUNC(_wrap_FXListBox_getSelTextColor), -1);
+  rb_define_method(SwigClassFXListBox.klass, "setHelpText", VALUEFUNC(_wrap_FXListBox_setHelpText), -1);
+  rb_define_method(SwigClassFXListBox.klass, "getHelpText", VALUEFUNC(_wrap_FXListBox_getHelpText), -1);
+  rb_define_method(SwigClassFXListBox.klass, "setTipText", VALUEFUNC(_wrap_FXListBox_setTipText), -1);
+  rb_define_method(SwigClassFXListBox.klass, "getTipText", VALUEFUNC(_wrap_FXListBox_getTipText), -1);
+  rb_define_method(SwigClassFXListBox.klass, "save", VALUEFUNC(_wrap_FXListBox_save), -1);
+  rb_define_method(SwigClassFXListBox.klass, "load", VALUEFUNC(_wrap_FXListBox_load), -1);
+  rb_define_method(SwigClassFXListBox.klass, "create", VALUEFUNC(_wrap_FXListBox_create), -1);
+  rb_define_method(SwigClassFXListBox.klass, "detach", VALUEFUNC(_wrap_FXListBox_detach), -1);
+  rb_define_method(SwigClassFXListBox.klass, "destroy", VALUEFUNC(_wrap_FXListBox_destroy), -1);
+  rb_define_method(SwigClassFXListBox.klass, "resize", VALUEFUNC(_wrap_FXListBox_resize), -1);
+  rb_define_method(SwigClassFXListBox.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXListBox_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXListBox.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXListBox_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXListBox.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXListBox_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXListBox.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXListBox_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXListBox.klass, "canFocus", VALUEFUNC(_wrap_FXListBox_canFocus), -1);
+  rb_define_method(SwigClassFXListBox.klass, "setFocus", VALUEFUNC(_wrap_FXListBox_setFocus), -1);
+  rb_define_method(SwigClassFXListBox.klass, "killFocus", VALUEFUNC(_wrap_FXListBox_killFocus), -1);
+  rb_define_method(SwigClassFXListBox.klass, "changeFocus", VALUEFUNC(_wrap_FXListBox_changeFocus), -1);
+  rb_define_method(SwigClassFXListBox.klass, "setDefault", VALUEFUNC(_wrap_FXListBox_setDefault), -1);
+  rb_define_method(SwigClassFXListBox.klass, "enable", VALUEFUNC(_wrap_FXListBox_enable), -1);
+  rb_define_method(SwigClassFXListBox.klass, "disable", VALUEFUNC(_wrap_FXListBox_disable), -1);
+  rb_define_method(SwigClassFXListBox.klass, "raiseWindow", VALUEFUNC(_wrap_FXListBox_raiseWindow), -1);
+  rb_define_method(SwigClassFXListBox.klass, "lower", VALUEFUNC(_wrap_FXListBox_lower), -1);
+  rb_define_method(SwigClassFXListBox.klass, "move", VALUEFUNC(_wrap_FXListBox_move), -1);
+  rb_define_method(SwigClassFXListBox.klass, "position", VALUEFUNC(_wrap_FXListBox_position), -1);
+  rb_define_method(SwigClassFXListBox.klass, "layout", VALUEFUNC(_wrap_FXListBox_layout), -1);
+  rb_define_method(SwigClassFXListBox.klass, "recalc", VALUEFUNC(_wrap_FXListBox_recalc), -1);
+  rb_define_method(SwigClassFXListBox.klass, "reparent", VALUEFUNC(_wrap_FXListBox_reparent), -1);
+  rb_define_method(SwigClassFXListBox.klass, "show", VALUEFUNC(_wrap_FXListBox_show), -1);
+  rb_define_method(SwigClassFXListBox.klass, "hide", VALUEFUNC(_wrap_FXListBox_hide), -1);
+  rb_define_method(SwigClassFXListBox.klass, "isComposite", VALUEFUNC(_wrap_FXListBox_isComposite), -1);
+  rb_define_method(SwigClassFXListBox.klass, "contains", VALUEFUNC(_wrap_FXListBox_contains), -1);
+  rb_define_method(SwigClassFXListBox.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXListBox_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXListBox.klass, "setBackColor", VALUEFUNC(_wrap_FXListBox_setBackColor), -1);
+  rb_define_method(SwigClassFXListBox.klass, "tr", VALUEFUNC(_wrap_FXListBox_tr), -1);
+  rb_define_method(SwigClassFXListBox.klass, "dropEnable", VALUEFUNC(_wrap_FXListBox_dropEnable), -1);
+  rb_define_method(SwigClassFXListBox.klass, "dropDisable", VALUEFUNC(_wrap_FXListBox_dropDisable), -1);
+  rb_define_method(SwigClassFXListBox.klass, "setShape", VALUEFUNC(_wrap_FXListBox_setShape), -1);
+  rb_define_method(SwigClassFXListBox.klass, "clearShape", VALUEFUNC(_wrap_FXListBox_clearShape), -1);
+  rb_define_method(SwigClassFXListBox.klass, "setCurrentItem", VALUEFUNC(_wrap_FXListBox_setCurrentItem), -1);
+  SwigClassFXListBox.mark = (void (*)(void *)) FXRbListBox::markfunc;
+  SwigClassFXListBox.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXListBox.trackObjects = 0;
+  
+  SWIGTYPE_p_FXListBox->dcast = (swig_dycast_func) FXListBox_dynamic_cast;
+  
+  rb_define_const(mFox, "TREELISTBOX_NORMAL", SWIG_From_int(static_cast< int >(TREELISTBOX_NORMAL)));
+  
+  SwigClassFXTreeListBox.klass = rb_define_class_under(mFox, "FXTreeListBox", ((swig_class *) SWIGTYPE_p_FXPacker->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXTreeListBox, (void *) &SwigClassFXTreeListBox);
+  rb_define_alloc_func(SwigClassFXTreeListBox.klass, _wrap_FXTreeListBox_allocate);
+  rb_define_method(SwigClassFXTreeListBox.klass, "initialize", VALUEFUNC(_wrap_new_FXTreeListBox), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "onFocusUp", VALUEFUNC(_wrap_FXTreeListBox_onFocusUp), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "onFocusDown", VALUEFUNC(_wrap_FXTreeListBox_onFocusDown), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "onFocusSelf", VALUEFUNC(_wrap_FXTreeListBox_onFocusSelf), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "onMouseWheel", VALUEFUNC(_wrap_FXTreeListBox_onMouseWheel), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "onFieldButton", VALUEFUNC(_wrap_FXTreeListBox_onFieldButton), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "onTreeUpdate", VALUEFUNC(_wrap_FXTreeListBox_onTreeUpdate), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "onTreeChanged", VALUEFUNC(_wrap_FXTreeListBox_onTreeChanged), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "onTreeClicked", VALUEFUNC(_wrap_FXTreeListBox_onTreeClicked), -1);
+  rb_define_const(SwigClassFXTreeListBox.klass, "ID_TREE", SWIG_From_int(static_cast< int >(FXTreeListBox::ID_TREE)));
+  rb_define_const(SwigClassFXTreeListBox.klass, "ID_FIELD", SWIG_From_int(static_cast< int >(FXTreeListBox::ID_FIELD)));
+  rb_define_const(SwigClassFXTreeListBox.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXTreeListBox::ID_LAST)));
+  rb_define_method(SwigClassFXTreeListBox.klass, "getNumItems", VALUEFUNC(_wrap_FXTreeListBox_getNumItems), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "getNumVisible", VALUEFUNC(_wrap_FXTreeListBox_getNumVisible), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "setNumVisible", VALUEFUNC(_wrap_FXTreeListBox_setNumVisible), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "getFirstItem", VALUEFUNC(_wrap_FXTreeListBox_getFirstItem), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "getLastItem", VALUEFUNC(_wrap_FXTreeListBox_getLastItem), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "fillItems", VALUEFUNC(_wrap_FXTreeListBox_fillItems), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "insertItem", VALUEFUNC(_wrap_FXTreeListBox_insertItem), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "appendItem", VALUEFUNC(_wrap_FXTreeListBox_appendItem), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "prependItem", VALUEFUNC(_wrap_FXTreeListBox_prependItem), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "removeItem", VALUEFUNC(_wrap_FXTreeListBox_removeItem), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "removeItems", VALUEFUNC(_wrap_FXTreeListBox_removeItems), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "clearItems", VALUEFUNC(_wrap_FXTreeListBox_clearItems), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "moveItem", VALUEFUNC(_wrap_FXTreeListBox_moveItem), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "extractItem", VALUEFUNC(_wrap_FXTreeListBox_extractItem), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "findItem", VALUEFUNC(_wrap_FXTreeListBox_findItem), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "findItemByData", VALUEFUNC(_wrap_FXTreeListBox_findItemByData), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "isItemCurrent", VALUEFUNC(_wrap_FXTreeListBox_isItemCurrent), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "isItemLeaf", VALUEFUNC(_wrap_FXTreeListBox_isItemLeaf), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "sortRootItems", VALUEFUNC(_wrap_FXTreeListBox_sortRootItems), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "sortItems", VALUEFUNC(_wrap_FXTreeListBox_sortItems), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "sortChildItems", VALUEFUNC(_wrap_FXTreeListBox_sortChildItems), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "getCurrentItem", VALUEFUNC(_wrap_FXTreeListBox_getCurrentItem), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "setItemText", VALUEFUNC(_wrap_FXTreeListBox_setItemText), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "getItemText", VALUEFUNC(_wrap_FXTreeListBox_getItemText), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "setItemOpenIcon", VALUEFUNC(_wrap_FXTreeListBox_setItemOpenIcon), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "getItemOpenIcon", VALUEFUNC(_wrap_FXTreeListBox_getItemOpenIcon), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "setItemClosedIcon", VALUEFUNC(_wrap_FXTreeListBox_setItemClosedIcon), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "getItemClosedIcon", VALUEFUNC(_wrap_FXTreeListBox_getItemClosedIcon), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "setItemData", VALUEFUNC(_wrap_FXTreeListBox_setItemData), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "getItemData", VALUEFUNC(_wrap_FXTreeListBox_getItemData), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "isPaneShown", VALUEFUNC(_wrap_FXTreeListBox_isPaneShown), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "setFont", VALUEFUNC(_wrap_FXTreeListBox_setFont), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "getFont", VALUEFUNC(_wrap_FXTreeListBox_getFont), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "getListStyle", VALUEFUNC(_wrap_FXTreeListBox_getListStyle), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "setListStyle", VALUEFUNC(_wrap_FXTreeListBox_setListStyle), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "setHelpText", VALUEFUNC(_wrap_FXTreeListBox_setHelpText), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "getHelpText", VALUEFUNC(_wrap_FXTreeListBox_getHelpText), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "setTipText", VALUEFUNC(_wrap_FXTreeListBox_setTipText), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "getTipText", VALUEFUNC(_wrap_FXTreeListBox_getTipText), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "save", VALUEFUNC(_wrap_FXTreeListBox_save), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "load", VALUEFUNC(_wrap_FXTreeListBox_load), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "create", VALUEFUNC(_wrap_FXTreeListBox_create), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "detach", VALUEFUNC(_wrap_FXTreeListBox_detach), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "destroy", VALUEFUNC(_wrap_FXTreeListBox_destroy), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "resize", VALUEFUNC(_wrap_FXTreeListBox_resize), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXTreeListBox_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXTreeListBox_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXTreeListBox_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXTreeListBox_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "canFocus", VALUEFUNC(_wrap_FXTreeListBox_canFocus), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "setFocus", VALUEFUNC(_wrap_FXTreeListBox_setFocus), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "killFocus", VALUEFUNC(_wrap_FXTreeListBox_killFocus), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "changeFocus", VALUEFUNC(_wrap_FXTreeListBox_changeFocus), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "setDefault", VALUEFUNC(_wrap_FXTreeListBox_setDefault), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "enable", VALUEFUNC(_wrap_FXTreeListBox_enable), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "disable", VALUEFUNC(_wrap_FXTreeListBox_disable), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "raiseWindow", VALUEFUNC(_wrap_FXTreeListBox_raiseWindow), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "lower", VALUEFUNC(_wrap_FXTreeListBox_lower), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "move", VALUEFUNC(_wrap_FXTreeListBox_move), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "position", VALUEFUNC(_wrap_FXTreeListBox_position), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "layout", VALUEFUNC(_wrap_FXTreeListBox_layout), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "recalc", VALUEFUNC(_wrap_FXTreeListBox_recalc), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "reparent", VALUEFUNC(_wrap_FXTreeListBox_reparent), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "show", VALUEFUNC(_wrap_FXTreeListBox_show), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "hide", VALUEFUNC(_wrap_FXTreeListBox_hide), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "isComposite", VALUEFUNC(_wrap_FXTreeListBox_isComposite), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "contains", VALUEFUNC(_wrap_FXTreeListBox_contains), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXTreeListBox_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "setBackColor", VALUEFUNC(_wrap_FXTreeListBox_setBackColor), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "tr", VALUEFUNC(_wrap_FXTreeListBox_tr), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "dropEnable", VALUEFUNC(_wrap_FXTreeListBox_dropEnable), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "dropDisable", VALUEFUNC(_wrap_FXTreeListBox_dropDisable), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "setShape", VALUEFUNC(_wrap_FXTreeListBox_setShape), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "clearShape", VALUEFUNC(_wrap_FXTreeListBox_clearShape), -1);
+  rb_define_method(SwigClassFXTreeListBox.klass, "setCurrentItem", VALUEFUNC(_wrap_FXTreeListBox_setCurrentItem), -1);
+  SwigClassFXTreeListBox.mark = (void (*)(void *)) FXRbTreeListBox::markfunc;
+  SwigClassFXTreeListBox.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXTreeListBox.trackObjects = 0;
+  
+  SWIGTYPE_p_FXTreeListBox->dcast = (swig_dycast_func) FXTreeListBox_dynamic_cast;
+  
+  rb_define_const(mFox, "IMAGEVIEW_NORMAL", SWIG_From_int(static_cast< int >(IMAGEVIEW_NORMAL)));
+  rb_define_const(mFox, "IMAGEVIEW_CENTER_X", SWIG_From_int(static_cast< int >(IMAGEVIEW_CENTER_X)));
+  rb_define_const(mFox, "IMAGEVIEW_LEFT", SWIG_From_int(static_cast< int >(IMAGEVIEW_LEFT)));
+  rb_define_const(mFox, "IMAGEVIEW_RIGHT", SWIG_From_int(static_cast< int >(IMAGEVIEW_RIGHT)));
+  rb_define_const(mFox, "IMAGEVIEW_CENTER_Y", SWIG_From_int(static_cast< int >(IMAGEVIEW_CENTER_Y)));
+  rb_define_const(mFox, "IMAGEVIEW_TOP", SWIG_From_int(static_cast< int >(IMAGEVIEW_TOP)));
+  rb_define_const(mFox, "IMAGEVIEW_BOTTOM", SWIG_From_int(static_cast< int >(IMAGEVIEW_BOTTOM)));
+  
+  SwigClassFXImageView.klass = rb_define_class_under(mFox, "FXImageView", ((swig_class *) SWIGTYPE_p_FXScrollArea->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXImageView, (void *) &SwigClassFXImageView);
+  rb_define_alloc_func(SwigClassFXImageView.klass, _wrap_FXImageView_allocate);
+  rb_define_method(SwigClassFXImageView.klass, "initialize", VALUEFUNC(_wrap_new_FXImageView), -1);
+  rb_define_method(SwigClassFXImageView.klass, "onPaint", VALUEFUNC(_wrap_FXImageView_onPaint), -1);
+  rb_define_method(SwigClassFXImageView.klass, "onMotion", VALUEFUNC(_wrap_FXImageView_onMotion), -1);
+  rb_define_method(SwigClassFXImageView.klass, "onRightBtnPress", VALUEFUNC(_wrap_FXImageView_onRightBtnPress), -1);
+  rb_define_method(SwigClassFXImageView.klass, "onRightBtnRelease", VALUEFUNC(_wrap_FXImageView_onRightBtnRelease), -1);
+  rb_define_const(SwigClassFXImageView.klass, "ID_XYZ", SWIG_From_int(static_cast< int >(FXImageView::ID_XYZ)));
+  rb_define_const(SwigClassFXImageView.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXImageView::ID_LAST)));
+  rb_define_method(SwigClassFXImageView.klass, "setImage", VALUEFUNC(_wrap_FXImageView_setImage), -1);
+  rb_define_method(SwigClassFXImageView.klass, "getImage", VALUEFUNC(_wrap_FXImageView_getImage), -1);
+  rb_define_method(SwigClassFXImageView.klass, "setAlignment", VALUEFUNC(_wrap_FXImageView_setAlignment), -1);
+  rb_define_method(SwigClassFXImageView.klass, "getAlignment", VALUEFUNC(_wrap_FXImageView_getAlignment), -1);
+  rb_define_method(SwigClassFXImageView.klass, "save", VALUEFUNC(_wrap_FXImageView_save), -1);
+  rb_define_method(SwigClassFXImageView.klass, "load", VALUEFUNC(_wrap_FXImageView_load), -1);
+  rb_define_method(SwigClassFXImageView.klass, "create", VALUEFUNC(_wrap_FXImageView_create), -1);
+  rb_define_method(SwigClassFXImageView.klass, "detach", VALUEFUNC(_wrap_FXImageView_detach), -1);
+  rb_define_method(SwigClassFXImageView.klass, "destroy", VALUEFUNC(_wrap_FXImageView_destroy), -1);
+  rb_define_method(SwigClassFXImageView.klass, "resize", VALUEFUNC(_wrap_FXImageView_resize), -1);
+  rb_define_method(SwigClassFXImageView.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXImageView_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXImageView.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXImageView_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXImageView.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXImageView_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXImageView.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXImageView_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXImageView.klass, "canFocus", VALUEFUNC(_wrap_FXImageView_canFocus), -1);
+  rb_define_method(SwigClassFXImageView.klass, "setFocus", VALUEFUNC(_wrap_FXImageView_setFocus), -1);
+  rb_define_method(SwigClassFXImageView.klass, "killFocus", VALUEFUNC(_wrap_FXImageView_killFocus), -1);
+  rb_define_method(SwigClassFXImageView.klass, "changeFocus", VALUEFUNC(_wrap_FXImageView_changeFocus), -1);
+  rb_define_method(SwigClassFXImageView.klass, "setDefault", VALUEFUNC(_wrap_FXImageView_setDefault), -1);
+  rb_define_method(SwigClassFXImageView.klass, "enable", VALUEFUNC(_wrap_FXImageView_enable), -1);
+  rb_define_method(SwigClassFXImageView.klass, "disable", VALUEFUNC(_wrap_FXImageView_disable), -1);
+  rb_define_method(SwigClassFXImageView.klass, "raiseWindow", VALUEFUNC(_wrap_FXImageView_raiseWindow), -1);
+  rb_define_method(SwigClassFXImageView.klass, "lower", VALUEFUNC(_wrap_FXImageView_lower), -1);
+  rb_define_method(SwigClassFXImageView.klass, "move", VALUEFUNC(_wrap_FXImageView_move), -1);
+  rb_define_method(SwigClassFXImageView.klass, "layout", VALUEFUNC(_wrap_FXImageView_layout), -1);
+  rb_define_method(SwigClassFXImageView.klass, "recalc", VALUEFUNC(_wrap_FXImageView_recalc), -1);
+  rb_define_method(SwigClassFXImageView.klass, "reparent", VALUEFUNC(_wrap_FXImageView_reparent), -1);
+  rb_define_method(SwigClassFXImageView.klass, "show", VALUEFUNC(_wrap_FXImageView_show), -1);
+  rb_define_method(SwigClassFXImageView.klass, "hide", VALUEFUNC(_wrap_FXImageView_hide), -1);
+  rb_define_method(SwigClassFXImageView.klass, "isComposite", VALUEFUNC(_wrap_FXImageView_isComposite), -1);
+  rb_define_method(SwigClassFXImageView.klass, "contains", VALUEFUNC(_wrap_FXImageView_contains), -1);
+  rb_define_method(SwigClassFXImageView.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXImageView_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXImageView.klass, "setBackColor", VALUEFUNC(_wrap_FXImageView_setBackColor), -1);
+  rb_define_method(SwigClassFXImageView.klass, "tr", VALUEFUNC(_wrap_FXImageView_tr), -1);
+  rb_define_method(SwigClassFXImageView.klass, "dropEnable", VALUEFUNC(_wrap_FXImageView_dropEnable), -1);
+  rb_define_method(SwigClassFXImageView.klass, "dropDisable", VALUEFUNC(_wrap_FXImageView_dropDisable), -1);
+  rb_define_method(SwigClassFXImageView.klass, "setShape", VALUEFUNC(_wrap_FXImageView_setShape), -1);
+  rb_define_method(SwigClassFXImageView.klass, "clearShape", VALUEFUNC(_wrap_FXImageView_clearShape), -1);
+  rb_define_method(SwigClassFXImageView.klass, "getViewportHeight", VALUEFUNC(_wrap_FXImageView_getViewportHeight), -1);
+  rb_define_method(SwigClassFXImageView.klass, "getViewportWidth", VALUEFUNC(_wrap_FXImageView_getViewportWidth), -1);
+  rb_define_method(SwigClassFXImageView.klass, "getContentHeight", VALUEFUNC(_wrap_FXImageView_getContentHeight), -1);
+  rb_define_method(SwigClassFXImageView.klass, "getContentWidth", VALUEFUNC(_wrap_FXImageView_getContentWidth), -1);
+  rb_define_method(SwigClassFXImageView.klass, "position", VALUEFUNC(_wrap_FXImageView_position), -1);
+  SwigClassFXImageView.mark = (void (*)(void *)) FXRbImageView::markfunc;
+  SwigClassFXImageView.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXImageView.trackObjects = 0;
+  
+  SwigClassFXDragCorner.klass = rb_define_class_under(mFox, "FXDragCorner", ((swig_class *) SWIGTYPE_p_FXWindow->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXDragCorner, (void *) &SwigClassFXDragCorner);
+  rb_define_alloc_func(SwigClassFXDragCorner.klass, _wrap_FXDragCorner_allocate);
+  rb_define_method(SwigClassFXDragCorner.klass, "initialize", VALUEFUNC(_wrap_new_FXDragCorner), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "onPaint", VALUEFUNC(_wrap_FXDragCorner_onPaint), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXDragCorner_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXDragCorner_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "onMotion", VALUEFUNC(_wrap_FXDragCorner_onMotion), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "setHiliteColor", VALUEFUNC(_wrap_FXDragCorner_setHiliteColor), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "getHiliteColor", VALUEFUNC(_wrap_FXDragCorner_getHiliteColor), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "setShadowColor", VALUEFUNC(_wrap_FXDragCorner_setShadowColor), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "getShadowColor", VALUEFUNC(_wrap_FXDragCorner_getShadowColor), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "save", VALUEFUNC(_wrap_FXDragCorner_save), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "load", VALUEFUNC(_wrap_FXDragCorner_load), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "create", VALUEFUNC(_wrap_FXDragCorner_create), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "detach", VALUEFUNC(_wrap_FXDragCorner_detach), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "destroy", VALUEFUNC(_wrap_FXDragCorner_destroy), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "resize", VALUEFUNC(_wrap_FXDragCorner_resize), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXDragCorner_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXDragCorner_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXDragCorner_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXDragCorner_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "canFocus", VALUEFUNC(_wrap_FXDragCorner_canFocus), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "setFocus", VALUEFUNC(_wrap_FXDragCorner_setFocus), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "killFocus", VALUEFUNC(_wrap_FXDragCorner_killFocus), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "changeFocus", VALUEFUNC(_wrap_FXDragCorner_changeFocus), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "setDefault", VALUEFUNC(_wrap_FXDragCorner_setDefault), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "enable", VALUEFUNC(_wrap_FXDragCorner_enable), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "disable", VALUEFUNC(_wrap_FXDragCorner_disable), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "raiseWindow", VALUEFUNC(_wrap_FXDragCorner_raiseWindow), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "lower", VALUEFUNC(_wrap_FXDragCorner_lower), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "move", VALUEFUNC(_wrap_FXDragCorner_move), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "position", VALUEFUNC(_wrap_FXDragCorner_position), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "layout", VALUEFUNC(_wrap_FXDragCorner_layout), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "recalc", VALUEFUNC(_wrap_FXDragCorner_recalc), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "reparent", VALUEFUNC(_wrap_FXDragCorner_reparent), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "show", VALUEFUNC(_wrap_FXDragCorner_show), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "hide", VALUEFUNC(_wrap_FXDragCorner_hide), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "isComposite", VALUEFUNC(_wrap_FXDragCorner_isComposite), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "contains", VALUEFUNC(_wrap_FXDragCorner_contains), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXDragCorner_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "setBackColor", VALUEFUNC(_wrap_FXDragCorner_setBackColor), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "tr", VALUEFUNC(_wrap_FXDragCorner_tr), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "dropEnable", VALUEFUNC(_wrap_FXDragCorner_dropEnable), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "dropDisable", VALUEFUNC(_wrap_FXDragCorner_dropDisable), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "setShape", VALUEFUNC(_wrap_FXDragCorner_setShape), -1);
+  rb_define_method(SwigClassFXDragCorner.klass, "clearShape", VALUEFUNC(_wrap_FXDragCorner_clearShape), -1);
+  SwigClassFXDragCorner.mark = (void (*)(void *)) FXRbDragCorner::markfunc;
+  SwigClassFXDragCorner.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXDragCorner.trackObjects = 0;
+  rb_define_const(mFox, "DIRBOX_NO_OWN_ASSOC", SWIG_From_int(static_cast< int >(DIRBOX_NO_OWN_ASSOC)));
+  
+  SwigClassFXDirBox.klass = rb_define_class_under(mFox, "FXDirBox", ((swig_class *) SWIGTYPE_p_FXTreeListBox->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXDirBox, (void *) &SwigClassFXDirBox);
+  rb_define_alloc_func(SwigClassFXDirBox.klass, _wrap_FXDirBox_allocate);
+  rb_define_method(SwigClassFXDirBox.klass, "initialize", VALUEFUNC(_wrap_new_FXDirBox), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "onTreeChanged", VALUEFUNC(_wrap_FXDirBox_onTreeChanged), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "onTreeClicked", VALUEFUNC(_wrap_FXDirBox_onTreeClicked), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXDirBox_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "onCmdSetStringValue", VALUEFUNC(_wrap_FXDirBox_onCmdSetStringValue), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "onCmdGetStringValue", VALUEFUNC(_wrap_FXDirBox_onCmdGetStringValue), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "setDirectory", VALUEFUNC(_wrap_FXDirBox_setDirectory), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "getDirectory", VALUEFUNC(_wrap_FXDirBox_getDirectory), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "setAssociations", VALUEFUNC(_wrap_FXDirBox_setAssociations), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "getAssociations", VALUEFUNC(_wrap_FXDirBox_getAssociations), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "save", VALUEFUNC(_wrap_FXDirBox_save), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "load", VALUEFUNC(_wrap_FXDirBox_load), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "create", VALUEFUNC(_wrap_FXDirBox_create), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "detach", VALUEFUNC(_wrap_FXDirBox_detach), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "destroy", VALUEFUNC(_wrap_FXDirBox_destroy), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "resize", VALUEFUNC(_wrap_FXDirBox_resize), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXDirBox_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXDirBox_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXDirBox_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXDirBox_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "canFocus", VALUEFUNC(_wrap_FXDirBox_canFocus), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "setFocus", VALUEFUNC(_wrap_FXDirBox_setFocus), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "killFocus", VALUEFUNC(_wrap_FXDirBox_killFocus), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "changeFocus", VALUEFUNC(_wrap_FXDirBox_changeFocus), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "setDefault", VALUEFUNC(_wrap_FXDirBox_setDefault), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "enable", VALUEFUNC(_wrap_FXDirBox_enable), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "disable", VALUEFUNC(_wrap_FXDirBox_disable), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "raiseWindow", VALUEFUNC(_wrap_FXDirBox_raiseWindow), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "lower", VALUEFUNC(_wrap_FXDirBox_lower), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "move", VALUEFUNC(_wrap_FXDirBox_move), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "position", VALUEFUNC(_wrap_FXDirBox_position), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "layout", VALUEFUNC(_wrap_FXDirBox_layout), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "recalc", VALUEFUNC(_wrap_FXDirBox_recalc), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "reparent", VALUEFUNC(_wrap_FXDirBox_reparent), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "show", VALUEFUNC(_wrap_FXDirBox_show), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "hide", VALUEFUNC(_wrap_FXDirBox_hide), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "isComposite", VALUEFUNC(_wrap_FXDirBox_isComposite), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "contains", VALUEFUNC(_wrap_FXDirBox_contains), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXDirBox_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "setBackColor", VALUEFUNC(_wrap_FXDirBox_setBackColor), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "tr", VALUEFUNC(_wrap_FXDirBox_tr), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "dropEnable", VALUEFUNC(_wrap_FXDirBox_dropEnable), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "dropDisable", VALUEFUNC(_wrap_FXDirBox_dropDisable), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "setShape", VALUEFUNC(_wrap_FXDirBox_setShape), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "clearShape", VALUEFUNC(_wrap_FXDirBox_clearShape), -1);
+  rb_define_method(SwigClassFXDirBox.klass, "setCurrentItem", VALUEFUNC(_wrap_FXDirBox_setCurrentItem), -1);
+  SwigClassFXDirBox.mark = (void (*)(void *)) FXRbDirBox::markfunc;
+  SwigClassFXDirBox.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXDirBox.trackObjects = 0;
+  
+  SwigClassFXDriveBox.klass = rb_define_class_under(mFox, "FXDriveBox", ((swig_class *) SWIGTYPE_p_FXListBox->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXDriveBox, (void *) &SwigClassFXDriveBox);
+  rb_define_alloc_func(SwigClassFXDriveBox.klass, _wrap_FXDriveBox_allocate);
+  rb_define_method(SwigClassFXDriveBox.klass, "initialize", VALUEFUNC(_wrap_new_FXDriveBox), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "onListChanged", VALUEFUNC(_wrap_FXDriveBox_onListChanged), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "onListClicked", VALUEFUNC(_wrap_FXDriveBox_onListClicked), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXDriveBox_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "onCmdSetStringValue", VALUEFUNC(_wrap_FXDriveBox_onCmdSetStringValue), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "onCmdGetStringValue", VALUEFUNC(_wrap_FXDriveBox_onCmdGetStringValue), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "setDrive", VALUEFUNC(_wrap_FXDriveBox_setDrive), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "getDrive", VALUEFUNC(_wrap_FXDriveBox_getDrive), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "setAssociations", VALUEFUNC(_wrap_FXDriveBox_setAssociations), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "getAssociations", VALUEFUNC(_wrap_FXDriveBox_getAssociations), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "save", VALUEFUNC(_wrap_FXDriveBox_save), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "load", VALUEFUNC(_wrap_FXDriveBox_load), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "create", VALUEFUNC(_wrap_FXDriveBox_create), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "detach", VALUEFUNC(_wrap_FXDriveBox_detach), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "destroy", VALUEFUNC(_wrap_FXDriveBox_destroy), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "resize", VALUEFUNC(_wrap_FXDriveBox_resize), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXDriveBox_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXDriveBox_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXDriveBox_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXDriveBox_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "canFocus", VALUEFUNC(_wrap_FXDriveBox_canFocus), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "setFocus", VALUEFUNC(_wrap_FXDriveBox_setFocus), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "killFocus", VALUEFUNC(_wrap_FXDriveBox_killFocus), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "changeFocus", VALUEFUNC(_wrap_FXDriveBox_changeFocus), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "setDefault", VALUEFUNC(_wrap_FXDriveBox_setDefault), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "enable", VALUEFUNC(_wrap_FXDriveBox_enable), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "disable", VALUEFUNC(_wrap_FXDriveBox_disable), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "raiseWindow", VALUEFUNC(_wrap_FXDriveBox_raiseWindow), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "lower", VALUEFUNC(_wrap_FXDriveBox_lower), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "move", VALUEFUNC(_wrap_FXDriveBox_move), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "position", VALUEFUNC(_wrap_FXDriveBox_position), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "layout", VALUEFUNC(_wrap_FXDriveBox_layout), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "recalc", VALUEFUNC(_wrap_FXDriveBox_recalc), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "reparent", VALUEFUNC(_wrap_FXDriveBox_reparent), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "show", VALUEFUNC(_wrap_FXDriveBox_show), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "hide", VALUEFUNC(_wrap_FXDriveBox_hide), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "isComposite", VALUEFUNC(_wrap_FXDriveBox_isComposite), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "contains", VALUEFUNC(_wrap_FXDriveBox_contains), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXDriveBox_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "setBackColor", VALUEFUNC(_wrap_FXDriveBox_setBackColor), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "tr", VALUEFUNC(_wrap_FXDriveBox_tr), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "dropEnable", VALUEFUNC(_wrap_FXDriveBox_dropEnable), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "dropDisable", VALUEFUNC(_wrap_FXDriveBox_dropDisable), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "setShape", VALUEFUNC(_wrap_FXDriveBox_setShape), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "clearShape", VALUEFUNC(_wrap_FXDriveBox_clearShape), -1);
+  rb_define_method(SwigClassFXDriveBox.klass, "setCurrentItem", VALUEFUNC(_wrap_FXDriveBox_setCurrentItem), -1);
+  SwigClassFXDriveBox.mark = (void (*)(void *)) FXRbDriveBox::markfunc;
+  SwigClassFXDriveBox.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXDriveBox.trackObjects = 0;
+  
+  SwigClassFXDirSelector.klass = rb_define_class_under(mFox, "FXDirSelector", ((swig_class *) SWIGTYPE_p_FXPacker->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXDirSelector, (void *) &SwigClassFXDirSelector);
+  rb_define_alloc_func(SwigClassFXDirSelector.klass, _wrap_FXDirSelector_allocate);
+  rb_define_method(SwigClassFXDirSelector.klass, "initialize", VALUEFUNC(_wrap_new_FXDirSelector), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "onCmdName", VALUEFUNC(_wrap_FXDirSelector_onCmdName), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "onCmdOpened", VALUEFUNC(_wrap_FXDirSelector_onCmdOpened), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "onCmdHome", VALUEFUNC(_wrap_FXDirSelector_onCmdHome), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "onCmdWork", VALUEFUNC(_wrap_FXDirSelector_onCmdWork), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "onCmdDirectoryUp", VALUEFUNC(_wrap_FXDirSelector_onCmdDirectoryUp), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "onPopupMenu", VALUEFUNC(_wrap_FXDirSelector_onPopupMenu), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "onCmdBookmark", VALUEFUNC(_wrap_FXDirSelector_onCmdBookmark), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "onCmdVisit", VALUEFUNC(_wrap_FXDirSelector_onCmdVisit), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "onCmdNew", VALUEFUNC(_wrap_FXDirSelector_onCmdNew), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "onUpdNew", VALUEFUNC(_wrap_FXDirSelector_onUpdNew), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "onCmdMove", VALUEFUNC(_wrap_FXDirSelector_onCmdMove), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "onCmdCopy", VALUEFUNC(_wrap_FXDirSelector_onCmdCopy), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "onCmdLink", VALUEFUNC(_wrap_FXDirSelector_onCmdLink), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "onCmdDelete", VALUEFUNC(_wrap_FXDirSelector_onCmdDelete), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "onUpdSelected", VALUEFUNC(_wrap_FXDirSelector_onUpdSelected), -1);
+  rb_define_const(SwigClassFXDirSelector.klass, "ID_DIRNAME", SWIG_From_int(static_cast< int >(FXDirSelector::ID_DIRNAME)));
+  rb_define_const(SwigClassFXDirSelector.klass, "ID_DIRLIST", SWIG_From_int(static_cast< int >(FXDirSelector::ID_DIRLIST)));
+  rb_define_const(SwigClassFXDirSelector.klass, "ID_HOME", SWIG_From_int(static_cast< int >(FXDirSelector::ID_HOME)));
+  rb_define_const(SwigClassFXDirSelector.klass, "ID_WORK", SWIG_From_int(static_cast< int >(FXDirSelector::ID_WORK)));
+  rb_define_const(SwigClassFXDirSelector.klass, "ID_DIRECTORY_UP", SWIG_From_int(static_cast< int >(FXDirSelector::ID_DIRECTORY_UP)));
+  rb_define_const(SwigClassFXDirSelector.klass, "ID_BOOKMARK", SWIG_From_int(static_cast< int >(FXDirSelector::ID_BOOKMARK)));
+  rb_define_const(SwigClassFXDirSelector.klass, "ID_VISIT", SWIG_From_int(static_cast< int >(FXDirSelector::ID_VISIT)));
+  rb_define_const(SwigClassFXDirSelector.klass, "ID_NEW", SWIG_From_int(static_cast< int >(FXDirSelector::ID_NEW)));
+  rb_define_const(SwigClassFXDirSelector.klass, "ID_DELETE", SWIG_From_int(static_cast< int >(FXDirSelector::ID_DELETE)));
+  rb_define_const(SwigClassFXDirSelector.klass, "ID_MOVE", SWIG_From_int(static_cast< int >(FXDirSelector::ID_MOVE)));
+  rb_define_const(SwigClassFXDirSelector.klass, "ID_COPY", SWIG_From_int(static_cast< int >(FXDirSelector::ID_COPY)));
+  rb_define_const(SwigClassFXDirSelector.klass, "ID_LINK", SWIG_From_int(static_cast< int >(FXDirSelector::ID_LINK)));
+  rb_define_const(SwigClassFXDirSelector.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXDirSelector::ID_LAST)));
+  rb_define_method(SwigClassFXDirSelector.klass, "acceptButton", VALUEFUNC(_wrap_FXDirSelector_acceptButton), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "cancelButton", VALUEFUNC(_wrap_FXDirSelector_cancelButton), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "setDirectory", VALUEFUNC(_wrap_FXDirSelector_setDirectory), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "getDirectory", VALUEFUNC(_wrap_FXDirSelector_getDirectory), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "getShowFiles", VALUEFUNC(_wrap_FXDirSelector_getShowFiles), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "setShowFiles", VALUEFUNC(_wrap_FXDirSelector_setShowFiles), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "getShowHiddenFiles", VALUEFUNC(_wrap_FXDirSelector_getShowHiddenFiles), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "setShowHiddenFiles", VALUEFUNC(_wrap_FXDirSelector_setShowHiddenFiles), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "getMatchMode", VALUEFUNC(_wrap_FXDirSelector_getMatchMode), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "setMatchMode", VALUEFUNC(_wrap_FXDirSelector_setMatchMode), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "setDirBoxStyle", VALUEFUNC(_wrap_FXDirSelector_setDirBoxStyle), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "getDirBoxStyle", VALUEFUNC(_wrap_FXDirSelector_getDirBoxStyle), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "save", VALUEFUNC(_wrap_FXDirSelector_save), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "load", VALUEFUNC(_wrap_FXDirSelector_load), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "create", VALUEFUNC(_wrap_FXDirSelector_create), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "detach", VALUEFUNC(_wrap_FXDirSelector_detach), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "destroy", VALUEFUNC(_wrap_FXDirSelector_destroy), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "resize", VALUEFUNC(_wrap_FXDirSelector_resize), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXDirSelector_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXDirSelector_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXDirSelector_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXDirSelector_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "canFocus", VALUEFUNC(_wrap_FXDirSelector_canFocus), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "setFocus", VALUEFUNC(_wrap_FXDirSelector_setFocus), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "killFocus", VALUEFUNC(_wrap_FXDirSelector_killFocus), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "changeFocus", VALUEFUNC(_wrap_FXDirSelector_changeFocus), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "setDefault", VALUEFUNC(_wrap_FXDirSelector_setDefault), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "enable", VALUEFUNC(_wrap_FXDirSelector_enable), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "disable", VALUEFUNC(_wrap_FXDirSelector_disable), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "raiseWindow", VALUEFUNC(_wrap_FXDirSelector_raiseWindow), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "lower", VALUEFUNC(_wrap_FXDirSelector_lower), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "move", VALUEFUNC(_wrap_FXDirSelector_move), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "position", VALUEFUNC(_wrap_FXDirSelector_position), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "layout", VALUEFUNC(_wrap_FXDirSelector_layout), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "recalc", VALUEFUNC(_wrap_FXDirSelector_recalc), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "reparent", VALUEFUNC(_wrap_FXDirSelector_reparent), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "show", VALUEFUNC(_wrap_FXDirSelector_show), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "hide", VALUEFUNC(_wrap_FXDirSelector_hide), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "isComposite", VALUEFUNC(_wrap_FXDirSelector_isComposite), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "contains", VALUEFUNC(_wrap_FXDirSelector_contains), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXDirSelector_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "setBackColor", VALUEFUNC(_wrap_FXDirSelector_setBackColor), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "tr", VALUEFUNC(_wrap_FXDirSelector_tr), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "dropEnable", VALUEFUNC(_wrap_FXDirSelector_dropEnable), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "dropDisable", VALUEFUNC(_wrap_FXDirSelector_dropDisable), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "setShape", VALUEFUNC(_wrap_FXDirSelector_setShape), -1);
+  rb_define_method(SwigClassFXDirSelector.klass, "clearShape", VALUEFUNC(_wrap_FXDirSelector_clearShape), -1);
+  SwigClassFXDirSelector.mark = (void (*)(void *)) FXRbDirSelector::markfunc;
+  SwigClassFXDirSelector.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXDirSelector.trackObjects = 0;
+  rb_define_const(mFox, "SELECTFILE_ANY", SWIG_From_int(static_cast< int >(SELECTFILE_ANY)));
+  rb_define_const(mFox, "SELECTFILE_EXISTING", SWIG_From_int(static_cast< int >(SELECTFILE_EXISTING)));
+  rb_define_const(mFox, "SELECTFILE_MULTIPLE", SWIG_From_int(static_cast< int >(SELECTFILE_MULTIPLE)));
+  rb_define_const(mFox, "SELECTFILE_MULTIPLE_ALL", SWIG_From_int(static_cast< int >(SELECTFILE_MULTIPLE_ALL)));
+  rb_define_const(mFox, "SELECTFILE_DIRECTORY", SWIG_From_int(static_cast< int >(SELECTFILE_DIRECTORY)));
+  
+  SwigClassFXFileSelector.klass = rb_define_class_under(mFox, "FXFileSelector", ((swig_class *) SWIGTYPE_p_FXPacker->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXFileSelector, (void *) &SwigClassFXFileSelector);
+  rb_define_alloc_func(SwigClassFXFileSelector.klass, _wrap_FXFileSelector_allocate);
+  rb_define_method(SwigClassFXFileSelector.klass, "initialize", VALUEFUNC(_wrap_new_FXFileSelector), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "onCmdAccept", VALUEFUNC(_wrap_FXFileSelector_onCmdAccept), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "onCmdFilter", VALUEFUNC(_wrap_FXFileSelector_onCmdFilter), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "onCmdItemDblClicked", VALUEFUNC(_wrap_FXFileSelector_onCmdItemDblClicked), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "onCmdItemSelected", VALUEFUNC(_wrap_FXFileSelector_onCmdItemSelected), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "onCmdItemDeselected", VALUEFUNC(_wrap_FXFileSelector_onCmdItemDeselected), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "onCmdDirectoryUp", VALUEFUNC(_wrap_FXFileSelector_onCmdDirectoryUp), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "onUpdDirectoryUp", VALUEFUNC(_wrap_FXFileSelector_onUpdDirectoryUp), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "onCmdDirTree", VALUEFUNC(_wrap_FXFileSelector_onCmdDirTree), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "onCmdHome", VALUEFUNC(_wrap_FXFileSelector_onCmdHome), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "onCmdWork", VALUEFUNC(_wrap_FXFileSelector_onCmdWork), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "onCmdBookmark", VALUEFUNC(_wrap_FXFileSelector_onCmdBookmark), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "onCmdVisit", VALUEFUNC(_wrap_FXFileSelector_onCmdVisit), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "onCmdNew", VALUEFUNC(_wrap_FXFileSelector_onCmdNew), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "onUpdNew", VALUEFUNC(_wrap_FXFileSelector_onUpdNew), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "onCmdMove", VALUEFUNC(_wrap_FXFileSelector_onCmdMove), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "onCmdCopy", VALUEFUNC(_wrap_FXFileSelector_onCmdCopy), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "onCmdLink", VALUEFUNC(_wrap_FXFileSelector_onCmdLink), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "onCmdDelete", VALUEFUNC(_wrap_FXFileSelector_onCmdDelete), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "onUpdSelected", VALUEFUNC(_wrap_FXFileSelector_onUpdSelected), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "onPopupMenu", VALUEFUNC(_wrap_FXFileSelector_onPopupMenu), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "onCmdImageSize", VALUEFUNC(_wrap_FXFileSelector_onCmdImageSize), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "onUpdImageSize", VALUEFUNC(_wrap_FXFileSelector_onUpdImageSize), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "onUpdNavigable", VALUEFUNC(_wrap_FXFileSelector_onUpdNavigable), -1);
+  rb_define_const(SwigClassFXFileSelector.klass, "ID_FILEFILTER", SWIG_From_int(static_cast< int >(FXFileSelector::ID_FILEFILTER)));
+  rb_define_const(SwigClassFXFileSelector.klass, "ID_ACCEPT", SWIG_From_int(static_cast< int >(FXFileSelector::ID_ACCEPT)));
+  rb_define_const(SwigClassFXFileSelector.klass, "ID_FILELIST", SWIG_From_int(static_cast< int >(FXFileSelector::ID_FILELIST)));
+  rb_define_const(SwigClassFXFileSelector.klass, "ID_DIRECTORY_UP", SWIG_From_int(static_cast< int >(FXFileSelector::ID_DIRECTORY_UP)));
+  rb_define_const(SwigClassFXFileSelector.klass, "ID_DIRTREE", SWIG_From_int(static_cast< int >(FXFileSelector::ID_DIRTREE)));
+  rb_define_const(SwigClassFXFileSelector.klass, "ID_NORMAL_SIZE", SWIG_From_int(static_cast< int >(FXFileSelector::ID_NORMAL_SIZE)));
+  rb_define_const(SwigClassFXFileSelector.klass, "ID_MEDIUM_SIZE", SWIG_From_int(static_cast< int >(FXFileSelector::ID_MEDIUM_SIZE)));
+  rb_define_const(SwigClassFXFileSelector.klass, "ID_GIANT_SIZE", SWIG_From_int(static_cast< int >(FXFileSelector::ID_GIANT_SIZE)));
+  rb_define_const(SwigClassFXFileSelector.klass, "ID_HOME", SWIG_From_int(static_cast< int >(FXFileSelector::ID_HOME)));
+  rb_define_const(SwigClassFXFileSelector.klass, "ID_WORK", SWIG_From_int(static_cast< int >(FXFileSelector::ID_WORK)));
+  rb_define_const(SwigClassFXFileSelector.klass, "ID_BOOKMARK", SWIG_From_int(static_cast< int >(FXFileSelector::ID_BOOKMARK)));
+  rb_define_const(SwigClassFXFileSelector.klass, "ID_BOOKMENU", SWIG_From_int(static_cast< int >(FXFileSelector::ID_BOOKMENU)));
+  rb_define_const(SwigClassFXFileSelector.klass, "ID_VISIT", SWIG_From_int(static_cast< int >(FXFileSelector::ID_VISIT)));
+  rb_define_const(SwigClassFXFileSelector.klass, "ID_NEW", SWIG_From_int(static_cast< int >(FXFileSelector::ID_NEW)));
+  rb_define_const(SwigClassFXFileSelector.klass, "ID_DELETE", SWIG_From_int(static_cast< int >(FXFileSelector::ID_DELETE)));
+  rb_define_const(SwigClassFXFileSelector.klass, "ID_MOVE", SWIG_From_int(static_cast< int >(FXFileSelector::ID_MOVE)));
+  rb_define_const(SwigClassFXFileSelector.klass, "ID_COPY", SWIG_From_int(static_cast< int >(FXFileSelector::ID_COPY)));
+  rb_define_const(SwigClassFXFileSelector.klass, "ID_LINK", SWIG_From_int(static_cast< int >(FXFileSelector::ID_LINK)));
+  rb_define_const(SwigClassFXFileSelector.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXFileSelector::ID_LAST)));
+  rb_define_method(SwigClassFXFileSelector.klass, "acceptButton", VALUEFUNC(_wrap_FXFileSelector_acceptButton), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "cancelButton", VALUEFUNC(_wrap_FXFileSelector_cancelButton), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "setFilename", VALUEFUNC(_wrap_FXFileSelector_setFilename), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "getFilename", VALUEFUNC(_wrap_FXFileSelector_getFilename), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "getFilenames", VALUEFUNC(_wrap_FXFileSelector_getFilenames), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "setPattern", VALUEFUNC(_wrap_FXFileSelector_setPattern), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "getPattern", VALUEFUNC(_wrap_FXFileSelector_getPattern), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "setPatternList", VALUEFUNC(_wrap_FXFileSelector_setPatternList), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "getPatternList", VALUEFUNC(_wrap_FXFileSelector_getPatternList), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "setCurrentPattern", VALUEFUNC(_wrap_FXFileSelector_setCurrentPattern), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "getCurrentPattern", VALUEFUNC(_wrap_FXFileSelector_getCurrentPattern), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "getPatternText", VALUEFUNC(_wrap_FXFileSelector_getPatternText), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "setPatternText", VALUEFUNC(_wrap_FXFileSelector_setPatternText), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "numPatterns", VALUEFUNC(_wrap_FXFileSelector_numPatterns), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "setAllowPatternEntry", VALUEFUNC(_wrap_FXFileSelector_setAllowPatternEntry), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "getAllowPatternEntry", VALUEFUNC(_wrap_FXFileSelector_getAllowPatternEntry), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "setDirectory", VALUEFUNC(_wrap_FXFileSelector_setDirectory), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "getDirectory", VALUEFUNC(_wrap_FXFileSelector_getDirectory), -1);
+  rb_define_singleton_method(SwigClassFXFileSelector.klass, "patternFromText", VALUEFUNC(_wrap_FXFileSelector_patternFromText), -1);
+  rb_define_singleton_method(SwigClassFXFileSelector.klass, "extensionFromPattern", VALUEFUNC(_wrap_FXFileSelector_extensionFromPattern), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "setItemSpace", VALUEFUNC(_wrap_FXFileSelector_setItemSpace), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "getItemSpace", VALUEFUNC(_wrap_FXFileSelector_getItemSpace), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "setFileBoxStyle", VALUEFUNC(_wrap_FXFileSelector_setFileBoxStyle), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "getFileBoxStyle", VALUEFUNC(_wrap_FXFileSelector_getFileBoxStyle), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "setSelectMode", VALUEFUNC(_wrap_FXFileSelector_setSelectMode), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "getSelectMode", VALUEFUNC(_wrap_FXFileSelector_getSelectMode), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "setMatchMode", VALUEFUNC(_wrap_FXFileSelector_setMatchMode), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "getMatchMode", VALUEFUNC(_wrap_FXFileSelector_getMatchMode), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "getShowHiddenFiles", VALUEFUNC(_wrap_FXFileSelector_getShowHiddenFiles), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "setShowHiddenFiles", VALUEFUNC(_wrap_FXFileSelector_setShowHiddenFiles), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "getShowImages", VALUEFUNC(_wrap_FXFileSelector_getShowImages), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "setShowImages", VALUEFUNC(_wrap_FXFileSelector_setShowImages), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "getImageSize", VALUEFUNC(_wrap_FXFileSelector_getImageSize), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "setImageSize", VALUEFUNC(_wrap_FXFileSelector_setImageSize), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "setReadOnlyShown", VALUEFUNC(_wrap_FXFileSelector_setReadOnlyShown), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "getReadOnlyShown", VALUEFUNC(_wrap_FXFileSelector_getReadOnlyShown), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "setReadOnly", VALUEFUNC(_wrap_FXFileSelector_setReadOnly), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "getReadOnly", VALUEFUNC(_wrap_FXFileSelector_getReadOnly), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "navigationAllowed=", VALUEFUNC(_wrap_FXFileSelector_navigationAllowede___), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "navigationAllowed?", VALUEFUNC(_wrap_FXFileSelector_navigationAllowedq___), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "save", VALUEFUNC(_wrap_FXFileSelector_save), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "load", VALUEFUNC(_wrap_FXFileSelector_load), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "create", VALUEFUNC(_wrap_FXFileSelector_create), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "detach", VALUEFUNC(_wrap_FXFileSelector_detach), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "destroy", VALUEFUNC(_wrap_FXFileSelector_destroy), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "resize", VALUEFUNC(_wrap_FXFileSelector_resize), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXFileSelector_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXFileSelector_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXFileSelector_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXFileSelector_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "canFocus", VALUEFUNC(_wrap_FXFileSelector_canFocus), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "setFocus", VALUEFUNC(_wrap_FXFileSelector_setFocus), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "killFocus", VALUEFUNC(_wrap_FXFileSelector_killFocus), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "changeFocus", VALUEFUNC(_wrap_FXFileSelector_changeFocus), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "setDefault", VALUEFUNC(_wrap_FXFileSelector_setDefault), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "enable", VALUEFUNC(_wrap_FXFileSelector_enable), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "disable", VALUEFUNC(_wrap_FXFileSelector_disable), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "raiseWindow", VALUEFUNC(_wrap_FXFileSelector_raiseWindow), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "lower", VALUEFUNC(_wrap_FXFileSelector_lower), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "move", VALUEFUNC(_wrap_FXFileSelector_move), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "position", VALUEFUNC(_wrap_FXFileSelector_position), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "layout", VALUEFUNC(_wrap_FXFileSelector_layout), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "recalc", VALUEFUNC(_wrap_FXFileSelector_recalc), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "reparent", VALUEFUNC(_wrap_FXFileSelector_reparent), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "show", VALUEFUNC(_wrap_FXFileSelector_show), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "hide", VALUEFUNC(_wrap_FXFileSelector_hide), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "isComposite", VALUEFUNC(_wrap_FXFileSelector_isComposite), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "contains", VALUEFUNC(_wrap_FXFileSelector_contains), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXFileSelector_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "setBackColor", VALUEFUNC(_wrap_FXFileSelector_setBackColor), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "tr", VALUEFUNC(_wrap_FXFileSelector_tr), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "dropEnable", VALUEFUNC(_wrap_FXFileSelector_dropEnable), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "dropDisable", VALUEFUNC(_wrap_FXFileSelector_dropDisable), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "setShape", VALUEFUNC(_wrap_FXFileSelector_setShape), -1);
+  rb_define_method(SwigClassFXFileSelector.klass, "clearShape", VALUEFUNC(_wrap_FXFileSelector_clearShape), -1);
+  SwigClassFXFileSelector.mark = (void (*)(void *)) FXRbFileSelector::markfunc;
+  SwigClassFXFileSelector.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXFileSelector.trackObjects = 0;
+  
+  SwigClassFXColorSelector.klass = rb_define_class_under(mFox, "FXColorSelector", ((swig_class *) SWIGTYPE_p_FXPacker->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXColorSelector, (void *) &SwigClassFXColorSelector);
+  rb_define_alloc_func(SwigClassFXColorSelector.klass, _wrap_FXColorSelector_allocate);
+  rb_define_method(SwigClassFXColorSelector.klass, "initialize", VALUEFUNC(_wrap_new_FXColorSelector), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onCmdWell", VALUEFUNC(_wrap_FXColorSelector_onCmdWell), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onChgWell", VALUEFUNC(_wrap_FXColorSelector_onChgWell), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onCmdRGBSlider", VALUEFUNC(_wrap_FXColorSelector_onCmdRGBSlider), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onUpdRGBSlider", VALUEFUNC(_wrap_FXColorSelector_onUpdRGBSlider), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onCmdRGBText", VALUEFUNC(_wrap_FXColorSelector_onCmdRGBText), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onUpdRGBText", VALUEFUNC(_wrap_FXColorSelector_onUpdRGBText), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onCmdHSVSlider", VALUEFUNC(_wrap_FXColorSelector_onCmdHSVSlider), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onUpdHSVSlider", VALUEFUNC(_wrap_FXColorSelector_onUpdHSVSlider), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onCmdHSVText", VALUEFUNC(_wrap_FXColorSelector_onCmdHSVText), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onUpdHSVText", VALUEFUNC(_wrap_FXColorSelector_onUpdHSVText), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onCmdCMYSlider", VALUEFUNC(_wrap_FXColorSelector_onCmdCMYSlider), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onUpdCMYSlider", VALUEFUNC(_wrap_FXColorSelector_onUpdCMYSlider), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onCmdCMYText", VALUEFUNC(_wrap_FXColorSelector_onCmdCMYText), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onUpdCMYText", VALUEFUNC(_wrap_FXColorSelector_onUpdCMYText), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onCmdList", VALUEFUNC(_wrap_FXColorSelector_onCmdList), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onCmdCustomWell", VALUEFUNC(_wrap_FXColorSelector_onCmdCustomWell), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onChgCustomWell", VALUEFUNC(_wrap_FXColorSelector_onChgCustomWell), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXColorSelector_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onCmdActivePane", VALUEFUNC(_wrap_FXColorSelector_onCmdActivePane), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onCmdAlphaSlider", VALUEFUNC(_wrap_FXColorSelector_onCmdAlphaSlider), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onUpdAlphaSlider", VALUEFUNC(_wrap_FXColorSelector_onUpdAlphaSlider), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onCmdAlphaText", VALUEFUNC(_wrap_FXColorSelector_onCmdAlphaText), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onUpdAlphaText", VALUEFUNC(_wrap_FXColorSelector_onUpdAlphaText), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onUpdAlphaLabel", VALUEFUNC(_wrap_FXColorSelector_onUpdAlphaLabel), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onCmdWheel", VALUEFUNC(_wrap_FXColorSelector_onCmdWheel), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onUpdWheel", VALUEFUNC(_wrap_FXColorSelector_onUpdWheel), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "onCmdColorPick", VALUEFUNC(_wrap_FXColorSelector_onCmdColorPick), -1);
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_CUSTOM_FIRST", SWIG_From_int(static_cast< int >(FXColorSelector::ID_CUSTOM_FIRST)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_CUSTOM_LAST", SWIG_From_int(static_cast< int >(FXColorSelector::ID_CUSTOM_LAST)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_RGB_RED_SLIDER", SWIG_From_int(static_cast< int >(FXColorSelector::ID_RGB_RED_SLIDER)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_RGB_GREEN_SLIDER", SWIG_From_int(static_cast< int >(FXColorSelector::ID_RGB_GREEN_SLIDER)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_RGB_BLUE_SLIDER", SWIG_From_int(static_cast< int >(FXColorSelector::ID_RGB_BLUE_SLIDER)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_RGB_RED_TEXT", SWIG_From_int(static_cast< int >(FXColorSelector::ID_RGB_RED_TEXT)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_RGB_GREEN_TEXT", SWIG_From_int(static_cast< int >(FXColorSelector::ID_RGB_GREEN_TEXT)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_RGB_BLUE_TEXT", SWIG_From_int(static_cast< int >(FXColorSelector::ID_RGB_BLUE_TEXT)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_HSV_HUE_SLIDER", SWIG_From_int(static_cast< int >(FXColorSelector::ID_HSV_HUE_SLIDER)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_HSV_SATURATION_SLIDER", SWIG_From_int(static_cast< int >(FXColorSelector::ID_HSV_SATURATION_SLIDER)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_HSV_VALUE_SLIDER", SWIG_From_int(static_cast< int >(FXColorSelector::ID_HSV_VALUE_SLIDER)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_HSV_HUE_TEXT", SWIG_From_int(static_cast< int >(FXColorSelector::ID_HSV_HUE_TEXT)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_HSV_SATURATION_TEXT", SWIG_From_int(static_cast< int >(FXColorSelector::ID_HSV_SATURATION_TEXT)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_HSV_VALUE_TEXT", SWIG_From_int(static_cast< int >(FXColorSelector::ID_HSV_VALUE_TEXT)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_CMY_CYAN_SLIDER", SWIG_From_int(static_cast< int >(FXColorSelector::ID_CMY_CYAN_SLIDER)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_CMY_MAGENTA_SLIDER", SWIG_From_int(static_cast< int >(FXColorSelector::ID_CMY_MAGENTA_SLIDER)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_CMY_YELLOW_SLIDER", SWIG_From_int(static_cast< int >(FXColorSelector::ID_CMY_YELLOW_SLIDER)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_CMY_CYAN_TEXT", SWIG_From_int(static_cast< int >(FXColorSelector::ID_CMY_CYAN_TEXT)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_CMY_MAGENTA_TEXT", SWIG_From_int(static_cast< int >(FXColorSelector::ID_CMY_MAGENTA_TEXT)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_CMY_YELLOW_TEXT", SWIG_From_int(static_cast< int >(FXColorSelector::ID_CMY_YELLOW_TEXT)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_DIAL_WHEEL", SWIG_From_int(static_cast< int >(FXColorSelector::ID_DIAL_WHEEL)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_COLOR_LIST", SWIG_From_int(static_cast< int >(FXColorSelector::ID_COLOR_LIST)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_WELL_CHANGED", SWIG_From_int(static_cast< int >(FXColorSelector::ID_WELL_CHANGED)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_ACTIVEPANE", SWIG_From_int(static_cast< int >(FXColorSelector::ID_ACTIVEPANE)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_ALPHA_SLIDER", SWIG_From_int(static_cast< int >(FXColorSelector::ID_ALPHA_SLIDER)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_ALPHA_TEXT", SWIG_From_int(static_cast< int >(FXColorSelector::ID_ALPHA_TEXT)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_ALPHA_LABEL", SWIG_From_int(static_cast< int >(FXColorSelector::ID_ALPHA_LABEL)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_COLORPICK", SWIG_From_int(static_cast< int >(FXColorSelector::ID_COLORPICK)));
+  rb_define_const(SwigClassFXColorSelector.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXColorSelector::ID_LAST)));
+  rb_define_method(SwigClassFXColorSelector.klass, "acceptButton", VALUEFUNC(_wrap_FXColorSelector_acceptButton), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "cancelButton", VALUEFUNC(_wrap_FXColorSelector_cancelButton), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "setRGBA", VALUEFUNC(_wrap_FXColorSelector_setRGBA), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "getRGBA", VALUEFUNC(_wrap_FXColorSelector_getRGBA), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "isOpaqueOnly", VALUEFUNC(_wrap_FXColorSelector_isOpaqueOnly), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "setOpaqueOnly", VALUEFUNC(_wrap_FXColorSelector_setOpaqueOnly), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "save", VALUEFUNC(_wrap_FXColorSelector_save), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "load", VALUEFUNC(_wrap_FXColorSelector_load), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "create", VALUEFUNC(_wrap_FXColorSelector_create), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "detach", VALUEFUNC(_wrap_FXColorSelector_detach), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "destroy", VALUEFUNC(_wrap_FXColorSelector_destroy), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "resize", VALUEFUNC(_wrap_FXColorSelector_resize), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXColorSelector_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXColorSelector_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXColorSelector_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXColorSelector_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "canFocus", VALUEFUNC(_wrap_FXColorSelector_canFocus), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "setFocus", VALUEFUNC(_wrap_FXColorSelector_setFocus), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "killFocus", VALUEFUNC(_wrap_FXColorSelector_killFocus), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "changeFocus", VALUEFUNC(_wrap_FXColorSelector_changeFocus), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "setDefault", VALUEFUNC(_wrap_FXColorSelector_setDefault), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "enable", VALUEFUNC(_wrap_FXColorSelector_enable), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "disable", VALUEFUNC(_wrap_FXColorSelector_disable), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "raiseWindow", VALUEFUNC(_wrap_FXColorSelector_raiseWindow), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "lower", VALUEFUNC(_wrap_FXColorSelector_lower), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "move", VALUEFUNC(_wrap_FXColorSelector_move), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "position", VALUEFUNC(_wrap_FXColorSelector_position), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "layout", VALUEFUNC(_wrap_FXColorSelector_layout), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "recalc", VALUEFUNC(_wrap_FXColorSelector_recalc), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "reparent", VALUEFUNC(_wrap_FXColorSelector_reparent), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "show", VALUEFUNC(_wrap_FXColorSelector_show), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "hide", VALUEFUNC(_wrap_FXColorSelector_hide), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "isComposite", VALUEFUNC(_wrap_FXColorSelector_isComposite), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "contains", VALUEFUNC(_wrap_FXColorSelector_contains), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXColorSelector_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "setBackColor", VALUEFUNC(_wrap_FXColorSelector_setBackColor), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "tr", VALUEFUNC(_wrap_FXColorSelector_tr), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "dropEnable", VALUEFUNC(_wrap_FXColorSelector_dropEnable), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "dropDisable", VALUEFUNC(_wrap_FXColorSelector_dropDisable), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "setShape", VALUEFUNC(_wrap_FXColorSelector_setShape), -1);
+  rb_define_method(SwigClassFXColorSelector.klass, "clearShape", VALUEFUNC(_wrap_FXColorSelector_clearShape), -1);
+  SwigClassFXColorSelector.mark = (void (*)(void *)) FXRbColorSelector::markfunc;
+  SwigClassFXColorSelector.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXColorSelector.trackObjects = 0;
+  
+  SwigClassFXFontSelector.klass = rb_define_class_under(mFox, "FXFontSelector", ((swig_class *) SWIGTYPE_p_FXPacker->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXFontSelector, (void *) &SwigClassFXFontSelector);
+  rb_define_alloc_func(SwigClassFXFontSelector.klass, _wrap_FXFontSelector_allocate);
+  rb_define_method(SwigClassFXFontSelector.klass, "initialize", VALUEFUNC(_wrap_new_FXFontSelector), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "onCmdFamily", VALUEFUNC(_wrap_FXFontSelector_onCmdFamily), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "onCmdWeight", VALUEFUNC(_wrap_FXFontSelector_onCmdWeight), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "onCmdStyle", VALUEFUNC(_wrap_FXFontSelector_onCmdStyle), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "onCmdStyleText", VALUEFUNC(_wrap_FXFontSelector_onCmdStyleText), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "onCmdSize", VALUEFUNC(_wrap_FXFontSelector_onCmdSize), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "onCmdSizeText", VALUEFUNC(_wrap_FXFontSelector_onCmdSizeText), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "onCmdCharset", VALUEFUNC(_wrap_FXFontSelector_onCmdCharset), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "onUpdCharset", VALUEFUNC(_wrap_FXFontSelector_onUpdCharset), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "onCmdSetWidth", VALUEFUNC(_wrap_FXFontSelector_onCmdSetWidth), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "onUpdSetWidth", VALUEFUNC(_wrap_FXFontSelector_onUpdSetWidth), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "onCmdPitch", VALUEFUNC(_wrap_FXFontSelector_onCmdPitch), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "onUpdPitch", VALUEFUNC(_wrap_FXFontSelector_onUpdPitch), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "onCmdScalable", VALUEFUNC(_wrap_FXFontSelector_onCmdScalable), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "onUpdScalable", VALUEFUNC(_wrap_FXFontSelector_onUpdScalable), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "onCmdAllFonts", VALUEFUNC(_wrap_FXFontSelector_onCmdAllFonts), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "onUpdAllFonts", VALUEFUNC(_wrap_FXFontSelector_onUpdAllFonts), -1);
+  rb_define_const(SwigClassFXFontSelector.klass, "ID_FAMILY", SWIG_From_int(static_cast< int >(FXFontSelector::ID_FAMILY)));
+  rb_define_const(SwigClassFXFontSelector.klass, "ID_WEIGHT", SWIG_From_int(static_cast< int >(FXFontSelector::ID_WEIGHT)));
+  rb_define_const(SwigClassFXFontSelector.klass, "ID_STYLE", SWIG_From_int(static_cast< int >(FXFontSelector::ID_STYLE)));
+  rb_define_const(SwigClassFXFontSelector.klass, "ID_STYLE_TEXT", SWIG_From_int(static_cast< int >(FXFontSelector::ID_STYLE_TEXT)));
+  rb_define_const(SwigClassFXFontSelector.klass, "ID_SIZE", SWIG_From_int(static_cast< int >(FXFontSelector::ID_SIZE)));
+  rb_define_const(SwigClassFXFontSelector.klass, "ID_SIZE_TEXT", SWIG_From_int(static_cast< int >(FXFontSelector::ID_SIZE_TEXT)));
+  rb_define_const(SwigClassFXFontSelector.klass, "ID_CHARSET", SWIG_From_int(static_cast< int >(FXFontSelector::ID_CHARSET)));
+  rb_define_const(SwigClassFXFontSelector.klass, "ID_SETWIDTH", SWIG_From_int(static_cast< int >(FXFontSelector::ID_SETWIDTH)));
+  rb_define_const(SwigClassFXFontSelector.klass, "ID_PITCH", SWIG_From_int(static_cast< int >(FXFontSelector::ID_PITCH)));
+  rb_define_const(SwigClassFXFontSelector.klass, "ID_SCALABLE", SWIG_From_int(static_cast< int >(FXFontSelector::ID_SCALABLE)));
+  rb_define_const(SwigClassFXFontSelector.klass, "ID_ALLFONTS", SWIG_From_int(static_cast< int >(FXFontSelector::ID_ALLFONTS)));
+  rb_define_const(SwigClassFXFontSelector.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXFontSelector::ID_LAST)));
+  rb_define_method(SwigClassFXFontSelector.klass, "acceptButton", VALUEFUNC(_wrap_FXFontSelector_acceptButton), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "cancelButton", VALUEFUNC(_wrap_FXFontSelector_cancelButton), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "setFontSelection", VALUEFUNC(_wrap_FXFontSelector_setFontSelection), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "getFontSelection", VALUEFUNC(_wrap_FXFontSelector_getFontSelection), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "save", VALUEFUNC(_wrap_FXFontSelector_save), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "load", VALUEFUNC(_wrap_FXFontSelector_load), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "create", VALUEFUNC(_wrap_FXFontSelector_create), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "detach", VALUEFUNC(_wrap_FXFontSelector_detach), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "destroy", VALUEFUNC(_wrap_FXFontSelector_destroy), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "resize", VALUEFUNC(_wrap_FXFontSelector_resize), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXFontSelector_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXFontSelector_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXFontSelector_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXFontSelector_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "canFocus", VALUEFUNC(_wrap_FXFontSelector_canFocus), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "setFocus", VALUEFUNC(_wrap_FXFontSelector_setFocus), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "killFocus", VALUEFUNC(_wrap_FXFontSelector_killFocus), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "changeFocus", VALUEFUNC(_wrap_FXFontSelector_changeFocus), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "setDefault", VALUEFUNC(_wrap_FXFontSelector_setDefault), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "enable", VALUEFUNC(_wrap_FXFontSelector_enable), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "disable", VALUEFUNC(_wrap_FXFontSelector_disable), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "raiseWindow", VALUEFUNC(_wrap_FXFontSelector_raiseWindow), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "lower", VALUEFUNC(_wrap_FXFontSelector_lower), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "move", VALUEFUNC(_wrap_FXFontSelector_move), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "position", VALUEFUNC(_wrap_FXFontSelector_position), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "layout", VALUEFUNC(_wrap_FXFontSelector_layout), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "recalc", VALUEFUNC(_wrap_FXFontSelector_recalc), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "reparent", VALUEFUNC(_wrap_FXFontSelector_reparent), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "show", VALUEFUNC(_wrap_FXFontSelector_show), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "hide", VALUEFUNC(_wrap_FXFontSelector_hide), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "isComposite", VALUEFUNC(_wrap_FXFontSelector_isComposite), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "contains", VALUEFUNC(_wrap_FXFontSelector_contains), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXFontSelector_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "setBackColor", VALUEFUNC(_wrap_FXFontSelector_setBackColor), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "tr", VALUEFUNC(_wrap_FXFontSelector_tr), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "dropEnable", VALUEFUNC(_wrap_FXFontSelector_dropEnable), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "dropDisable", VALUEFUNC(_wrap_FXFontSelector_dropDisable), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "setShape", VALUEFUNC(_wrap_FXFontSelector_setShape), -1);
+  rb_define_method(SwigClassFXFontSelector.klass, "clearShape", VALUEFUNC(_wrap_FXFontSelector_clearShape), -1);
+  SwigClassFXFontSelector.mark = (void (*)(void *)) FXRbFontSelector::markfunc;
+  SwigClassFXFontSelector.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXFontSelector.trackObjects = 0;
+  
+  SwigClassFXDockHandler.klass = rb_define_class_under(mFox, "FXDockHandler", ((swig_class *) SWIGTYPE_p_FXFrame->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXDockHandler, (void *) &SwigClassFXDockHandler);
+  rb_undef_alloc_func(SwigClassFXDockHandler.klass);
+  rb_define_method(SwigClassFXDockHandler.klass, "onLeftBtnPress", VALUEFUNC(_wrap_FXDockHandler_onLeftBtnPress), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "onLeftBtnRelease", VALUEFUNC(_wrap_FXDockHandler_onLeftBtnRelease), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "onMotion", VALUEFUNC(_wrap_FXDockHandler_onMotion), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "onKeyPress", VALUEFUNC(_wrap_FXDockHandler_onKeyPress), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "onKeyRelease", VALUEFUNC(_wrap_FXDockHandler_onKeyRelease), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "onQueryTip", VALUEFUNC(_wrap_FXDockHandler_onQueryTip), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "onQueryHelp", VALUEFUNC(_wrap_FXDockHandler_onQueryHelp), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "onCmdSetTip", VALUEFUNC(_wrap_FXDockHandler_onCmdSetTip), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "onCmdGetTip", VALUEFUNC(_wrap_FXDockHandler_onCmdGetTip), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "onCmdSetHelp", VALUEFUNC(_wrap_FXDockHandler_onCmdSetHelp), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "onCmdGetHelp", VALUEFUNC(_wrap_FXDockHandler_onCmdGetHelp), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "helpText=", VALUEFUNC(_wrap_FXDockHandler_helpTexte___), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "helpText", VALUEFUNC(_wrap_FXDockHandler_helpText), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "tipText=", VALUEFUNC(_wrap_FXDockHandler_tipTexte___), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "tipText", VALUEFUNC(_wrap_FXDockHandler_tipText), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "save", VALUEFUNC(_wrap_FXDockHandler_save), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "load", VALUEFUNC(_wrap_FXDockHandler_load), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "create", VALUEFUNC(_wrap_FXDockHandler_create), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "detach", VALUEFUNC(_wrap_FXDockHandler_detach), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "destroy", VALUEFUNC(_wrap_FXDockHandler_destroy), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "resize", VALUEFUNC(_wrap_FXDockHandler_resize), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXDockHandler_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXDockHandler_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXDockHandler_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXDockHandler_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "canFocus", VALUEFUNC(_wrap_FXDockHandler_canFocus), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "setFocus", VALUEFUNC(_wrap_FXDockHandler_setFocus), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "killFocus", VALUEFUNC(_wrap_FXDockHandler_killFocus), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "changeFocus", VALUEFUNC(_wrap_FXDockHandler_changeFocus), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "setDefault", VALUEFUNC(_wrap_FXDockHandler_setDefault), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "enable", VALUEFUNC(_wrap_FXDockHandler_enable), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "disable", VALUEFUNC(_wrap_FXDockHandler_disable), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "raiseWindow", VALUEFUNC(_wrap_FXDockHandler_raiseWindow), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "lower", VALUEFUNC(_wrap_FXDockHandler_lower), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "move", VALUEFUNC(_wrap_FXDockHandler_move), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "position", VALUEFUNC(_wrap_FXDockHandler_position), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "layout", VALUEFUNC(_wrap_FXDockHandler_layout), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "recalc", VALUEFUNC(_wrap_FXDockHandler_recalc), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "reparent", VALUEFUNC(_wrap_FXDockHandler_reparent), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "show", VALUEFUNC(_wrap_FXDockHandler_show), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "hide", VALUEFUNC(_wrap_FXDockHandler_hide), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "isComposite", VALUEFUNC(_wrap_FXDockHandler_isComposite), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "contains", VALUEFUNC(_wrap_FXDockHandler_contains), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXDockHandler_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "setBackColor", VALUEFUNC(_wrap_FXDockHandler_setBackColor), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "tr", VALUEFUNC(_wrap_FXDockHandler_tr), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "dropEnable", VALUEFUNC(_wrap_FXDockHandler_dropEnable), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "dropDisable", VALUEFUNC(_wrap_FXDockHandler_dropDisable), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "setShape", VALUEFUNC(_wrap_FXDockHandler_setShape), -1);
+  rb_define_method(SwigClassFXDockHandler.klass, "clearShape", VALUEFUNC(_wrap_FXDockHandler_clearShape), -1);
+  SwigClassFXDockHandler.mark = (void (*)(void *)) FXRbDockHandler::markfunc;
+  SwigClassFXDockHandler.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXDockHandler.trackObjects = 0;
+  
+  SWIGTYPE_p_FXDockHandler->dcast = (swig_dycast_func) FXDockHandler_dynamic_cast;
+  
+  
+  SwigClassFXDockTitle.klass = rb_define_class_under(mFox, "FXDockTitle", ((swig_class *) SWIGTYPE_p_FXDockHandler->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXDockTitle, (void *) &SwigClassFXDockTitle);
+  rb_define_alloc_func(SwigClassFXDockTitle.klass, _wrap_FXDockTitle_allocate);
+  rb_define_method(SwigClassFXDockTitle.klass, "initialize", VALUEFUNC(_wrap_new_FXDockTitle), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "onPaint", VALUEFUNC(_wrap_FXDockTitle_onPaint), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "onCmdSetValue", VALUEFUNC(_wrap_FXDockTitle_onCmdSetValue), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "onCmdSetStringValue", VALUEFUNC(_wrap_FXDockTitle_onCmdSetStringValue), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "onCmdGetStringValue", VALUEFUNC(_wrap_FXDockTitle_onCmdGetStringValue), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "caption=", VALUEFUNC(_wrap_FXDockTitle_captione___), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "caption", VALUEFUNC(_wrap_FXDockTitle_caption), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "font=", VALUEFUNC(_wrap_FXDockTitle_fonte___), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "font", VALUEFUNC(_wrap_FXDockTitle_font), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "captionColor", VALUEFUNC(_wrap_FXDockTitle_captionColor), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "captionColor=", VALUEFUNC(_wrap_FXDockTitle_captionColore___), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "justify=", VALUEFUNC(_wrap_FXDockTitle_justifye___), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "justify", VALUEFUNC(_wrap_FXDockTitle_justify), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "save", VALUEFUNC(_wrap_FXDockTitle_save), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "load", VALUEFUNC(_wrap_FXDockTitle_load), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "create", VALUEFUNC(_wrap_FXDockTitle_create), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "detach", VALUEFUNC(_wrap_FXDockTitle_detach), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "destroy", VALUEFUNC(_wrap_FXDockTitle_destroy), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "resize", VALUEFUNC(_wrap_FXDockTitle_resize), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXDockTitle_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXDockTitle_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXDockTitle_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXDockTitle_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "canFocus", VALUEFUNC(_wrap_FXDockTitle_canFocus), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "setFocus", VALUEFUNC(_wrap_FXDockTitle_setFocus), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "killFocus", VALUEFUNC(_wrap_FXDockTitle_killFocus), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "changeFocus", VALUEFUNC(_wrap_FXDockTitle_changeFocus), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "setDefault", VALUEFUNC(_wrap_FXDockTitle_setDefault), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "enable", VALUEFUNC(_wrap_FXDockTitle_enable), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "disable", VALUEFUNC(_wrap_FXDockTitle_disable), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "raiseWindow", VALUEFUNC(_wrap_FXDockTitle_raiseWindow), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "lower", VALUEFUNC(_wrap_FXDockTitle_lower), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "move", VALUEFUNC(_wrap_FXDockTitle_move), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "position", VALUEFUNC(_wrap_FXDockTitle_position), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "layout", VALUEFUNC(_wrap_FXDockTitle_layout), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "recalc", VALUEFUNC(_wrap_FXDockTitle_recalc), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "reparent", VALUEFUNC(_wrap_FXDockTitle_reparent), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "show", VALUEFUNC(_wrap_FXDockTitle_show), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "hide", VALUEFUNC(_wrap_FXDockTitle_hide), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "isComposite", VALUEFUNC(_wrap_FXDockTitle_isComposite), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "contains", VALUEFUNC(_wrap_FXDockTitle_contains), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXDockTitle_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "setBackColor", VALUEFUNC(_wrap_FXDockTitle_setBackColor), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "tr", VALUEFUNC(_wrap_FXDockTitle_tr), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "dropEnable", VALUEFUNC(_wrap_FXDockTitle_dropEnable), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "dropDisable", VALUEFUNC(_wrap_FXDockTitle_dropDisable), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "setShape", VALUEFUNC(_wrap_FXDockTitle_setShape), -1);
+  rb_define_method(SwigClassFXDockTitle.klass, "clearShape", VALUEFUNC(_wrap_FXDockTitle_clearShape), -1);
+  SwigClassFXDockTitle.mark = (void (*)(void *)) FXRbDockTitle::markfunc;
+  SwigClassFXDockTitle.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXDockTitle.trackObjects = 0;
+  rb_define_const(mFox, "TOOLBARGRIP_SINGLE", SWIG_From_int(static_cast< int >(TOOLBARGRIP_SINGLE)));
+  rb_define_const(mFox, "TOOLBARGRIP_DOUBLE", SWIG_From_int(static_cast< int >(TOOLBARGRIP_DOUBLE)));
+  
+  SwigClassFXToolBarGrip.klass = rb_define_class_under(mFox, "FXToolBarGrip", ((swig_class *) SWIGTYPE_p_FXDockHandler->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXToolBarGrip, (void *) &SwigClassFXToolBarGrip);
+  rb_define_alloc_func(SwigClassFXToolBarGrip.klass, _wrap_FXToolBarGrip_allocate);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "initialize", VALUEFUNC(_wrap_new_FXToolBarGrip), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "onPaint", VALUEFUNC(_wrap_FXToolBarGrip_onPaint), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "onEnter", VALUEFUNC(_wrap_FXToolBarGrip_onEnter), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "onLeave", VALUEFUNC(_wrap_FXToolBarGrip_onLeave), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "setDoubleBar", VALUEFUNC(_wrap_FXToolBarGrip_setDoubleBar), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "isDoubleBar", VALUEFUNC(_wrap_FXToolBarGrip_isDoubleBar), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "setActiveColor", VALUEFUNC(_wrap_FXToolBarGrip_setActiveColor), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "getActiveColor", VALUEFUNC(_wrap_FXToolBarGrip_getActiveColor), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "save", VALUEFUNC(_wrap_FXToolBarGrip_save), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "load", VALUEFUNC(_wrap_FXToolBarGrip_load), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "create", VALUEFUNC(_wrap_FXToolBarGrip_create), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "detach", VALUEFUNC(_wrap_FXToolBarGrip_detach), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "destroy", VALUEFUNC(_wrap_FXToolBarGrip_destroy), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "resize", VALUEFUNC(_wrap_FXToolBarGrip_resize), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXToolBarGrip_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXToolBarGrip_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXToolBarGrip_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXToolBarGrip_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "canFocus", VALUEFUNC(_wrap_FXToolBarGrip_canFocus), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "setFocus", VALUEFUNC(_wrap_FXToolBarGrip_setFocus), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "killFocus", VALUEFUNC(_wrap_FXToolBarGrip_killFocus), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "changeFocus", VALUEFUNC(_wrap_FXToolBarGrip_changeFocus), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "setDefault", VALUEFUNC(_wrap_FXToolBarGrip_setDefault), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "enable", VALUEFUNC(_wrap_FXToolBarGrip_enable), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "disable", VALUEFUNC(_wrap_FXToolBarGrip_disable), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "raiseWindow", VALUEFUNC(_wrap_FXToolBarGrip_raiseWindow), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "lower", VALUEFUNC(_wrap_FXToolBarGrip_lower), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "move", VALUEFUNC(_wrap_FXToolBarGrip_move), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "position", VALUEFUNC(_wrap_FXToolBarGrip_position), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "layout", VALUEFUNC(_wrap_FXToolBarGrip_layout), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "recalc", VALUEFUNC(_wrap_FXToolBarGrip_recalc), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "reparent", VALUEFUNC(_wrap_FXToolBarGrip_reparent), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "show", VALUEFUNC(_wrap_FXToolBarGrip_show), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "hide", VALUEFUNC(_wrap_FXToolBarGrip_hide), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "isComposite", VALUEFUNC(_wrap_FXToolBarGrip_isComposite), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "contains", VALUEFUNC(_wrap_FXToolBarGrip_contains), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXToolBarGrip_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "setBackColor", VALUEFUNC(_wrap_FXToolBarGrip_setBackColor), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "tr", VALUEFUNC(_wrap_FXToolBarGrip_tr), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "dropEnable", VALUEFUNC(_wrap_FXToolBarGrip_dropEnable), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "dropDisable", VALUEFUNC(_wrap_FXToolBarGrip_dropDisable), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "setShape", VALUEFUNC(_wrap_FXToolBarGrip_setShape), -1);
+  rb_define_method(SwigClassFXToolBarGrip.klass, "clearShape", VALUEFUNC(_wrap_FXToolBarGrip_clearShape), -1);
+  SwigClassFXToolBarGrip.mark = (void (*)(void *)) FXRbToolBarGrip::markfunc;
+  SwigClassFXToolBarGrip.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXToolBarGrip.trackObjects = 0;
+  
+  SwigClassFXToolBarShell.klass = rb_define_class_under(mFox, "FXToolBarShell", ((swig_class *) SWIGTYPE_p_FXTopWindow->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXToolBarShell, (void *) &SwigClassFXToolBarShell);
+  rb_define_alloc_func(SwigClassFXToolBarShell.klass, _wrap_FXToolBarShell_allocate);
+  rb_define_method(SwigClassFXToolBarShell.klass, "initialize", VALUEFUNC(_wrap_new_FXToolBarShell), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "onPaint", VALUEFUNC(_wrap_FXToolBarShell_onPaint), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "setFrameStyle", VALUEFUNC(_wrap_FXToolBarShell_setFrameStyle), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "getFrameStyle", VALUEFUNC(_wrap_FXToolBarShell_getFrameStyle), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "getBorderWidth", VALUEFUNC(_wrap_FXToolBarShell_getBorderWidth), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "setHiliteColor", VALUEFUNC(_wrap_FXToolBarShell_setHiliteColor), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "getHiliteColor", VALUEFUNC(_wrap_FXToolBarShell_getHiliteColor), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "setShadowColor", VALUEFUNC(_wrap_FXToolBarShell_setShadowColor), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "getShadowColor", VALUEFUNC(_wrap_FXToolBarShell_getShadowColor), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "setBorderColor", VALUEFUNC(_wrap_FXToolBarShell_setBorderColor), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "getBorderColor", VALUEFUNC(_wrap_FXToolBarShell_getBorderColor), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "setBaseColor", VALUEFUNC(_wrap_FXToolBarShell_setBaseColor), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "getBaseColor", VALUEFUNC(_wrap_FXToolBarShell_getBaseColor), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "save", VALUEFUNC(_wrap_FXToolBarShell_save), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "load", VALUEFUNC(_wrap_FXToolBarShell_load), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "create", VALUEFUNC(_wrap_FXToolBarShell_create), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "detach", VALUEFUNC(_wrap_FXToolBarShell_detach), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "destroy", VALUEFUNC(_wrap_FXToolBarShell_destroy), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "resize", VALUEFUNC(_wrap_FXToolBarShell_resize), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXToolBarShell_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXToolBarShell_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXToolBarShell_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXToolBarShell_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "canFocus", VALUEFUNC(_wrap_FXToolBarShell_canFocus), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "setFocus", VALUEFUNC(_wrap_FXToolBarShell_setFocus), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "killFocus", VALUEFUNC(_wrap_FXToolBarShell_killFocus), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "changeFocus", VALUEFUNC(_wrap_FXToolBarShell_changeFocus), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "setDefault", VALUEFUNC(_wrap_FXToolBarShell_setDefault), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "enable", VALUEFUNC(_wrap_FXToolBarShell_enable), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "disable", VALUEFUNC(_wrap_FXToolBarShell_disable), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "raiseWindow", VALUEFUNC(_wrap_FXToolBarShell_raiseWindow), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "lower", VALUEFUNC(_wrap_FXToolBarShell_lower), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "move", VALUEFUNC(_wrap_FXToolBarShell_move), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "position", VALUEFUNC(_wrap_FXToolBarShell_position), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "layout", VALUEFUNC(_wrap_FXToolBarShell_layout), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "recalc", VALUEFUNC(_wrap_FXToolBarShell_recalc), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "reparent", VALUEFUNC(_wrap_FXToolBarShell_reparent), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "hide", VALUEFUNC(_wrap_FXToolBarShell_hide), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "isComposite", VALUEFUNC(_wrap_FXToolBarShell_isComposite), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "contains", VALUEFUNC(_wrap_FXToolBarShell_contains), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXToolBarShell_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "setBackColor", VALUEFUNC(_wrap_FXToolBarShell_setBackColor), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "tr", VALUEFUNC(_wrap_FXToolBarShell_tr), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "dropEnable", VALUEFUNC(_wrap_FXToolBarShell_dropEnable), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "dropDisable", VALUEFUNC(_wrap_FXToolBarShell_dropDisable), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "setShape", VALUEFUNC(_wrap_FXToolBarShell_setShape), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "clearShape", VALUEFUNC(_wrap_FXToolBarShell_clearShape), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "show", VALUEFUNC(_wrap_FXToolBarShell_show), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "maximize", VALUEFUNC(_wrap_FXToolBarShell_maximize), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "minimize", VALUEFUNC(_wrap_FXToolBarShell_minimize), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "restore", VALUEFUNC(_wrap_FXToolBarShell_restore), -1);
+  rb_define_method(SwigClassFXToolBarShell.klass, "close", VALUEFUNC(_wrap_FXToolBarShell_close), -1);
+  SwigClassFXToolBarShell.mark = (void (*)(void *)) FXRbToolBarShell::markfunc;
+  SwigClassFXToolBarShell.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXToolBarShell.trackObjects = 0;
+  
+  SwigClassFXRulerView.klass = rb_define_class_under(mFox, "FXRulerView", ((swig_class *) SWIGTYPE_p_FXScrollArea->clientdata)->klass);
+  SWIG_TypeClientData(SWIGTYPE_p_FXRulerView, (void *) &SwigClassFXRulerView);
+  rb_define_alloc_func(SwigClassFXRulerView.klass, _wrap_FXRulerView_allocate);
+  rb_define_method(SwigClassFXRulerView.klass, "initialize", VALUEFUNC(_wrap_new_FXRulerView), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "onPaint", VALUEFUNC(_wrap_FXRulerView_onPaint), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "onMotion", VALUEFUNC(_wrap_FXRulerView_onMotion), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "onCmdSetHelp", VALUEFUNC(_wrap_FXRulerView_onCmdSetHelp), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "onCmdGetHelp", VALUEFUNC(_wrap_FXRulerView_onCmdGetHelp), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "onCmdSetTip", VALUEFUNC(_wrap_FXRulerView_onCmdSetTip), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "onCmdGetTip", VALUEFUNC(_wrap_FXRulerView_onCmdGetTip), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "onQueryHelp", VALUEFUNC(_wrap_FXRulerView_onQueryHelp), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "onQueryTip", VALUEFUNC(_wrap_FXRulerView_onQueryTip), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "onDocChanged", VALUEFUNC(_wrap_FXRulerView_onDocChanged), -1);
+  rb_define_const(SwigClassFXRulerView.klass, "ID_HRULER", SWIG_From_int(static_cast< int >(FXRulerView::ID_HRULER)));
+  rb_define_const(SwigClassFXRulerView.klass, "ID_VRULER", SWIG_From_int(static_cast< int >(FXRulerView::ID_VRULER)));
+  rb_define_const(SwigClassFXRulerView.klass, "ID_LAST", SWIG_From_int(static_cast< int >(FXRulerView::ID_LAST)));
+  rb_define_method(SwigClassFXRulerView.klass, "horizontalRuler", VALUEFUNC(_wrap_FXRulerView_horizontalRuler), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "verticalRuler", VALUEFUNC(_wrap_FXRulerView_verticalRuler), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getDocumentX", VALUEFUNC(_wrap_FXRulerView_getDocumentX), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getDocumentY", VALUEFUNC(_wrap_FXRulerView_getDocumentY), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setDocumentWidth", VALUEFUNC(_wrap_FXRulerView_setDocumentWidth), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getDocumentWidth", VALUEFUNC(_wrap_FXRulerView_getDocumentWidth), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setDocumentHeight", VALUEFUNC(_wrap_FXRulerView_setDocumentHeight), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getDocumentHeight", VALUEFUNC(_wrap_FXRulerView_getDocumentHeight), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setDocumentColor", VALUEFUNC(_wrap_FXRulerView_setDocumentColor), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getDocumentColor", VALUEFUNC(_wrap_FXRulerView_getDocumentColor), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setHEdgeSpacing", VALUEFUNC(_wrap_FXRulerView_setHEdgeSpacing), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setVEdgeSpacing", VALUEFUNC(_wrap_FXRulerView_setVEdgeSpacing), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getHEdgeSpacing", VALUEFUNC(_wrap_FXRulerView_getHEdgeSpacing), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getVEdgeSpacing", VALUEFUNC(_wrap_FXRulerView_getVEdgeSpacing), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setHMarginLower", VALUEFUNC(_wrap_FXRulerView_setHMarginLower), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setHMarginUpper", VALUEFUNC(_wrap_FXRulerView_setHMarginUpper), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getHMarginLower", VALUEFUNC(_wrap_FXRulerView_getHMarginLower), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getHMarginUpper", VALUEFUNC(_wrap_FXRulerView_getHMarginUpper), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setVMarginLower", VALUEFUNC(_wrap_FXRulerView_setVMarginLower), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setVMarginUpper", VALUEFUNC(_wrap_FXRulerView_setVMarginUpper), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getVMarginLower", VALUEFUNC(_wrap_FXRulerView_getVMarginLower), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getVMarginUpper", VALUEFUNC(_wrap_FXRulerView_getVMarginUpper), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setHAlignment", VALUEFUNC(_wrap_FXRulerView_setHAlignment), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getHAlignment", VALUEFUNC(_wrap_FXRulerView_getHAlignment), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setVAlignment", VALUEFUNC(_wrap_FXRulerView_setVAlignment), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getVAlignment", VALUEFUNC(_wrap_FXRulerView_getVAlignment), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setArrowPosX", VALUEFUNC(_wrap_FXRulerView_setArrowPosX), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setArrowPosY", VALUEFUNC(_wrap_FXRulerView_setArrowPosY), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getArrowPosX", VALUEFUNC(_wrap_FXRulerView_getArrowPosX), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getArrowPosY", VALUEFUNC(_wrap_FXRulerView_getArrowPosY), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setHRulerFont", VALUEFUNC(_wrap_FXRulerView_setHRulerFont), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getHRulerFont", VALUEFUNC(_wrap_FXRulerView_getHRulerFont), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setVRulerFont", VALUEFUNC(_wrap_FXRulerView_setVRulerFont), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getVRulerFont", VALUEFUNC(_wrap_FXRulerView_getVRulerFont), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setHNumberTicks", VALUEFUNC(_wrap_FXRulerView_setHNumberTicks), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setVNumberTicks", VALUEFUNC(_wrap_FXRulerView_setVNumberTicks), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getHNumberTicks", VALUEFUNC(_wrap_FXRulerView_getHNumberTicks), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getVNumberTicks", VALUEFUNC(_wrap_FXRulerView_getVNumberTicks), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setHMajorTicks", VALUEFUNC(_wrap_FXRulerView_setHMajorTicks), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setVMajorTicks", VALUEFUNC(_wrap_FXRulerView_setVMajorTicks), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getHMajorTicks", VALUEFUNC(_wrap_FXRulerView_getHMajorTicks), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getVMajorTicks", VALUEFUNC(_wrap_FXRulerView_getVMajorTicks), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setHMediumTicks", VALUEFUNC(_wrap_FXRulerView_setHMediumTicks), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setVMediumTicks", VALUEFUNC(_wrap_FXRulerView_setVMediumTicks), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getHMediumTicks", VALUEFUNC(_wrap_FXRulerView_getHMediumTicks), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getVMediumTicks", VALUEFUNC(_wrap_FXRulerView_getVMediumTicks), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setHTinyTicks", VALUEFUNC(_wrap_FXRulerView_setHTinyTicks), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setVTinyTicks", VALUEFUNC(_wrap_FXRulerView_setVTinyTicks), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getHTinyTicks", VALUEFUNC(_wrap_FXRulerView_getHTinyTicks), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getVTinyTicks", VALUEFUNC(_wrap_FXRulerView_getVTinyTicks), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setHPixelsPerTick", VALUEFUNC(_wrap_FXRulerView_setHPixelsPerTick), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setVPixelsPerTick", VALUEFUNC(_wrap_FXRulerView_setVPixelsPerTick), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getHPixelsPerTick", VALUEFUNC(_wrap_FXRulerView_getHPixelsPerTick), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getVPixelsPerTick", VALUEFUNC(_wrap_FXRulerView_getVPixelsPerTick), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setHRulerStyle", VALUEFUNC(_wrap_FXRulerView_setHRulerStyle), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setVRulerStyle", VALUEFUNC(_wrap_FXRulerView_setVRulerStyle), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getHRulerStyle", VALUEFUNC(_wrap_FXRulerView_getHRulerStyle), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getVRulerStyle", VALUEFUNC(_wrap_FXRulerView_getVRulerStyle), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setHelpText", VALUEFUNC(_wrap_FXRulerView_setHelpText), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getHelpText", VALUEFUNC(_wrap_FXRulerView_getHelpText), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setTipText", VALUEFUNC(_wrap_FXRulerView_setTipText), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getTipText", VALUEFUNC(_wrap_FXRulerView_getTipText), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "save", VALUEFUNC(_wrap_FXRulerView_save), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "load", VALUEFUNC(_wrap_FXRulerView_load), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "create", VALUEFUNC(_wrap_FXRulerView_create), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "detach", VALUEFUNC(_wrap_FXRulerView_detach), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "destroy", VALUEFUNC(_wrap_FXRulerView_destroy), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "resize", VALUEFUNC(_wrap_FXRulerView_resize), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getDefaultWidth", VALUEFUNC(_wrap_FXRulerView_getDefaultWidth), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getDefaultHeight", VALUEFUNC(_wrap_FXRulerView_getDefaultHeight), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getWidthForHeight", VALUEFUNC(_wrap_FXRulerView_getWidthForHeight), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getHeightForWidth", VALUEFUNC(_wrap_FXRulerView_getHeightForWidth), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "canFocus", VALUEFUNC(_wrap_FXRulerView_canFocus), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setFocus", VALUEFUNC(_wrap_FXRulerView_setFocus), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "killFocus", VALUEFUNC(_wrap_FXRulerView_killFocus), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "changeFocus", VALUEFUNC(_wrap_FXRulerView_changeFocus), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setDefault", VALUEFUNC(_wrap_FXRulerView_setDefault), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "enable", VALUEFUNC(_wrap_FXRulerView_enable), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "disable", VALUEFUNC(_wrap_FXRulerView_disable), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "raiseWindow", VALUEFUNC(_wrap_FXRulerView_raiseWindow), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "lower", VALUEFUNC(_wrap_FXRulerView_lower), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "move", VALUEFUNC(_wrap_FXRulerView_move), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "layout", VALUEFUNC(_wrap_FXRulerView_layout), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "recalc", VALUEFUNC(_wrap_FXRulerView_recalc), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "reparent", VALUEFUNC(_wrap_FXRulerView_reparent), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "show", VALUEFUNC(_wrap_FXRulerView_show), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "hide", VALUEFUNC(_wrap_FXRulerView_hide), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "isComposite", VALUEFUNC(_wrap_FXRulerView_isComposite), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "contains", VALUEFUNC(_wrap_FXRulerView_contains), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "doesSaveUnder", VALUEFUNC(_wrap_FXRulerView_doesSaveUnder), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setBackColor", VALUEFUNC(_wrap_FXRulerView_setBackColor), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "tr", VALUEFUNC(_wrap_FXRulerView_tr), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "dropEnable", VALUEFUNC(_wrap_FXRulerView_dropEnable), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "dropDisable", VALUEFUNC(_wrap_FXRulerView_dropDisable), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "setShape", VALUEFUNC(_wrap_FXRulerView_setShape), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "clearShape", VALUEFUNC(_wrap_FXRulerView_clearShape), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getViewportHeight", VALUEFUNC(_wrap_FXRulerView_getViewportHeight), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getViewportWidth", VALUEFUNC(_wrap_FXRulerView_getViewportWidth), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getContentHeight", VALUEFUNC(_wrap_FXRulerView_getContentHeight), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "getContentWidth", VALUEFUNC(_wrap_FXRulerView_getContentWidth), -1);
+  rb_define_method(SwigClassFXRulerView.klass, "position", VALUEFUNC(_wrap_FXRulerView_position), -1);
+  SwigClassFXRulerView.mark = (void (*)(void *)) FXRbRulerView::markfunc;
+  SwigClassFXRulerView.destroy = (void (*)(void *)) FXRbObject::freefunc;
+  SwigClassFXRulerView.trackObjects = 0;
+}
+
diff --git a/fox-includes/FX4Splitter.h b/fox-includes/FX4Splitter.h
deleted file mode 100755
index 1e2d9cbd..00000000
--- a/fox-includes/FX4Splitter.h
+++ /dev/null
@@ -1,180 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       F o u r - W a y   S p l i t t e r                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1999,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FX4Splitter.h 2360 2006-03-29 04:10:56Z lyle $                       *
-********************************************************************************/
-#ifndef FX4SPLITTER_H
-#define FX4SPLITTER_H
-
-#ifndef FXCOMPOSITE_H
-#include "FXComposite.h"
-#endif
-
-namespace FX {
-
-// Splitter options
-enum {
-  FOURSPLITTER_TRACKING = 0x00008000,	// Track continuously during split
-  FOURSPLITTER_NORMAL   = 0
-  };
-
-
-
-/**
-* The four-way splitter is a layout manager which manages
-* four children like four panes in a window.
-* You can use a four-way splitter for example in a CAD program
-* where you may want to maintain three orthographic views, and
-* one oblique view of a model.
-* The four-way splitter allows interactive repartitioning of the
-* panes by means of moving the central splitter bars.
-* When the four-way splitter is itself resized, each child is
-* proportionally resized, maintaining the same split-percentage.
-* The four-way splitter widget sends a SEL_CHANGED to its target
-* during the resizing of the panes; at the end of the resize interaction,
-* it sends a SEL_COMMAND to signify that the resize operation is complete.
-*/
-class FXAPI FX4Splitter : public FXComposite {
-  FXDECLARE(FX4Splitter)
-private:
-  FXint     splitx;         // Current x split
-  FXint     splity;         // Current y split
-  FXint     barsize;        // Size of the splitter bar
-  FXint     fhor;           // Horizontal split fraction
-  FXint     fver;           // Vertical split fraction
-  FXint     offx;
-  FXint     offy;
-  FXuchar   mode;
-protected:
-  FX4Splitter();
-  FXuchar getMode(FXint x,FXint y);
-  void moveSplit(FXint x,FXint y);
-  void drawSplit(FXint x,FXint y,FXuint m);
-  void adjustLayout();
-private:
-  FX4Splitter(const FX4Splitter&);
-  FX4Splitter &operator=(const FX4Splitter&);
-public:
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onFocusUp(FXObject*,FXSelector,void*);
-  long onFocusDown(FXObject*,FXSelector,void*);
-  long onFocusLeft(FXObject*,FXSelector,void*);
-  long onFocusRight(FXObject*,FXSelector,void*);
-  long onCmdExpand(FXObject*,FXSelector,void*);
-  long onUpdExpand(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ExpandNone        = 0,                                  /// None expanded
-    ExpandTopLeft     = 1,                                  /// Expand top left child
-    ExpandTopRight    = 2,                                  /// Expand top right child
-    ExpandBottomLeft  = 4,                                  /// Expand bottom left child
-    ExpandBottomRight = 8,                                  /// Expand bottom right child
-    ExpandTop         = ExpandTopLeft|ExpandTopRight,       /// Expand top children
-    ExpandBottom      = ExpandBottomLeft|ExpandBottomRight, /// Expand bottom children
-    ExpandLeft        = ExpandTopLeft|ExpandBottomLeft,     /// Expand left children
-    ExpandRight       = ExpandTopRight|ExpandBottomRight,   /// Expand right children
-    ExpandAll         = ExpandLeft|ExpandRight              /// Expand all children
-    };
-public:
-  enum {
-    ID_EXPAND_NONE=FXComposite::ID_LAST+ExpandNone,
-    ID_EXPAND_TOP=ID_EXPAND_NONE+ExpandTop,
-    ID_EXPAND_BOTTOM=ID_EXPAND_NONE+ExpandBottom,
-    ID_EXPAND_LEFT=ID_EXPAND_NONE+ExpandLeft,
-    ID_EXPAND_RIGHT=ID_EXPAND_NONE+ExpandRight,
-    ID_EXPAND_TOPLEFT=ID_EXPAND_NONE+ExpandTopLeft,
-    ID_EXPAND_TOPRIGHT=ID_EXPAND_NONE+ExpandTopRight,
-    ID_EXPAND_BOTTOMLEFT=ID_EXPAND_NONE+ExpandBottomLeft,
-    ID_EXPAND_BOTTOMRIGHT=ID_EXPAND_NONE+ExpandBottomRight,
-    ID_EXPAND_ALL=ID_EXPAND_NONE+ExpandAll,
-    ID_LAST
-    };
-public:
-
-  /// Create 4-way splitter, initially shown as four unexpanded panes
-  FX4Splitter(FXComposite* p,FXuint opts=FOURSPLITTER_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Create 4-way splitter, initially shown as four unexpanded panes; notifies target about size changes
-  FX4Splitter(FXComposite* p,FXObject* tgt,FXSelector sel,FXuint opts=FOURSPLITTER_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Get top left child, if any
-  FXWindow *getTopLeft() const;
-
-  /// Get top right child, if any
-  FXWindow *getTopRight() const;
-
-  /// Get bottom left child, if any
-  FXWindow *getBottomLeft() const;
-
-  /// Get bottom right child, if any
-  FXWindow *getBottomRight() const;
-
-  /// Get horizontal split fraction
-  FXint getHSplit() const { return fhor; }
-
-  /// Get vertical split fraction
-  FXint getVSplit() const { return fver; }
-
-  /// Change horizontal split fraction
-  void setHSplit(FXint s);
-
-  /// Change vertical split fraction
-  void setVSplit(FXint s);
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Get default width
-  virtual FXint getDefaultWidth();
-
-  /// Get default height
-  virtual FXint getDefaultHeight();
-
-  /// Return current splitter style
-  FXuint getSplitterStyle() const;
-
-  /// Change splitter style
-  void setSplitterStyle(FXuint style);
-
-  /// Change splitter bar width
-  void setBarSize(FXint bs);
-
-  /// Get splitter bar width
-  FXint getBarSize() const { return barsize; }
-
-  /// Change set of expanded children
-  void setExpanded(FXuint set=FX4Splitter::ExpandAll);
-
-  /// Get set of expanded children
-  FXuint getExpanded() const;
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FX7Segment.h b/fox-includes/FX7Segment.h
deleted file mode 100644
index ebc4930c..00000000
--- a/fox-includes/FX7Segment.h
+++ /dev/null
@@ -1,146 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                7 - S e g m e n t   D i s p l a y   W i d g e t                *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2004,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FX7Segment.h 2360 2006-03-29 04:10:56Z lyle $                        *
-********************************************************************************/
-#ifndef FX7SEGMENT_H
-#define FX7SEGMENT_H
-
-#ifndef FXFRAME_H
-#include "FXFrame.h"
-#endif
-
-
-namespace FX {
-
-/// 7 Segment styles
-enum {
-  SEVENSEGMENT_NORMAL   = 0,            /// Draw segments normally
-  SEVENSEGMENT_SHADOW   = 0x00080000    /// Draw shadow under the segments
-  };
-
-
-/**
-* Seven-segment (eg LCD/watch style) widget, useful for making
-* indicators and timers.  Besides numbers, the seven-segment
-* display widget can also display some letters and punctuations.
-*/
-class FXAPI FX7Segment : public FXFrame {
-  FXDECLARE(FX7Segment)
-protected:
-  FXString label;       // Text being shown
-  FXColor  textColor;   // Text color
-  FXint    thickness;   // Segment thickness
-  FXint    cellwidth;   // Width of cell
-  FXint    cellheight;  // height of cell
-  FXString tip;         // Tooltip
-  FXString help;        // Help message
-protected:
-  FX7Segment();
-private:
-  FX7Segment(const FX7Segment&);
-  FX7Segment &operator=(const FX7Segment&);
-  void drawCells(FXDCWindow &dc,FXint x,FXint y,FXint cw,FXint ch);
-  void drawSegments(FXDCWindow &dc,FXint x,FXint y,FXint w,FXint h,FXuint segments);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-  long onCmdSetRealValue(FXObject*,FXSelector,void*);
-  long onCmdSetStringValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-  long onCmdGetRealValue(FXObject*,FXSelector,void*);
-  long onCmdGetStringValue(FXObject*,FXSelector,void*);
-  long onCmdSetHelp(FXObject*,FXSelector,void*);
-  long onCmdGetHelp(FXObject*,FXSelector,void*);
-  long onCmdSetTip(FXObject*,FXSelector,void*);
-  long onCmdGetTip(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-public:
-
-  /// Create a seven segment display
-  FX7Segment(FXComposite* p,const FXString& text,FXuint opts=SEVENSEGMENT_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Set the text for this label
-  void setText(const FXString& text);
-
-  /// Get the text for this label
-  FXString getText() const { return label; }
-
-  /// Change text color
-  void setTextColor(FXColor clr);
-
-  /// Return text color
-  FXColor getTextColor() const { return textColor; }
-
-  /// Get/set cell width
-  void setCellWidth(FXint w);
-  FXint getCellWidth() const { return cellwidth; }
-
-  /// Get/set cell height
-  void setCellHeight(FXint h);
-  FXint getCellHeight() const { return cellheight; }
-
-  /// Get/set segment thickness
-  void setThickness(FXint t);
-  FXint getThickness() const { return thickness; }
-
-  /// Change 7 segment style
-  void set7SegmentStyle(FXuint style);
-
-  /// Get current 7 segment style
-  FXuint get7SegmentStyle() const;
-
-  /// Set the current text-justification mode.
-  void setJustify(FXuint mode);
-
-  /// Get the current text-justification mode.
-  FXuint getJustify() const;
-
-  /// Set the status line help text
-  void setHelpText(const FXString& text){ help=text; }
-
-  /// Get the status line help text
-  const FXString& getHelpText() const { return help; }
-
-  /// Set the tool tip message
-  void setTipText(const FXString& text){ tip=text; }
-
-  /// Get the tool tip message
-  const FXString& getTipText() const { return tip; }
-
-  /// Save to a stream
-  virtual void save(FXStream &store) const;
-
-  /// Load from a stream
-  virtual void load(FXStream &store);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FX885910Codec.h b/fox-includes/FX885910Codec.h
deleted file mode 100644
index c997e4fa..00000000
--- a/fox-includes/FX885910Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FX885910CODEC_H
-#define FX885910CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// ISO-8859-10 Codec
-class FXAPI FX885910Codec : public FXTextCodec {
-  FXDECLARE(FX885910Codec)
-public:
-  FX885910Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FX885910Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FX885911Codec.h b/fox-includes/FX885911Codec.h
deleted file mode 100644
index 0691dd7b..00000000
--- a/fox-includes/FX885911Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FX885911CODEC_H
-#define FX885911CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// ISO-8859-11 Codec
-class FXAPI FX885911Codec : public FXTextCodec {
-  FXDECLARE(FX885911Codec)
-public:
-  FX885911Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FX885911Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FX885913Codec.h b/fox-includes/FX885913Codec.h
deleted file mode 100644
index 3cc12487..00000000
--- a/fox-includes/FX885913Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FX885913CODEC_H
-#define FX885913CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// ISO-8859-13 Codec
-class FXAPI FX885913Codec : public FXTextCodec {
-  FXDECLARE(FX885913Codec)
-public:
-  FX885913Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FX885913Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FX885914Codec.h b/fox-includes/FX885914Codec.h
deleted file mode 100644
index 934dcc18..00000000
--- a/fox-includes/FX885914Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FX885914CODEC_H
-#define FX885914CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// ISO-8859-14 Codec
-class FXAPI FX885914Codec : public FXTextCodec {
-  FXDECLARE(FX885914Codec)
-public:
-  FX885914Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FX885914Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FX885915Codec.h b/fox-includes/FX885915Codec.h
deleted file mode 100644
index 5f30e5f2..00000000
--- a/fox-includes/FX885915Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FX885915CODEC_H
-#define FX885915CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// ISO-8859-15 Codec
-class FXAPI FX885915Codec : public FXTextCodec {
-  FXDECLARE(FX885915Codec)
-public:
-  FX885915Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FX885915Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FX885916Codec.h b/fox-includes/FX885916Codec.h
deleted file mode 100644
index cc02c111..00000000
--- a/fox-includes/FX885916Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FX885916CODEC_H
-#define FX885916CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// ISO-8859-16 Codec
-class FXAPI FX885916Codec : public FXTextCodec {
-  FXDECLARE(FX885916Codec)
-public:
-  FX885916Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FX885916Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FX88591Codec.h b/fox-includes/FX88591Codec.h
deleted file mode 100644
index 23be294b..00000000
--- a/fox-includes/FX88591Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FX88591CODEC_H
-#define FX88591CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// ISO-8859-1 Codec
-class FXAPI FX88591Codec : public FXTextCodec {
-  FXDECLARE(FX88591Codec)
-public:
-  FX88591Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FX88591Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FX88592Codec.h b/fox-includes/FX88592Codec.h
deleted file mode 100644
index c31f5f1a..00000000
--- a/fox-includes/FX88592Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FX88592CODEC_H
-#define FX88592CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// ISO-8859-2 Codec
-class FXAPI FX88592Codec : public FXTextCodec {
-  FXDECLARE(FX88592Codec)
-public:
-  FX88592Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FX88592Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FX88593Codec.h b/fox-includes/FX88593Codec.h
deleted file mode 100644
index e5aa1eef..00000000
--- a/fox-includes/FX88593Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FX88593CODEC_H
-#define FX88593CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// ISO-8859-3 Codec
-class FXAPI FX88593Codec : public FXTextCodec {
-  FXDECLARE(FX88593Codec)
-public:
-  FX88593Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FX88593Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FX88594Codec.h b/fox-includes/FX88594Codec.h
deleted file mode 100644
index f2d4d57e..00000000
--- a/fox-includes/FX88594Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FX88594CODEC_H
-#define FX88594CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// ISO-8859-4 Codec
-class FXAPI FX88594Codec : public FXTextCodec {
-  FXDECLARE(FX88594Codec)
-public:
-  FX88594Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FX88594Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FX88595Codec.h b/fox-includes/FX88595Codec.h
deleted file mode 100644
index 79a738ff..00000000
--- a/fox-includes/FX88595Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FX88595CODEC_H
-#define FX88595CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// ISO-8859-5 Codec
-class FXAPI FX88595Codec : public FXTextCodec {
-  FXDECLARE(FX88595Codec)
-public:
-  FX88595Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FX88595Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FX88596Codec.h b/fox-includes/FX88596Codec.h
deleted file mode 100644
index ecc251a8..00000000
--- a/fox-includes/FX88596Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FX88596CODEC_H
-#define FX88596CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// ISO-8859-6 Codec
-class FXAPI FX88596Codec : public FXTextCodec {
-  FXDECLARE(FX88596Codec)
-public:
-  FX88596Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FX88596Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FX88597Codec.h b/fox-includes/FX88597Codec.h
deleted file mode 100644
index 6dff0b35..00000000
--- a/fox-includes/FX88597Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FX88597CODEC_H
-#define FX88597CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// ISO-8859-7 Codec
-class FXAPI FX88597Codec : public FXTextCodec {
-  FXDECLARE(FX88597Codec)
-public:
-  FX88597Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FX88597Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FX88598Codec.h b/fox-includes/FX88598Codec.h
deleted file mode 100644
index c5c16189..00000000
--- a/fox-includes/FX88598Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FX88598CODEC_H
-#define FX88598CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// ISO-8859-8 Codec
-class FXAPI FX88598Codec : public FXTextCodec {
-  FXDECLARE(FX88598Codec)
-public:
-  FX88598Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FX88598Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FX88599Codec.h b/fox-includes/FX88599Codec.h
deleted file mode 100644
index 82ff9e11..00000000
--- a/fox-includes/FX88599Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FX88599CODEC_H
-#define FX88599CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// ISO-8859-9 Codec
-class FXAPI FX88599Codec : public FXTextCodec {
-  FXDECLARE(FX88599Codec)
-public:
-  FX88599Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FX88599Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXAccelTable.h b/fox-includes/FXAccelTable.h
deleted file mode 100755
index 0ae95d70..00000000
--- a/fox-includes/FXAccelTable.h
+++ /dev/null
@@ -1,131 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                   A c c e l e r a t o r   T a b l e   C l a s s               *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXAccelTable.h 2335 2006-01-28 02:33:03Z lyle $                      *
-********************************************************************************/
-#ifndef FXACCELTABLE_H
-#define FXACCELTABLE_H
-
-#ifndef FXOBJECT_H
-#include "FXObject.h"
-#endif
-
-namespace FX {
-
-
-/**
-* The accelerator table sends a message to a specific
-* target object when the indicated key and modifier combination
-* is pressed.
-*/
-class FXAPI FXAccelTable : public FXObject {
-  FXDECLARE(FXAccelTable)
-protected:
-  struct FXAccelKey {
-    FXObject    *target;    // Target object of message
-    FXSelector   messagedn; // Message being sent
-    FXSelector   messageup; // Message being sent
-    FXHotKey     code;      // Keysym and modifier mask to match
-    };
-private:
-  FXAccelKey *key;          // Accelerator table
-  FXuint      max;          // Largest table index
-  FXuint      num;          // Number of entries
-private:
-  void resize(FXuint m);
-private:
-  FXAccelTable(const FXAccelTable&);
-  FXAccelTable &operator=(const FXAccelTable&);
-public:
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct empty accelerator table
-  FXAccelTable();
-
-  /// Add an accelerator into the table
-  void addAccel(FXHotKey hotkey,FXObject* target=NULL,FXSelector seldn=0,FXSelector selup=0);
-
-  /// Remove an accelerator from the table
-  void removeAccel(FXHotKey hotkey);
-
-  /// Return true if accelerator specified
-  bool hasAccel(FXHotKey hotkey) const;
-
-  /// Return target object of the given accelerator
-  FXObject* targetOfAccel(FXHotKey hotkey) const;
-
-  /**
-  * Parse accelerator from string, yielding modifier and
-  * key code.  For example, parseAccel("Ctl+Shift+X")
-  * yields MKUINT(KEY_X,CONTROLMASK|SHIFTMASK).
-  */
-  friend FXAPI FXHotKey parseAccel(const FXString& string);
-
-  /**
-  * Unparse hot key comprising modifier and key code back
-  * into a string suitable for parsing with fxparseHotKey.
-  */
-  friend FXAPI FXString unparseAccel(FXHotKey key);
-
-  /**
-  * Parse hot key from string, yielding modifier and
-  * key code.  For example, parseHotKey(""Salt && &Pepper!"")
-  * yields MKUINT(KEY_p,ALTMASK).
-  */
-  friend FXAPI FXHotKey parseHotKey(const FXString& string);
-
-  /**
-  * Obtain hot key offset in string, or -1 if not found.
-  * For example, findHotKey("Salt && &Pepper!") yields 7.
-  * Note that this is the byte-offset, not the character
-  * index!
-  */
-  friend FXAPI FXint findHotKey(const FXString& string);
-
-  /**
-  * Strip hot key combination from the string.
-  * For example, stripHotKey("Salt && &Pepper") should
-  * yield "Salt & Pepper".
-  */
-  friend FXAPI FXString stripHotKey(const FXString& string);
-
-  /// Save table to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load table from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXAccelTable();
-  };
-
-
-extern FXAPI FXHotKey parseAccel(const FXString& string);
-extern FXAPI FXString unparseAccel(FXHotKey key);
-extern FXAPI FXHotKey parseHotKey(const FXString& string);
-extern FXAPI FXint findHotKey(const FXString& string);
-extern FXAPI FXString stripHotKey(const FXString& string);
-
-}
-
-#endif
diff --git a/fox-includes/FXApp.h b/fox-includes/FXApp.h
deleted file mode 100755
index bf8e48e5..00000000
--- a/fox-includes/FXApp.h
+++ /dev/null
@@ -1,829 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                     A p p l i c a t i o n   O b j e c t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXApp.h 2342 2006-02-10 14:24:44Z lyle $                            *
-********************************************************************************/
-#ifndef FXAPP_H
-#define FXAPP_H
-
-#ifndef FXOBJECT_H
-#include "FXObject.h"
-#endif
-
-namespace FX {
-
-
-// Forward declarations
-class FXApp;
-class FXWindow;
-class FXIcon;
-class FXBitmap;
-class FXCursor;
-class FXRootWindow;
-class FXMainWindow;
-class FXPopup;
-class FXFont;
-class FXDC;
-class FXDCWindow;
-class FXVisual;
-class FXGLVisual;
-class FXGLContext;
-class FXTranslator;
-class FXComposeContext;
-
-// Opaque FOX objects
-struct FXTimer;
-struct FXChore;
-struct FXSignal;
-struct FXRepaint;
-struct FXInput;
-struct FXInvocation;
-
-
-
-/// File input modes for addInput
-enum FXInputMode {
-  INPUT_NONE   = 0,                 /// Inactive
-  INPUT_READ   = 1,                 /// Read input fd
-  INPUT_WRITE  = 2,                 /// Write input fd
-  INPUT_EXCEPT = 4                  /// Except input fd
-  };
-
-
-/// All ways of being modal
-enum FXModality {
-  MODAL_FOR_NONE,                 /// Non modal event loop (dispatch normally)
-  MODAL_FOR_WINDOW,               /// Modal dialog (beep if outside of modal dialog)
-  MODAL_FOR_POPUP                 /// Modal for popup (always dispatch to popup)
-  };
-
-
-/// Default cursors provided by the application
-enum FXDefaultCursor {
-  DEF_ARROW_CURSOR,                     /// Arrow cursor
-  DEF_RARROW_CURSOR,                    /// Reverse arrow cursor
-  DEF_TEXT_CURSOR,                      /// Text cursor
-  DEF_HSPLIT_CURSOR,                    /// Horizontal split cursor
-  DEF_VSPLIT_CURSOR,                    /// Vertical split cursor
-  DEF_XSPLIT_CURSOR,                    /// Cross split cursor
-  DEF_SWATCH_CURSOR,                    /// Color swatch drag cursor
-  DEF_MOVE_CURSOR,                      /// Move cursor
-  DEF_DRAGH_CURSOR,                     /// Resize horizontal edge
-  DEF_DRAGV_CURSOR,                     /// Resize vertical edge
-  DEF_DRAGTL_CURSOR,                    /// Resize upper-leftcorner
-  DEF_DRAGBR_CURSOR=DEF_DRAGTL_CURSOR,  /// Resize bottom-right corner
-  DEF_DRAGTR_CURSOR,                    /// Resize upper-right corner
-  DEF_DRAGBL_CURSOR=DEF_DRAGTR_CURSOR,  /// Resize bottom-left corner
-  DEF_DNDSTOP_CURSOR,                   /// Drag and drop stop
-  DEF_DNDCOPY_CURSOR,                   /// Drag and drop copy
-  DEF_DNDMOVE_CURSOR,                   /// Drag and drop move
-  DEF_DNDLINK_CURSOR,                   /// Drag and drop link
-  DEF_CROSSHAIR_CURSOR,                 /// Cross hair cursor
-  DEF_CORNERNE_CURSOR,                  /// North-east cursor
-  DEF_CORNERNW_CURSOR,                  /// North-west cursor
-  DEF_CORNERSE_CURSOR,                  /// South-east cursor
-  DEF_CORNERSW_CURSOR,                  /// South-west cursor
-  DEF_HELP_CURSOR,                      /// Help arrow cursor
-  DEF_HAND_CURSOR,                      /// Hand cursor
-  DEF_ROTATE_CURSOR,                    /// Rotate cursor
-  DEF_WAIT_CURSOR                       /// Wait cursor
-  };
-
-
-
-/// FOX Event
-struct FXAPI FXEvent {
-  FXuint      type;           /// Event type
-  FXuint      time;           /// Time of last event
-  FXint       win_x;          /// Window-relative x-coord
-  FXint       win_y;          /// Window-relative y-coord
-  FXint       root_x;         /// Root x-coord
-  FXint       root_y;         /// Root y-coord
-  FXint       state;          /// Mouse button and modifier key state
-  FXint       code;           /// Button, Keysym, or mode; DDE Source
-  FXString    text;           /// Text of keyboard event
-  FXint       last_x;         /// Window-relative x-coord of previous mouse location
-  FXint       last_y;         /// Window-relative y-coord of previous mouse location
-  FXint       click_x;        /// Window-relative x-coord of mouse press
-  FXint       click_y;        /// Window-relative y-coord of mouse press
-  FXint       rootclick_x;    /// Root-relative x-coord of mouse press
-  FXint       rootclick_y;    /// Root-relative y-coord of mouse press
-  FXuint      click_time;     /// Time of mouse button press
-  FXuint      click_button;   /// Mouse button pressed
-  FXint       click_count;    /// Click-count
-  FXbool      moved;          /// Moved cursor since press
-  FXRectangle rect;           /// Rectangle
-  FXbool      synthetic;      /// True if synthetic expose event
-  FXDragType  target;         /// Target drag type being requested
-  };
-
-
-/// Application Object
-class FXAPI FXApp : public FXObject {
-  FXDECLARE(FXApp)
-
-  // We've got many friends
-  friend class FXId;
-  friend class FXBitmap;
-  friend class FXImage;
-  friend class FXIcon;
-  friend class FXCursor;
-  friend class FXDrawable;
-  friend class FXWindow;
-  friend class FXShell;
-  friend class FXRootWindow;
-  friend class FXTopWindow;
-  friend class FXMainWindow;
-  friend class FXPopup;
-  friend class FXFont;
-  friend class FXVisual;
-  friend class FXGLVisual;
-  friend class FXGLContext;
-  friend class FXDC;
-  friend class FXDCWindow;
-  friend class FXDragCorner;
-  friend class FXDockHandler;
-  friend class FXComposeContext;
-
-private:
-
-  // Platform independent private data
-  void            *display;             // Display we're talking to
-  const FXchar    *dpy;                 // Initial display guess
-  FXHash           hash;                // Window handle hash table
-  FXRegistry       registry;            // Application setting registry
-  FXWindow        *activeWindow;        // Active toplevel window
-  FXWindow        *cursorWindow;        // Window under the cursor
-  FXWindow        *mouseGrabWindow;     // Window which grabbed the mouse
-  FXWindow        *keyboardGrabWindow;  // Window which grabbed the keyboard
-  FXWindow        *keyWindow;           // Window in which keyboard key was pressed
-  FXWindow        *selectionWindow;     // Selection window
-  FXWindow        *clipboardWindow;     // Clipboard window
-  FXWindow        *dropWindow;          // Drop target window
-  FXWindow        *dragWindow;          // Drag source window
-  FXWindow        *refresher;           // GUI refresher pointer
-  FXWindow        *refresherstop;       // GUI refresher end pointer
-  FXPopup         *popupWindow;         // Current popup window
-  FXRootWindow    *root;                // Root window
-  FXVisual        *monoVisual;          // Monochrome visual
-  FXVisual        *defaultVisual;       // Default [color] visual
-  FXTimer         *timers;              // List of timers, sorted by time
-  FXChore         *chores;              // List of chores
-  FXRepaint       *repaints;            // Unhandled repaint rectangles
-  FXTimer         *timerrecs;           // List of recycled timer records
-  FXChore         *chorerecs;           // List of recycled chore records
-  FXRepaint       *repaintrecs;         // List of recycled repaint records
-  FXInvocation    *invocation;          // Modal loop invocation
-  FXSignal        *signals;             // Array of signal records
-  FXint            nsignals;            // Number of signals
-  FXFont          *normalFont;          // Normal font
-  FXFont          *stockFont;           // Stock font
-  FXMutex          appMutex;            // Application wide mutex
-  FXEvent          event;               // Event
-  FXuint           stickyMods;          // Sticky modifier state
-  FXInput         *inputs;              // Input file descriptors being watched
-  FXint            ninputs;             // Number of inputs
-  FXint            maxinput;            // Maximum input number
-  FXuchar         *ddeData;             // DDE array
-  FXuint           ddeSize;             // DDE array size
-  FXuint           maxcolors;           // Maximum number of colors to allocate
-  FXuint           typingSpeed;         // Typing speed
-  FXuint           clickSpeed;          // Double click speed
-  FXuint           scrollSpeed;         // Scroll speed
-  FXuint           scrollDelay;         // Scroll delay
-  FXuint           blinkSpeed;          // Cursor blink speed
-  FXuint           animSpeed;           // Animation speed
-  FXuint           menuPause;           // Menu popup delay
-  FXuint           tooltipPause;        // Tooltip popup delay
-  FXuint           tooltipTime;         // Tooltip display time
-  FXint            dragDelta;           // Minimum distance considered a move
-  FXint            wheelLines;          // Scroll by this many lines
-  FXint            scrollBarSize;       // Scrollbar size
-  FXColor          borderColor;         // Border color
-  FXColor          baseColor;           // Background color of GUI controls
-  FXColor          hiliteColor;         // Highlight color of GUI controls
-  FXColor          shadowColor;         // Shadow color of GUI controls
-  FXColor          backColor;           // Background color
-  FXColor          foreColor;           // Foreground color
-  FXColor          selforeColor;        // Select foreground color
-  FXColor          selbackColor;        // Select background color
-  FXColor          tipforeColor;        // Tooltip foreground color
-  FXColor          tipbackColor;        // Tooltip background color
-  FXColor          selMenuTextColor;    // Select foreground color in menus
-  FXColor          selMenuBackColor;    // Select background color in menus
-  FXCursor        *waitCursor;          // Current wait cursor
-  FXuint           waitCount;           // Number of times wait cursor was called
-  FXuint           windowCount;         // Number of windows
-  FXCursor        *cursor[DEF_WAIT_CURSOR+1];
-  FXTranslator    *translator;          // Message translator
-  FXint                appArgc;         // Argument count
-  const FXchar *const *appArgv;         // Argument vector
-  const FXchar    *inputmethod;         // Input method name
-  const FXchar    *inputstyle;          // Input method style
-  bool             initialized;         // Has been initialized
-
-private:
-  static FXApp    *app;                 // Application pointer
-
-  // Platform dependent private stuff
-#ifndef WIN32
-private:
-  FXID             wmDeleteWindow;      // Catch delete window
-  FXID             wmQuitApp;           // Catch quit application
-  FXID             wmProtocols;         // Window manager protocols
-  FXID             wmMotifHints;        // Motif hints
-  FXID             wmTakeFocus;         // Focus explicitly set by app
-  FXID             wmState;             // Window state
-  FXID             wmNetState;          // Extended Window Manager window state
-  FXID             wmNetIconName;       // Extended Window Manager icon name
-  FXID             wmNetWindowName;     // Extended Window Manager window name
-  FXID             wmNetSupported;      // Extended Window Manager states list
-  FXID             wmNetWindowType;     // Extended Window Manager types
-  FXID             wmNetHMaximized;     // Extended Window Manager horizontally maximized
-  FXID             wmNetVMaximized;     // Extended Window Manager vertically maximized
-  FXID             wmNetMoveResize;     // Extended Window Manager drag corner
-  FXID             wmNetPing;           // Extended Window Manager ping
-  FXID             wmNetTypes[8];       // Extended Window Manager window types
-  FXID             wmNetStates[12];     // Extended Window Manager state
-  FXID             wmWindowRole;        // Window Role
-  FXID             wmClientLeader;      // Client leader
-  FXID             wmClientId;          // Client id
-  FXID             embedAtom;           // XEMBED support
-  FXID             embedInfoAtom;       // XEMBED info support
-  FXID             timestampAtom;       // Server time
-  FXID             ddeTargets;          // DDE targets atom
-  FXID             ddeAtom;             // DDE exchange atom
-  FXID             ddeDelete;           // DDE delete target atom
-  FXID             ddeIncr;             // DDE incremental data exchange atom
-  FXDragType      *ddeTypeList;         // DDE drop type list
-  FXuint           ddeNumTypes;         // DDE number of drop types
-  FXDragAction     ddeAction;           // DDE action
-  FXDragAction     ansAction;           // Reply action
-  FXID             xcbSelection;        // Clipboard selection
-  FXDragType      *xcbTypeList;         // Clipboard type list
-  FXuint           xcbNumTypes;         // Clipboard number of types on list
-  FXDragType      *xselTypeList;        // Selection type list
-  FXuint           xselNumTypes;        // Selection number of types on list
-  FXDragType      *xdndTypeList;        // XDND type list
-  FXuint           xdndNumTypes;        // XDND number of types
-  FXID             xdndProxy;           // XDND proxy atom
-  FXID             xdndAware;           // XDND awareness atom
-  FXID             xdndEnter;           // XDND enter window message
-  FXID             xdndLeave;           // XDND leave window message
-  FXID             xdndPosition;        // XDND position update message
-  FXID             xdndStatus;          // XDND status feedback message
-  FXID             xdndDrop;            // XDND drop message
-  FXID             xdndFinished;        // XDND finished message
-  FXID             xdndSelection;       // XDND selection atom
-  FXID             xdndActionMove;      // XDND Move action
-  FXID             xdndActionCopy;      // XDND Copy action
-  FXID             xdndActionLink;      // XDND Link action
-  FXID             xdndActionPrivate;   // XDND Private action
-  FXID             xdndTypes;           // XDND types list atom
-  FXID             xdndSource;          // XDND drag source window
-  FXID             xdndTarget;          // XDND drop target window
-  FXID             xdndProxyTarget;     // XDND window to set messages to
-  FXbool           xdndStatusPending;   // XDND waiting for status feedback
-  FXbool           xdndStatusReceived;  // XDND received at least one status
-  FXbool           xdndWantUpdates;     // XDND target wants new positions while in rect
-  FXbool           xdndFinishSent;      // XDND finish sent
-  FXRectangle      xdndRect;            // XDND rectangle bounding target
-  FXint            xrreventbase;        // XRR event base
-  FXID             stipples[23];        // Standard stipple patterns
-  void            *r_fds;               // Set of file descriptors for read
-  void            *w_fds;               // Set of file descriptors for write
-  void            *e_fds;               // Set of file descriptors for exceptions
-  void            *xim;                 // Input method
-  FXbool           shmi;                // Use XSHM Image possible
-  FXbool           shmp;                // Use XSHM Pixmap possible
-  FXbool           synchronize;         // Synchronized
-
-#else
-
-  FXushort         ddeTargets;          // DDE targets atom
-  FXushort         ddeAtom;             // DDE Exchange Atom
-  FXDragType       ddeDelete;           // DDE Delete Target Atom
-  FXDragType      *ddeTypeList;         // DDE drop type list
-  FXuint           ddeNumTypes;         // DDE number of drop types
-  FXDragAction     ddeAction;           // DDE action
-  FXDragAction     ansAction;           // Reply action
-  FXDragType      *xselTypeList;        // Selection type list
-  FXuint           xselNumTypes;        // Selection number of types on list
-  void*            xdndTypes;           // Handle to file mapping object for types list
-  FXushort         xdndAware;           // XDND awareness atom
-  FXID             xdndSource;          // XDND drag source window
-  FXID             xdndTarget;          // XDND drop target window
-  FXbool           xdndStatusPending;   // XDND waiting for status feedback
-  FXbool           xdndFinishPending;   // XDND waiting for drop-confirmation
-  FXbool           xdndStatusReceived;  // XDND received at least one status
-  FXbool           xdndFinishSent;      // XDND finish sent
-  FXRectangle      xdndRect;            // XDND rectangle bounding target
-  FXID             stipples[17];        // Standard stipple bitmaps
-  void           **handles;             // Waitable object handles
-
-#endif
-
-private:
-
-  // Internal helper functions
-  FXApp(const FXApp&);
-  FXApp &operator=(const FXApp&);
-  static void signalhandler(int sig);
-  static void immediatesignalhandler(int sig);
-  void leaveWindow(FXWindow *window,FXWindow *ancestor);
-  void enterWindow(FXWindow *window,FXWindow *ancestor);
-  void selectionSetData(const FXWindow* window,FXDragType type,FXuchar* data,FXuint size);
-  void selectionGetData(const FXWindow* window,FXDragType type,FXuchar*& data,FXuint& size);
-  void selectionGetTypes(const FXWindow* window,FXDragType*& types,FXuint& numtypes);
-  void clipboardSetData(const FXWindow* window,FXDragType type,FXuchar* data,FXuint size);
-  void clipboardGetData(const FXWindow* window,FXDragType type,FXuchar*& data,FXuint& size);
-  void clipboardGetTypes(const FXWindow* window,FXDragType*& types,FXuint& numtypes);
-  void dragdropSetData(const FXWindow* window,FXDragType type,FXuchar* data,FXuint size);
-  void dragdropGetData(const FXWindow* window,FXDragType type,FXuchar*& data,FXuint& size);
-  void dragdropGetTypes(const FXWindow* window,FXDragType*& types,FXuint& numtypes);
-#ifndef WIN32
-  void addRepaint(FXID win,FXint x,FXint y,FXint w,FXint h,FXbool synth=0);
-  void removeRepaints(FXID win,FXint x,FXint y,FXint w,FXint h);
-  void scrollRepaints(FXID win,FXint dx,FXint dy);
-  static void imcreatecallback(void*,FXApp*,void*);
-  static void imdestroycallback(void*,FXApp*,void*);
-#else
-  static long CALLBACK wndproc(FXID hwnd,unsigned int iMsg,unsigned int wParam,long lParam);
-protected:
-  virtual long dispatchEvent(FXID hwnd,unsigned int iMsg,unsigned int wParam,long lParam);
-#endif
-
-protected:
-
-  /// Return TRUE when new raw event is available
-  virtual bool getNextEvent(FXRawEvent& ev,bool blocking=true);
-
-  /// Dispatch raw event
-  virtual bool dispatchEvent(FXRawEvent& ev);
-
-public:
-  long onCmdQuit(FXObject*,FXSelector,void*);
-  long onCmdDump(FXObject*,FXSelector,void*);
-  long onCmdHover(FXObject*,FXSelector,void*);
-
-public:
-
-  /// Messages applications understand
-  enum {
-    ID_QUIT=1,    /// Terminate the application normally
-    ID_DUMP,      /// Dump the current widget tree
-    ID_HOVER,
-    ID_LAST
-    };
-
-public:
-
-  /// Information
-  static const FXuchar copyright[];     /// Copyright notice of library
-
-public:
-
-  /**
-  * Construct application object; the name and vendor strings are used
-  * as keys into the registry database for this application's settings.
-  * Only one single application object can be constructed.
-  */
-  FXApp(const FXString& name="Application",const FXString& vendor="FoxDefault");
-
-  /// Get application name
-  const FXString& getAppName() const { return registry.getAppKey(); }
-
-  /// Get vendor name
-  const FXString& getVendorName() const { return registry.getVendorKey(); }
-
-  /// Connection to display; this is called by init()
-  bool openDisplay(const FXchar* dpyname=NULL);
-
-  /// Close connection to the display
-  bool closeDisplay();
-
-  /// Return pointer
-  void* getDisplay() const { return display; }
-
-  /// Is application initialized
-  bool isInitialized() const { return initialized; }
-
-  /// Get argument count
-  FXint getArgc() const { return appArgc; }
-
-  /// Get argument vector
-  const FXchar *const *getArgv() const { return appArgv; }
-
-  /// Return true if input method support
-  bool hasInputMethod() const;
-
-  /// Get default visual
-  FXVisual* getDefaultVisual() const { return defaultVisual; }
-
-  /// Change default visual
-  void setDefaultVisual(FXVisual* vis);
-
-  /// Get monochrome visual
-  FXVisual* getMonoVisual() const { return monoVisual; }
-
-  /// Get root Window
-  FXRootWindow* getRootWindow() const { return root; }
-
-  /// Set root Window
-  void setRootWindow(FXRootWindow* rt);
-
-  /// Return window at the end of the focus chain
-  FXWindow *getFocusWindow() const;
-
-  /// Get the window under the cursor, if any
-  FXWindow *getCursorWindow() const { return cursorWindow; }
-
-  /// Get the active toplevel window, if any
-  FXWindow *getActiveWindow() const { return activeWindow; }
-
-  /// Get current popup window, if any
-  FXPopup* getPopupWindow() const { return popupWindow; }
-
-  /// Find window from id
-  FXWindow* findWindowWithId(FXID xid) const;
-
-  /// Find window from root x,y, starting from given window
-  FXWindow* findWindowAt(FXint rx,FXint ry,FXID window=0) const;
-
-  /// Create application's windows
-  virtual void create();
-
-  /// Destroy application's windows
-  virtual void destroy();
-
-  /// Detach application's windows
-  virtual void detach();
-
-  /**
-  * Add timeout message to be sent to target object in ms milliseconds;
-  * the timer fires only once after the interval expires.  The void* ptr
-  * is user data which will be passed into the void* ptr of the message
-  * handler.  If a timer with the same target and message already exists,
-  * it will be rescheduled.
-  */
-  void addTimeout(FXObject* tgt,FXSelector sel,FXuint ms=1000,void* ptr=NULL);
-
-  /**
-  * Remove timeout identified by tgt and sel.
-  */
-  void removeTimeout(FXObject* tgt,FXSelector sel);
-
-  /**
-  * Return TRUE if given timeout has been set
-  */
-  bool hasTimeout(FXObject *tgt,FXSelector sel) const;
-
-  /**
-  * Return, in ms, the time remaining until the given timer fires.
-  * If the timer is past due, 0 is returned.  If there is no such
-  * timer, infinity (UINT_MAX) is returned.
-  */
-  FXuint remainingTimeout(FXObject *tgt,FXSelector sel);
-
-  /**
-  * Process any timeouts due at this time.
-  */
-  void handleTimeouts();
-
-  /**
-  * Add a idle processing message to be sent to target object when
-  * the system becomes idle, i.e. there are no events to be processed.
-  * The void* ptr is user data which will be passed into the void* ptr
-  * of the message handler. If a chore with the same target and message
-  * already exists, it will be rescheduled.
-  */
-  void addChore(FXObject* tgt,FXSelector sel,void *ptr=NULL);
-
-  /**
-  * Remove idle processing message identified by tgt and sel.
-  */
-  void removeChore(FXObject* tgt,FXSelector sel);
-
-  /**
-  * Return TRUE if given chore has been set
-  */
-  bool hasChore(FXObject *tgt,FXSelector sel) const;
-
-  /**
-  * Add signal processing message to be sent to target object when
-  * the signal sig is raised; flags are to be set as per POSIX definitions.
-  * When immediate is TRUE, the message will be sent to the target right away;
-  * this should be used with extreme care as the application is interrupted
-  * at an unknown point in its execution.
-  */
-  void addSignal(FXint sig,FXObject* tgt,FXSelector sel,FXbool immediate=FALSE,FXuint flags=0);
-
-  /// Remove signal message for signal sig
-  void removeSignal(FXint sig);
-
-  /**
-  * Add a file descriptor fd to be watched for activity as determined
-  * by mode, where mode is a bitwise OR (INPUT_READ, INPUT_WRITE, INPUT_EXCEPT).
-  * A message of type SEL_IO_READ, SEL_IO_WRITE, or SEL_IO_EXCEPT will be sent
-  * to the target when the specified activity is detected on the file descriptor.
-  */
-  bool addInput(FXInputHandle fd,FXuint mode,FXObject *tgt,FXSelector sel);
-
-  /**
-  * Remove input message and target object for the specified file descriptor
-  * and mode, which is a bitwise OR of (INPUT_READ, INPUT_WRITE, INPUT_EXCEPT).
-  */
-  bool removeInput(FXInputHandle fd,FXuint mode);
-
-  /// Return key state of given key
-  bool getKeyState(FXuint keysym) const;
-
-  /// Peek to determine if there's an event
-  bool peekEvent();
-
-  /// Perform one event dispatch; return true if event was dispatched
-  bool runOneEvent(bool blocking=true);
-
-  /**
-  * Run the main application event loop until stop() is called,
-  * and return the exit code passed as argument to stop().
-  */
-  FXint run();
-
-  /**
-  * Run an event loop till some flag becomes non-zero, and
-  * then return.
-  */
-  FXint runUntil(FXuint& condition);
-
-  /**
-  * Run event loop while events are available, non-modally.
-  * Return when no more events, timers, or chores are outstanding.
-  */
-  FXint runWhileEvents();
-
-  /**
-  * Run event loop while there are events are available in the queue.
-  * Returns 1 when all events in the queue have been handled, and 0 when
-  * the event loop was terminated due to stop() or stopModal().
-  * Except for the modal window and its children, user input to all windows
-  * is blocked; if the modal window is NULL, all user input is blocked.
-  */
-  FXint runModalWhileEvents(FXWindow* window=NULL);
-
-  /**
-  * Run modal event loop, blocking keyboard and mouse events to all windows
-  * until stopModal is called.
-  */
-  FXint runModal();
-
-  /**
-  * Run a modal event loop for the given window, until stop() or stopModal() is
-  * called. Except for the modal window and its children, user input to all
-  * windows is blocked; if the modal window is NULL all user input is blocked.
-  */
-  FXint runModalFor(FXWindow* window);
-
-  /**
-  * Run modal while window is shown, or until stop() or stopModal() is called.
-  * Except for the modal window and its children, user input to all windows
-  * is blocked; if the modal window is NULL all user input is blocked.
-  */
-  FXint runModalWhileShown(FXWindow* window);
-
-  /**
-  * Run popup menu while shown, until stop() or stopModal() is called.
-  * Also returns when entering previous cascading popup menu.
-  */
-  FXint runPopup(FXWindow* window);
-
-  /// True if the window is modal
-  bool isModal(FXWindow* window) const;
-
-  /// Return window of current modal loop
-  FXWindow* getModalWindow() const;
-
-  /// Return mode of current modal loop
-  FXModality getModality() const;
-
-  /**
-  * Terminate the outermost event loop, and all inner modal loops;
-  * All more deeper nested event loops will be terminated with code equal
-  * to 0, while the outermost event loop will return code equal to value.
-  */
-  void stop(FXint value=0);
-
-  /**
-  * Break out of the matching modal loop, returning code equal to value.
-  * All deeper nested event loops are terminated with code equal to 0.
-  */
-  void stopModal(FXWindow* window,FXint value=0);
-
-  /**
-  * Break out of the innermost modal loop, returning code equal to value.
-  */
-  void stopModal(FXint value=0);
-
-  /// Force GUI refresh
-  void forceRefresh();
-
-  /// Schedule a refresh
-  void refresh();
-
-  /// Flush pending repaints
-  void flush(bool sync=false);
-
-  /**
-  * Paint all windows marked for repainting.
-  * On return all the applications windows have been painted.
-  */
-  void repaint();
-
-  /**
-  * Initialize application.
-  * Parses and removes common command line arguments, reads the registry.
-  * Finally, if connect is TRUE, it opens the display.
-  */
-  virtual void init(int& argc,char** argv,bool connect=true);
-
-  /**
-  * Exit application.
-  * Closes the display and writes the registry.
-  */
-  virtual void exit(FXint code=0);
-
-  /**
-  * Return a reference to the registry.  The registry keeps
-  * settings and configuration information for an application,
-  * which are automatically loaded when the application starts
-  * up, and saved when the application terminates.
-  */
-  FXRegistry& reg(){ return registry; }
-
-  /// Register new DND type
-  FXDragType registerDragType(const FXString& name) const;
-
-  /// Get drag type name
-  FXString getDragTypeName(FXDragType type) const;
-
-  /// Return drag window if a drag operation is in progress
-  FXWindow* getDragWindow() const { return dragWindow; }
-
-  /// Beep
-  void beep();
-
-  /// Return application instance
-  static inline FXApp* instance(){ return app; }
-
-  /// Change default font
-  void setNormalFont(FXFont* font);
-
-  /// Return default font
-  FXFont* getNormalFont() const { return normalFont; }
-
-  /// Begin of wait-cursor block; wait-cursor blocks may be nested.
-  void beginWaitCursor();
-
-  /// End of wait-cursor block
-  void endWaitCursor();
-
-  /// Change to a new wait cursor
-  void setWaitCursor(FXCursor *cur);
-
-  /// Return current wait cursor
-  FXCursor* getWaitCursor() const { return waitCursor; }
-
-  /// Obtain a default cursor
-  FXCursor* getDefaultCursor(FXDefaultCursor which) const { return cursor[which]; }
-
-  /// Change default cursor
-  void setDefaultCursor(FXDefaultCursor which,FXCursor* cur);
-
-  /**
-  * Write a window and its children, and all resources reachable from this
-  * window, into the stream store. (EXPERIMENTAL!)
-  */
-  FXbool writeWindow(FXStream& store,FXWindow *window);
-
-  /**
-  * Read a window and its children from the stream store, and append
-  * it under father; note it is initially not created yet. (EXPERIMENTAL!)
-  */
-  FXbool readWindow(FXStream& store,FXWindow*& window,FXWindow* father,FXWindow* owner);
-
-  /**
-  * Return a reference to the application-wide mutex.
-  * Normally, the main user interface thread holds this mutex,
-  * insuring that no other threads are modifying data during the
-  * processing of user interface messages. However, whenever the
-  * main user interface thread blocks for messages, it releases
-  * this mutex, to allow other threads to modify the same data.
-  * When a new message becomes available, the main user interface
-  * thread regains the mutex prior to dispatching the message.
-  * Other threads should hold this mutex only for short durations,
-  * so as to not starve the main user interface thread.
-  */
-  FXMutex& mutex(){ return appMutex; }
-
-  /**
-  * Change message translator.
-  * The new translator will be owned by FXApp.
-  */
-  void setTranslator(FXTranslator* trans);
-
-  /// Return message translator
-  FXTranslator* getTranslator() const { return translator; }
-
-  /// Obtain application-wide settings
-  FXuint getTypingSpeed() const { return typingSpeed; }
-  FXuint getClickSpeed() const { return clickSpeed; }
-  FXuint getScrollSpeed() const { return scrollSpeed; }
-  FXuint getScrollDelay() const { return scrollDelay; }
-  FXuint getBlinkSpeed() const { return blinkSpeed; }
-  FXuint getAnimSpeed() const { return animSpeed; }
-  FXuint getMenuPause() const { return menuPause; }
-  FXuint getTooltipPause() const { return tooltipPause; }
-  FXuint getTooltipTime() const { return tooltipTime; }
-  FXint getDragDelta() const { return dragDelta; }
-  FXint getWheelLines() const { return wheelLines; }
-  FXint getScrollBarSize() const { return scrollBarSize; }
-
-  /// Change application-wide settings
-  void setTypingSpeed(FXuint speed);
-  void setClickSpeed(FXuint speed);
-  void setScrollSpeed(FXuint speed);
-  void setScrollDelay(FXuint delay);
-  void setBlinkSpeed(FXuint speed);
-  void setAnimSpeed(FXuint speed);
-  void setMenuPause(FXuint pause);
-  void setTooltipPause(FXuint pause);
-  void setTooltipTime(FXuint time);
-  void setDragDelta(FXint delta);
-  void setWheelLines(FXint lines);
-  void setScrollBarSize(FXint size);
-
-  /// Obtain default colors
-  FXColor getBorderColor() const { return borderColor; }
-  FXColor getBaseColor() const { return baseColor; }
-  FXColor getHiliteColor() const { return hiliteColor; }
-  FXColor getShadowColor() const { return shadowColor; }
-  FXColor getBackColor() const { return backColor; }
-  FXColor getForeColor() const { return foreColor; }
-  FXColor getSelforeColor() const { return selforeColor; }
-  FXColor getSelbackColor() const { return selbackColor; }
-  FXColor getTipforeColor() const { return tipforeColor; }
-  FXColor getTipbackColor() const { return tipbackColor; }
-  FXColor getSelMenuTextColor() const { return selMenuTextColor; }
-  FXColor getSelMenuBackColor() const { return selMenuBackColor; }
-
-  /// Change default colors
-  void setBorderColor(FXColor color);
-  void setBaseColor(FXColor color);
-  void setHiliteColor(FXColor color);
-  void setShadowColor(FXColor color);
-  void setBackColor(FXColor color);
-  void setForeColor(FXColor color);
-  void setSelforeColor(FXColor color);
-  void setSelbackColor(FXColor color);
-  void setTipforeColor(FXColor color);
-  void setTipbackColor(FXColor color);
-  void setSelMenuTextColor(FXColor color);
-  void setSelMenuBackColor(FXColor color);
-
-  /// Get number of existing windows
-  FXuint getWindowCount() const { return windowCount; }
-
-  /// Save
-  virtual void save(FXStream& store) const;
-
-  /// Load
-  virtual void load(FXStream& store);
-
-  /// Dump widget information
-  void dumpWidgets() const;
-
-  /// Destroy the application and all reachable resources
-  virtual ~FXApp();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXArray.h b/fox-includes/FXArray.h
deleted file mode 100755
index 6d13763e..00000000
--- a/fox-includes/FXArray.h
+++ /dev/null
@@ -1,232 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                          G e n e r i c   A r r a y                            *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXArray.h 2335 2006-01-28 02:33:03Z lyle $                           *
-********************************************************************************/
-#ifndef FXARRAY_H
-#define FXARRAY_H
-
-#ifndef FXELEMENT_H
-#include "FXElement.h"
-#endif
-
-namespace FX {
-
-
-/// Array of some generic type
-template<class TYPE>
-class FXArray {
-protected:
-  TYPE  *ptr;   // Data array
-  FXint  num;   // Number in array
-public:
-
-  /// Create as empty
-  FXArray():ptr(NULL),num(0){
-    }
-
-  /// Create with given size n
-  FXArray(FXint n):ptr(NULL),num(0){
-    if(allocElms(ptr,n)){ constructElms(ptr,n); num=n; }
-    }
-
-  /// Create initialized from another array
-  FXArray(const FXArray<TYPE>& src):ptr(NULL),num(0){
-    if(allocElms(ptr,src.num)){ constructElms(ptr,src.num); copyElms(ptr,src.ptr,src.num); num=src.num; }
-    }
-
-  /// Create initialized with n copies of object
-  FXArray(const TYPE& src,FXint n):ptr(NULL),num(0){
-    if(allocElms(ptr,n)){ constructElms(ptr,n); fillElms(ptr,src,n); num=n; }
-    }
-
-  /// Create initialized with array of n objects
-  FXArray(const TYPE* src,FXint n):ptr(NULL),num(0){
-    if(allocElms(ptr,n)){ constructElms(ptr,n); copyElms(ptr,src,n); num=n; }
-    }
-
-  /// Return number of elements
-  FXint no() const { return num; }
-
-  /// Change number of elements to n
-  bool no(FXint n){
-    if(n!=num){
-      if(n<num){
-        destructElms(ptr+n,num-n);
-        if(!resizeElms(ptr,n)) return false;
-        }
-      else{
-        if(!resizeElms(ptr,n)) return false;
-        constructElms(ptr+num,n-num);
-        }
-      num=n;
-      }
-    return true;
-    }
-
-  /// Assign from another list
-  FXArray<TYPE>& operator=(const FXArray<TYPE>& src){
-    if(ptr!=src.ptr){ no(src.num); copyElms(ptr,src.ptr,src.num); }
-    return *this;
-    }
-
-  /// Index into array
-  TYPE& operator[](FXint i){ return ptr[i]; }
-  const TYPE& operator[](FXint i) const { return ptr[i]; }
-
-  /// Index into list
-  TYPE& at(FXint i){ return ptr[i]; }
-  const TYPE& at(FXint i) const { return ptr[i]; }
-
-  /// Return pointer to list
-  TYPE* data() const { return ptr; }
-
-  /// Adopt array from source
-  FXArray<TYPE>& adopt(FXArray<TYPE>& src){
-    no(0);
-    ptr=src.ptr; src.ptr=NULL;
-    num=src.num; src.num=0;
-    return *this;
-    }
-
-  /// Assign object p to list
-  FXArray<TYPE>& assign(const TYPE& src){
-    if(no(1)){ ptr[0]=src; }
-    return *this;
-    }
-
-  /// Assign n copies of object to list
-  FXArray<TYPE>& assign(const TYPE& src,FXint n){
-    if(no(n)){ fillElms(ptr,src,n); }
-    return *this;
-    }
-
-  /// Assign n objects to list
-  FXArray<TYPE>& assign(const TYPE* src,FXint n){
-    if(no(n)){ copyElms(ptr,src,n); }
-    return *this;
-    }
-
-  /// Assign n objects to list
-  FXArray<TYPE>& assign(const FXArray<TYPE>& src){
-    if(no(src.num)){ copyElms(ptr,src.ptr,src.num); }
-    return *this;
-    }
-
-  /// Insert an object
-  FXArray<TYPE>& insert(FXint pos,const TYPE& src){
-    if(no(num+1)){ moveElms(ptr+pos+1,ptr+pos,num-pos-1); ptr[pos]=src; }
-    return *this;
-    }
-
-  /// Insert n copies of object at specified position
-  FXArray<TYPE>& insert(FXint pos,const TYPE& src,FXint n){
-    if(no(num+n)){ moveElms(ptr+pos+n,ptr+pos,num-pos-n); fillElms(ptr+pos,src,n); }
-    return *this;
-    }
-
-  /// Insert n objects at specified position
-  FXArray<TYPE>& insert(FXint pos,const TYPE* src,FXint n){
-    if(no(num+n)){ moveElms(ptr+pos+n,ptr+pos,num-pos-n); copyElms(ptr+pos,src,n); }
-    return *this;
-    }
-
-  /// Insert n objects at specified position
-  FXArray<TYPE>& insert(FXint pos,const FXArray<TYPE>& src){
-    if(no(num+src.num)){ moveElms(ptr+pos+src.num,ptr+pos,num-pos-src.num); copyElms(ptr+pos,src.ptr,src.num); }
-    return *this;
-    }
-
-  /// Prepend object
-  FXArray<TYPE>& prepend(const TYPE& src){
-    if(no(num+1)){ moveElms(ptr+1,ptr,num-1); ptr[0]=src; }
-    return *this;
-    }
-
-  /// Prepend n copies of object
-  FXArray<TYPE>& prepend(const TYPE& src,FXint n){
-    if(no(num+n)){ moveElms(ptr+n,ptr,num-n); fillElms(ptr,src,n); }
-    return *this;
-    }
-
-  /// Prepend n objects
-  FXArray<TYPE>& prepend(const TYPE* src,FXint n){
-    if(no(num+n)){ moveElms(ptr+n,ptr,num-n); copyElms(ptr,src,n); }
-    return *this;
-    }
-
-  /// Prepend n objects
-  FXArray<TYPE>& prepend(const FXArray<TYPE>& src){
-    if(no(num+src.num)){ moveElms(ptr+src.num,ptr,num-src.num); copyElms(ptr,src.ptr,src.num); }
-    return *this;
-    }
-
-  /// Append object
-  FXArray<TYPE>& append(const TYPE& src){
-    if(no(num+1)){ ptr[num-1]=src; }
-    return *this;
-    }
-
-  /// Append n copies of object
-  FXArray<TYPE>& append(const TYPE& src,FXint n){
-    if(no(num+n)){ fillElms(ptr+num-n,src,n); }
-    return *this;
-    }
-
-  /// Append n objects
-  FXArray<TYPE>& append(const TYPE* src,FXint n){
-    if(no(num+n)){ copyElms(ptr+num-n,src,n); }
-    return *this;
-    }
-
-  /// Append n objects
-  FXArray<TYPE>& append(const FXArray<TYPE>& src){
-    if(no(num+src.num)){ copyElms(ptr+num-src.num,src.ptr,src.num); }
-    return *this;
-    }
-
-  /// Remove object at pos
-  FXArray<TYPE>& erase(FXint pos){
-    moveElms(ptr+pos,ptr+pos+1,num-pos-1); no(num-1);
-    return *this;
-    }
-
-  /// Remove n objects starting at pos
-  FXArray<TYPE>& erase(FXint pos,FXint n){
-    moveElms(ptr+pos,ptr+pos+n,num-n-pos); no(num-n);
-    return *this;
-    }
-
-  /// Remove all objects
-  FXArray<TYPE>& clear(){
-    destructElms(ptr,num); freeElms(ptr); num=0;
-    return *this;
-    }
-
-  /// Delete data
-  ~FXArray(){
-    destructElms(ptr,num); freeElms(ptr);
-    }
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXArrowButton.h b/fox-includes/FXArrowButton.h
deleted file mode 100755
index eadb34b3..00000000
--- a/fox-includes/FXArrowButton.h
+++ /dev/null
@@ -1,172 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                     A r r o w   B u t t o n   W i d g e t                     *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXArrowButton.h 2335 2006-01-28 02:33:03Z lyle $                     *
-********************************************************************************/
-#ifndef FXARROWBUTTON_H
-#define FXARROWBUTTON_H
-
-#ifndef FXFRAME_H
-#include "FXFrame.h"
-#endif
-
-namespace FX {
-
-
-// Arrow style options
-enum {
-  ARROW_NONE     = 0,		// No arrow
-  ARROW_UP       = 0x00080000,	// Arrow points up
-  ARROW_DOWN     = 0x00100000,	// Arrow points down
-  ARROW_LEFT     = 0x00200000,	// Arrow points left
-  ARROW_RIGHT    = 0x00400000,	// Arrow points right
-  ARROW_AUTO     = 0x00800000,  // Automatically fire when hovering mouse over button
-  ARROW_REPEAT   = 0x01000000,	// Button repeats if held down
-  ARROW_AUTOGRAY = 0x02000000,	// Automatically gray out when not updated
-  ARROW_AUTOHIDE = 0x04000000,	// Automatically hide when not updated
-  ARROW_TOOLBAR  = 0x08000000,	// Button is toolbar-style
-  ARROW_NORMAL   = FRAME_RAISED|FRAME_THICK|ARROW_UP
-  };
-
-
-/**
-* Button with an arrow; the arrow can point in any direction.
-* When clicked, the arrow button sends a SEL_COMMAND to its target.
-* When ARROW_REPEAT is passed, the arrow button sends a SEL_COMMAND
-* repeatedly while the button is pressed.
-* The option ARROW_AUTO together with ARROW_REPEAT makes the arrow
-* button work in repeat mode simply by hovering the cursor over it.
-*/
-class FXAPI FXArrowButton : public FXFrame {
-  FXDECLARE(FXArrowButton)
-protected:
-  FXColor   arrowColor;     // Arrow color
-  FXint     arrowSize;      // Arrow size
-  FXString  tip;            // Tooltip value
-  FXString  help;           // Help value
-  FXbool    state;          // State of button
-  FXbool    fired;          // Timer has fired
-protected:
-  FXArrowButton();
-private:
-  FXArrowButton(const FXArrowButton&);
-  FXArrowButton &operator=(const FXArrowButton&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onUpdate(FXObject*,FXSelector,void*);
-  long onEnter(FXObject*,FXSelector,void*);
-  long onLeave(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onRepeat(FXObject*,FXSelector,void*);
-  long onAuto(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onHotKeyPress(FXObject*,FXSelector,void*);
-  long onHotKeyRelease(FXObject*,FXSelector,void*);
-  long onCmdSetHelp(FXObject*,FXSelector,void*);
-  long onCmdGetHelp(FXObject*,FXSelector,void*);
-  long onCmdSetTip(FXObject*,FXSelector,void*);
-  long onCmdGetTip(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_REPEAT=FXFrame::ID_LAST,
-    ID_AUTO,
-    ID_LAST
-    };
-public:
-
-  /// Construct arrow button
-  FXArrowButton(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=ARROW_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Get default width
-  virtual FXint getDefaultWidth();
-
-  /// Get default height
-  virtual FXint getDefaultHeight();
-
-  /// Enable the button
-  virtual void enable();
-
-  /// Disable the button
-  virtual void disable();
-
-  /// Returns true because a button can receive focus
-  virtual bool canFocus() const;
-
-  /// Set the button state (where TRUE means the button is down)
-  void setState(FXbool s);
-
-  /// Get the button state (where TRUE means the button is down)
-  FXbool getState() const { return state; }
-
-  /// Set status line help text for this arrow button
-  void setHelpText(const FXString& text){ help=text; }
-
-  /// Get status line help text for this arrow button
-  const FXString& getHelpText() const { return help; }
-
-  /// Set tool tip message for this arrow button
-  void setTipText(const FXString& text){ tip=text; }
-
-  /// Get tool tip message for this arrow button
-  const FXString& getTipText() const { return tip; }
-
-  /// Set the arrow style flags
-  void setArrowStyle(FXuint style);
-
-  /// Get the arrow style flags
-  FXuint getArrowStyle() const;
-
-  /// Set the default arrow size
-  void setArrowSize(FXint size);
-
-  /// Get the default arrow size
-  FXint getArrowSize() const { return arrowSize; }
-
-  /// Set the current justification mode.
-  void setJustify(FXuint mode);
-
-  /// Get the current justification mode.
-  FXuint getJustify() const;
-
-  /// Get the fill color for the arrow
-  FXColor getArrowColor() const { return arrowColor; }
-
-  /// Set the fill color for the arrow
-  void setArrowColor(FXColor clr);
-
-  /// Save label to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load label from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXArrowButton();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXBMPIcon.h b/fox-includes/FXBMPIcon.h
deleted file mode 100755
index 28c01ea0..00000000
--- a/fox-includes/FXBMPIcon.h
+++ /dev/null
@@ -1,89 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        B M P   I c o n   O b j e c t                          *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXBMPIcon.h 2342 2006-02-10 14:24:44Z lyle $                         *
-********************************************************************************/
-#ifndef FXBMPICON_H
-#define FXBMPICON_H
-
-#ifndef FXICON_H
-#include "FXIcon.h"
-#endif
-
-namespace FX {
-
-
-/**
-* The BMP Icon class is a convenience class for working with icons in the
-* Microsoft Bitmap (.bmp) graphics file format.  This makes it possible to
-* use resources created with Windows development tools inside FOX without
-* need for graphics file format translators.  The bitmap loaded handles
-* 1, 4, and 8 bit paletted bitmaps, 16 and 24 bit RGB bitmaps, and
-* 32 bit RGBA bitmaps.
-*/
-class FXAPI FXBMPIcon : public FXIcon {
-  FXDECLARE(FXBMPIcon)
-protected:
-  FXBMPIcon(){}
-private:
-  FXBMPIcon(const FXBMPIcon&);
-  FXBMPIcon &operator=(const FXBMPIcon&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct icon from memory stream formatted in Microsoft BMP format
-  FXBMPIcon(FXApp* a,const void *pix=NULL,FXColor clr=FXRGB(192,192,192),FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Save pixels into stream in Microsoft bitmap format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in Microsoft bitmap format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy icon
-  virtual ~FXBMPIcon();
-  };
-
-
-/**
-* Check if stream contains a bitmap, return TRUE if so.
-*/
-extern FXAPI bool fxcheckBMP(FXStream& store);
-
-
-/**
-* Load an BMP (Microsoft Bitmap) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadBMP(FXStream& store,FXColor*& data,FXint& width,FXint& height);
-
-
-/**
-* Save an BMP (Microsoft Bitmap) file to a stream.
-*/
-extern FXAPI bool fxsaveBMP(FXStream& store,const FXColor *data,FXint width,FXint height);
-
-}
-
-#endif
diff --git a/fox-includes/FXBMPImage.h b/fox-includes/FXBMPImage.h
deleted file mode 100755
index c8088a7e..00000000
--- a/fox-includes/FXBMPImage.h
+++ /dev/null
@@ -1,89 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                            B M P   I m a g e   O b j e c t                    *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXBMPImage.h 2342 2006-02-10 14:24:44Z lyle $                        *
-********************************************************************************/
-#ifndef FXBMPIMAGE_H
-#define FXBMPIMAGE_H
-
-#ifndef FXIMAGE_H
-#include "FXImage.h"
-#endif
-
-namespace FX {
-
-
-/**
-* The BMP Image class is a convenience class for working with images in the
-* Microsoft Bitmap (.bmp) graphics file format.  This makes it possible to
-* use resources created with Windows development tools inside FOX without
-* need for graphics file format translators.  The bitmap loaded handles
-* 1, 4, and 8 bit paletted bitmaps, 16 and 24 bit RGB bitmaps, and
-* 32 bit RGBA bitmaps.
-*/
-class FXAPI FXBMPImage : public FXImage {
-  FXDECLARE(FXBMPImage)
-protected:
-  FXBMPImage(){}
-private:
-  FXBMPImage(const FXBMPImage&);
-  FXBMPImage &operator=(const FXBMPImage&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct image from memory stream formatted in Microsoft BMP format
-  FXBMPImage(FXApp* a,const void *pix=NULL,FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Save pixels into stream in Microsoft bitmap format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in Microsoft bitmap format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy icon
-  virtual ~FXBMPImage();
-  };
-
-
-/**
-* Check if stream contains a bitmap, return TRUE if so.
-*/
-extern FXAPI bool fxcheckBMP(FXStream& store);
-
-
-/**
-* Load an BMP (Microsoft Bitmap) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadBMP(FXStream& store,FXColor*& data,FXint& width,FXint& height);
-
-
-/**
-* Save an BMP (Microsoft Bitmap) file to a stream.
-*/
-extern FXAPI bool fxsaveBMP(FXStream& store,const FXColor *data,FXint width,FXint height);
-
-}
-
-#endif
diff --git a/fox-includes/FXBZFileStream.h b/fox-includes/FXBZFileStream.h
deleted file mode 100644
index 36e9edd0..00000000
--- a/fox-includes/FXBZFileStream.h
+++ /dev/null
@@ -1,126 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                      B Z F i l e S t r e a m   C l a s s e s                  *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1999,2005 by Lyle Johnson. All Rights Reserved.                 *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXBZFileStream.h 2335 2006-01-28 02:33:03Z lyle $                     *
-********************************************************************************/
-#ifdef HAVE_BZ2LIB_H
-#ifndef FXBZFILESTREAM_H
-#define FXBZFILESTREAM_H
-
-#ifndef FXFILESTREAM_H
-#include "FXFileStream.h"
-#endif
-
-
-namespace FX {
-
-
-struct BZBlock;
-
-
-/// BZIP2 compressed file stream
-class FXAPI FXBZFileStream : public FXFileStream {
-private:
-  BZBlock *bz;
-  int      ac;
-protected:
-  virtual FXuval writeBuffer(FXuval count);
-  virtual FXuval readBuffer(FXuval count);
-public:
-
-  /// Create BZIP2 file stream
-  FXBZFileStream(const FXObject* cont=NULL);
-
-  /// Open file stream
-  bool open(const FXString& filename,FXStreamDirection save_or_load,FXuval size=8192);
-
-  /// Close file stream
-  virtual bool close();
-
-  /// Get position
-  FXlong position() const { return FXStream::position(); }
-
-  /// Move to position
-  virtual bool position(FXlong,FXWhence){ return FALSE; }
-
-  /// Save single items to stream
-  FXBZFileStream& operator<<(const FXuchar& v){ FXStream::operator<<(v); return *this; }
-  FXBZFileStream& operator<<(const FXchar& v){ FXStream::operator<<(v); return *this; }
-  FXBZFileStream& operator<<(const FXushort& v){ FXStream::operator<<(v); return *this; }
-  FXBZFileStream& operator<<(const FXshort& v){ FXStream::operator<<(v); return *this; }
-  FXBZFileStream& operator<<(const FXuint& v){ FXStream::operator<<(v); return *this; }
-  FXBZFileStream& operator<<(const FXint& v){ FXStream::operator<<(v); return *this; }
-  FXBZFileStream& operator<<(const FXfloat& v){ FXStream::operator<<(v); return *this; }
-  FXBZFileStream& operator<<(const FXdouble& v){ FXStream::operator<<(v); return *this; }
-  FXBZFileStream& operator<<(const FXlong& v){ FXStream::operator<<(v); return *this; }
-  FXBZFileStream& operator<<(const FXulong& v){ FXStream::operator<<(v); return *this; }
-
-  /// Save arrays of items to stream
-  FXBZFileStream& save(const FXuchar* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXBZFileStream& save(const FXchar* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXBZFileStream& save(const FXushort* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXBZFileStream& save(const FXshort* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXBZFileStream& save(const FXuint* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXBZFileStream& save(const FXint* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXBZFileStream& save(const FXfloat* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXBZFileStream& save(const FXdouble* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXBZFileStream& save(const FXlong* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXBZFileStream& save(const FXulong* p,FXuval n){ FXStream::save(p,n); return *this; }
-
-  /// Load single items from stream
-  FXBZFileStream& operator>>(FXuchar& v){ FXStream::operator>>(v); return *this; }
-  FXBZFileStream& operator>>(FXchar& v){ FXStream::operator>>(v); return *this; }
-  FXBZFileStream& operator>>(FXushort& v){ FXStream::operator>>(v); return *this; }
-  FXBZFileStream& operator>>(FXshort& v){ FXStream::operator>>(v); return *this; }
-  FXBZFileStream& operator>>(FXuint& v){ FXStream::operator>>(v); return *this; }
-  FXBZFileStream& operator>>(FXint& v){ FXStream::operator>>(v); return *this; }
-  FXBZFileStream& operator>>(FXfloat& v){ FXStream::operator>>(v); return *this; }
-  FXBZFileStream& operator>>(FXdouble& v){ FXStream::operator>>(v); return *this; }
-  FXBZFileStream& operator>>(FXlong& v){ FXStream::operator>>(v); return *this; }
-  FXBZFileStream& operator>>(FXulong& v){ FXStream::operator>>(v); return *this; }
-
-  /// Load arrays of items from stream
-  FXBZFileStream& load(FXuchar* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXBZFileStream& load(FXchar* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXBZFileStream& load(FXushort* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXBZFileStream& load(FXshort* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXBZFileStream& load(FXuint* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXBZFileStream& load(FXint* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXBZFileStream& load(FXfloat* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXBZFileStream& load(FXdouble* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXBZFileStream& load(FXlong* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXBZFileStream& load(FXulong* p,FXuval n){ FXStream::load(p,n); return *this; }
-
-  /// Save object
-  FXBZFileStream& saveObject(const FXObject* v){ FXStream::saveObject(v); return *this; }
-
-  /// Load object
-  FXBZFileStream& loadObject(FXObject*& v){ FXStream::loadObject(v); return *this; }
-
-  /// Clean up
-  virtual ~FXBZFileStream();
-  };
-
-
-}
-
-#endif
-#endif
diff --git a/fox-includes/FXBitmap.h b/fox-includes/FXBitmap.h
deleted file mode 100755
index 97729de5..00000000
--- a/fox-includes/FXBitmap.h
+++ /dev/null
@@ -1,206 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                             B i t m a p    O b j e c t                        *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXBitmap.h 2335 2006-01-28 02:33:03Z lyle $                          *
-********************************************************************************/
-#ifndef FXBITMAP_H
-#define FXBITMAP_H
-
-#ifndef FXDRAWABLE_H
-#include "FXDrawable.h"
-#endif
-
-namespace FX {
-
-// Image rendering hints
-enum {
-  BITMAP_KEEP       = 0x00000001,       // Keep pixel data in client
-  BITMAP_OWNED      = 0x00000002,       // Pixel data is owned by image
-  BITMAP_SHMI       = 0x00000020,       // Using shared memory image
-  BITMAP_SHMP       = 0x00000040        // Using shared memory pixmap
-  };
-
-
-// Forward declarations
-class FXDC;
-class FXDCWindow;
-
-
-/**
-* A Bitmap is a rectangular array of pixels.  It supports two representations
-* of these pixels: a client-side pixel buffer, and a server-side pixmap which
-* is stored in an organization directly compatible with the screen, for fast
-* drawing onto the device.
-* The server-side representation is not directly accessible from the current
-* process as it lives in the process of the X Server or GDI.
-* The client-side pixel array is of size height x (width+7)/8 bytes, in other
-* words 8 pixels packed into a single byte, starting at bit 0 on the left.
-*/
-class FXAPI FXBitmap : public FXDrawable {
-  FXDECLARE(FXBitmap)
-  friend class FXDC;
-  friend class FXDCWindow;
-private:
-#ifdef WIN32
-  virtual FXID GetDC() const;
-  virtual int ReleaseDC(FXID) const;
-#endif
-protected:
-  FXuchar *data;        // Pixel data
-  FXint    bytewidth;   // Number of bytes across
-  FXuint   options;     // Options
-protected:
-  FXBitmap();
-private:
-  FXBitmap(const FXBitmap&);
-  FXBitmap &operator=(const FXBitmap&);
-public:
-
-  /**
-  * Create a bitmap.  If a client-side pixel buffer has been specified,
-  * the bitmap does not own the pixel buffer unless the BITMAP_OWNED flag is
-  * set.  If the BITMAP_OWNED flag is set but a NULL pixel buffer is
-  * passed, a pixel buffer will be automatically created and will be owned
-  * by the bitmap. The flags BITMAP_SHMI and BITMAP_SHMP may be specified for
-  * large bitmaps to instruct render() to use shared memory to communicate
-  * with the server.
-  */
-  FXBitmap(FXApp* a,const void *pix=NULL,FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Change options
-  void setOptions(FXuint opts);
-
-  /// To get to the option flags
-  FXuint getOptions() const { return options; }
-
-  /**
-  * Populate the bitmap with new pixel data of the same size; it will assume
-  * ownership of the pixel data if image BITMAP_OWNED option is passed.
-  * The server-side representation of the image, if it exists, is not updated.
-  * This can be done by calling render().
-  */
-  virtual void setData(FXuchar *pix,FXuint opts=0);
-
-  /**
-  * Populate the bitmap with new pixel data of a new size; it will assume ownership
-  * of the pixel data if image BITMAP_OWNED option is passed.  The size of the server-
-  * side representation of the image, if it exists, is adjusted but the contents are
-  * not updated yet. This can be done by calling render().
-  */
-  virtual void setData(FXuchar *pix,FXuint opts,FXint w,FXint h);
-
-  /// To get to the pixel data
-  FXuchar* getData() const { return data; }
-
-  /// Get pixel at x,y
-  FXbool getPixel(FXint x,FXint y) const { return (FXbool)((data[y*bytewidth+(x>>3)]>>(x&7))&1); }
-
-  /// Change pixel at x,y
-  void setPixel(FXint x,FXint y,FXbool color){ color ? data[y*bytewidth+(x>>3)]|=(1<<(x&7)) : data[y*bytewidth+(x>>3)]&=~(1<<(x&7)); }
-
-  /**
-  * Create the server side pixmap, then call render() to fill it with the
-  * pixel data from the client-side buffer.  After the server-side image has
-  * been created, the client-side pixel buffer will be deleted unless
-  * BITMAP_KEEP has been specified.  If the pixel buffer is not owned, i.e.
-  * the flag BITMAP_OWNED is not set, the pixel buffer will not be deleted.
-  */
-  virtual void create();
-
-  /**
-  * Detach the server side pixmap from the Bitmap.
-  * Afterwards, the Bitmap is left as if it never had a server-side resources.
-  */
-  virtual void detach();
-
-  /**
-  * Destroy the server-side pixmap.
-  * The client-side pixel buffer is not affected.
-  */
-  virtual void destroy();
-
-  /**
-  * Retrieves pixels from the server-side bitmap.
-  */
-  virtual void restore();
-
-  /**
-  * Render the server-side representation of the bitmap from client-side
-  * pixels.
-  */
-  virtual void render();
-
-  /**
-  * Release the client-side pixels buffer, free it if it was owned.
-  * If it is not owned, the image just forgets about the buffer.
-  */
-  virtual void release();
-
-  /**
-  * Resize both client-side and server-side representations (if any) to the
-  * given width and height.  The new representations typically contain garbage
-  * after this operation and need to be re-filled.
-  */
-  virtual void resize(FXint w,FXint h);
-
-  /**
-  * Rescale pixels image to the specified width and height; this calls
-  * resize() to adjust the client and server side representations.
-  */
-  virtual void scale(FXint w,FXint h);
-
-  /// Mirror bitmap horizontally and/or vertically
-  virtual void mirror(FXbool horizontal,FXbool vertical);
-
-  /// Rotate bitmap by degrees ccw
-  virtual void rotate(FXint degrees);
-
-  /**
-  * Crop bitmap to given rectangle; this calls resize() to adjust the client
-  * and server side representations.  The new bitmap may be smaller or larger
-  * than the old one; blank areas are filled with color. There must be at
-  * least one pixel of overlap between the old and the new bitmap.
-  */
-  virtual void crop(FXint x,FXint y,FXint w,FXint h,FXbool color=0);
-
-  /// Fill bitmap with uniform value
-  virtual void fill(FXbool color);
-
-  /// Save object to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load object from stream
-  virtual void load(FXStream& store);
-
-  /// Save pixel data only
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixel data only
-  virtual bool loadPixels(FXStream& store);
-
-  /// Cleanup
-  virtual ~FXBitmap();
-  };
-
-}
-
-#endif
-
diff --git a/fox-includes/FXBitmapFrame.h b/fox-includes/FXBitmapFrame.h
deleted file mode 100755
index 20a9744e..00000000
--- a/fox-includes/FXBitmapFrame.h
+++ /dev/null
@@ -1,103 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       B i t m a p   F r a m e   W i d g e t                   *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2001,2005 by H. J. Daniel III. All Rights Reserved.             *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXBitmapFrame.h 2127 2005-08-07 20:21:35Z lyle $                      *
-********************************************************************************/
-#ifndef FXBITMAPFRAME_H
-#define FXBITMAPFRAME_H
-
-#ifndef FXFRAME_H
-#include "FXFrame.h"
-#endif
-
-namespace FX {
-
-
-/**
-* The bitmap frame is a simple frame widget displaying an monochrome bitmap
-* image; the bitmap is not owned by the bitmap frame so it must be explicitly
-* deleted elsewhere.
-*/
-class FXAPI FXBitmapFrame : public FXFrame {
-  FXDECLARE(FXBitmapFrame)
-protected:
-  FXBitmap *bitmap;     // The bitmap being displayed
-  FXColor   onColor;    // Color for on pixels
-  FXColor   offColor;   // Color for off pixels
-protected:
-  FXBitmapFrame();
-private:
-  FXBitmapFrame(const FXBitmapFrame&);
-  FXBitmapFrame &operator=(const FXBitmapFrame&);
-public:
-  long onPaint(FXObject*,FXSelector,void* ptr);
-public:
-
-  /// Construct image frame and pass it an image
-  FXBitmapFrame(FXComposite* p,FXBitmap *bmp,FXuint opts=FRAME_SUNKEN|FRAME_THICK,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=0,FXint pr=0,FXint pt=0,FXint pb=0);
-
-  /// Create window
-  virtual void create();
-
-  /// Get default width
-  virtual FXint getDefaultWidth();
-
-  /// Get default height
-  virtual FXint getDefaultHeight();
-
-  /// Change the image being displayed
-  void setBitmap(FXBitmap* bmp);
-
-  /// Return the current image
-  FXBitmap* getBitmap() const { return bitmap; }
-
-  /// Set on color
-  void setOnColor(FXColor clr);
-
-  /// Get on color
-  FXColor getOnColor() const { return onColor; }
-
-  /// Set off color
-  void setOffColor(FXColor clr);
-
-  /// Get off color
-  FXColor getOffColor() const { return offColor; }
-
-  /// Set the current justification mode.
-  void setJustify(FXuint mode);
-
-  /// Get the current justification mode.
-  FXuint getJustify() const;
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destroy the widget, but do not destroy the image
-  virtual ~FXBitmapFrame();
-  };
-
-}
-
-
-#endif
diff --git a/fox-includes/FXBitmapView.h b/fox-includes/FXBitmapView.h
deleted file mode 100755
index 6ebd18aa..00000000
--- a/fox-includes/FXBitmapView.h
+++ /dev/null
@@ -1,135 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                    B i t m a p   V i e w   W i d g e t                        *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2000,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXBitmapView.h 2335 2006-01-28 02:33:03Z lyle $                       *
-********************************************************************************/
-#ifndef FXBITMAPVIEW_H
-#define FXBITMAPVIEW_H
-
-#ifndef FXSCROLLAREA_H
-#include "FXScrollArea.h"
-#endif
-
-namespace FX {
-
-
-class FXBitmap;
-
-/// Bitmap alignment styles
-enum {
-  BITMAPVIEW_NORMAL    = 0,              /// Normal mode is centered
-  BITMAPVIEW_CENTER_X  = 0,              /// Centered horizontally
-  BITMAPVIEW_LEFT      = 0x00100000,     /// Left-aligned
-  BITMAPVIEW_RIGHT     = 0x00200000,     /// Right-aligned
-  BITMAPVIEW_CENTER_Y  = 0,              /// Centered vertically
-  BITMAPVIEW_TOP       = 0x00400000,     /// Top-aligned
-  BITMAPVIEW_BOTTOM    = 0x00800000      /// Bottom-aligned
-  };
-
-/**
-* The Bitmap View widget display a scrollable view of a monochrome bitmap image;
-* the bitmap is not owned by the bitmap frame so it must be explicitly deleted
-* elsewhere.  Thus, a single bitmap image can be displayed inside multiple bitmap
-* view widgets.
-*/
-class FXAPI FXBitmapView : public FXScrollArea {
-  FXDECLARE(FXBitmapView)
-protected:
-  FXBitmap *bitmap;     // Image to view
-  FXColor   onColor;    // Color for on pixels
-  FXColor   offColor;   // Color for off pixels
-  FXint     grabx;      // Grab point x
-  FXint     graby;      // Grab point y
-protected:
-  FXBitmapView();
-private:
-  FXBitmapView(const FXBitmapView&);
-  FXBitmapView &operator=(const FXBitmapView&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onRightBtnPress(FXObject*,FXSelector,void*);
-  long onRightBtnRelease(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_XYZ=FXScrollArea::ID_LAST,
-    ID_LAST
-    };
-public:
-
-  /// Construct a scroll window
-  FXBitmapView(FXComposite* p,FXBitmap* bmp=NULL,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Perform layout immediately
-  virtual void layout();
-
-  /// Image view widget can receive focus
-  virtual bool canFocus() const;
-
-  /// Return the width of the contents
-  virtual FXint getContentWidth();
-
-  /// Return the height of the contents
-  virtual FXint getContentHeight();
-
-  /// Change image
-  void setBitmap(FXBitmap* bmp);
-
-  /// Return image
-  FXBitmap* getBitmap() const { return bitmap; }
-
-  /// Set on color
-  void setOnColor(FXColor clr);
-
-  /// Get on color
-  FXColor getOnColor() const { return onColor; }
-
-  /// Set off color
-  void setOffColor(FXColor clr);
-
-  /// Get off color
-  FXColor getOffColor() const { return offColor; }
-
-  /// Set the current alignment.
-  void setAlignment(FXuint mode);
-
-  /// Get the current alignment.
-  FXuint getAlignment() const;
-
-  /// Save list to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load list from a stream
-  virtual void load(FXStream& store);
-
-  /// Destroy
-  virtual ~FXBitmapView();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXButton.h b/fox-includes/FXButton.h
deleted file mode 100755
index 253f6f2d..00000000
--- a/fox-includes/FXButton.h
+++ /dev/null
@@ -1,134 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                           B u t t o n   W i d g e t                           *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXButton.h 2335 2006-01-28 02:33:03Z lyle $                          *
-********************************************************************************/
-#ifndef FXBUTTON_H
-#define FXBUTTON_H
-
-#ifndef FXLABEL_H
-#include "FXLabel.h"
-#endif
-
-namespace FX {
-
-
-/// Button state bits
-enum {
-  STATE_UP        = 0,		  /// Button is up
-  STATE_DOWN      = 1,		  /// Button is down
-  STATE_ENGAGED   = 2,		  /// Button is engaged
-  STATE_UNCHECKED = STATE_UP,	  /// Same as STATE_UP (used for check buttons or radio buttons)
-  STATE_CHECKED   = STATE_ENGAGED /// Same as STATE_ENGAGED (used for check buttons or radio buttons)
-  };
-
-
-/// Button flags
-enum {
-  BUTTON_AUTOGRAY  = 0x00800000,  /// Automatically gray out when not updated
-  BUTTON_AUTOHIDE  = 0x01000000,  /// Automatically hide button when not updated
-  BUTTON_TOOLBAR   = 0x02000000,  /// Toolbar style button [flat look]
-  BUTTON_DEFAULT   = 0x04000000,  /// May become default button when receiving focus
-  BUTTON_INITIAL   = 0x08000000,  /// This button is the initial default button
-  BUTTON_NORMAL    = (FRAME_RAISED|FRAME_THICK|JUSTIFY_NORMAL|ICON_BEFORE_TEXT)
-  };
-
-
-/**
-* A button provides a push button, with optional icon and/or text label.
-* When pressed, the button widget sends a SEL_COMMAND to its target.
-* Passing the BUTTON_TOOLBAR style option gives buttons a "flat" look, and
-* causes the edge of the button to be raised when the cursor moves over it.
-* Passing BUTTON_DEFAULT allows the button to become the default button in
-* a dialog, when the focus moves to it.  The default widget in a dialog
-* is the widget which will accept the RETURN key when it is pressed.
-* The BUTTON_INITIAL flag makes the button the default widget when the
-* focus moves to a widget which can not itself be a default widget.
-* There should be only a single button in the dialog which is the
-* initial default; typically this is the OK or CLOSE button.
-* The option BUTTON_AUTOGRAY (BUTTON_AUTOHIDE) causes the button to be grayed
-* out (hidden) if its handler does not respond to the SEL_UPDATE message.
-* This is useful when messages are delegated, for example when using a
-* multiple document interface, where the ultimaye destination of a message
-* can be changed.
-*/
-class FXAPI FXButton : public FXLabel {
-  FXDECLARE(FXButton)
-protected:
-  FXuchar  state;
-protected:
-  FXButton();
-private:
-  FXButton(const FXButton&);
-  FXButton& operator=(const FXButton&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onUpdate(FXObject*,FXSelector,void*);
-  long onEnter(FXObject*,FXSelector,void*);
-  long onLeave(FXObject*,FXSelector,void*);
-  long onFocusIn(FXObject*,FXSelector,void*);
-  long onFocusOut(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onHotKeyPress(FXObject*,FXSelector,void*);
-  long onHotKeyRelease(FXObject*,FXSelector,void*);
-  long onCheck(FXObject*,FXSelector,void*);
-  long onUncheck(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct button with text and icon
-  FXButton(FXComposite* p,const FXString& text,FXIcon* ic=NULL,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=BUTTON_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Returns true because a button can receive focus
-  virtual bool canFocus() const;
-
-  /// Move the focus to this window
-  virtual void setFocus();
-
-  /// Remove the focus from this window
-  virtual void killFocus();
-
-  /// Set as default button
-  virtual void setDefault(FXbool enable=TRUE);
-
-  /// Set the button state
-  void setState(FXuint s);
-
-  /// Get the button state
-  FXuint getState() const { return state; }
-
-  /// Set the button style flags
-  void setButtonStyle(FXuint style);
-
-  /// Get the button style flags
-  FXuint getButtonStyle() const;
-
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP1250Codec.h b/fox-includes/FXCP1250Codec.h
deleted file mode 100644
index 0354248d..00000000
--- a/fox-includes/FXCP1250Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP1250CODEC_H
-#define FXCP1250CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP1250 Codec
-class FXAPI FXCP1250Codec : public FXTextCodec {
-  FXDECLARE(FXCP1250Codec)
-public:
-  FXCP1250Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP1250Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP1251Codec.h b/fox-includes/FXCP1251Codec.h
deleted file mode 100644
index 55e7439c..00000000
--- a/fox-includes/FXCP1251Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP1251CODEC_H
-#define FXCP1251CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP1251 Codec
-class FXAPI FXCP1251Codec : public FXTextCodec {
-  FXDECLARE(FXCP1251Codec)
-public:
-  FXCP1251Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP1251Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP1252Codec.h b/fox-includes/FXCP1252Codec.h
deleted file mode 100644
index a0e30c02..00000000
--- a/fox-includes/FXCP1252Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP1252CODEC_H
-#define FXCP1252CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP1252 Codec
-class FXAPI FXCP1252Codec : public FXTextCodec {
-  FXDECLARE(FXCP1252Codec)
-public:
-  FXCP1252Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP1252Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP1253Codec.h b/fox-includes/FXCP1253Codec.h
deleted file mode 100644
index 10138b61..00000000
--- a/fox-includes/FXCP1253Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP1253CODEC_H
-#define FXCP1253CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP1253 Codec
-class FXAPI FXCP1253Codec : public FXTextCodec {
-  FXDECLARE(FXCP1253Codec)
-public:
-  FXCP1253Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP1253Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP1254Codec.h b/fox-includes/FXCP1254Codec.h
deleted file mode 100644
index 27960019..00000000
--- a/fox-includes/FXCP1254Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP1254CODEC_H
-#define FXCP1254CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP1254 Codec
-class FXAPI FXCP1254Codec : public FXTextCodec {
-  FXDECLARE(FXCP1254Codec)
-public:
-  FXCP1254Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP1254Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP1255Codec.h b/fox-includes/FXCP1255Codec.h
deleted file mode 100644
index 20734921..00000000
--- a/fox-includes/FXCP1255Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP1255CODEC_H
-#define FXCP1255CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP1255 Codec
-class FXAPI FXCP1255Codec : public FXTextCodec {
-  FXDECLARE(FXCP1255Codec)
-public:
-  FXCP1255Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP1255Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP1256Codec.h b/fox-includes/FXCP1256Codec.h
deleted file mode 100644
index 37871cc6..00000000
--- a/fox-includes/FXCP1256Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP1256CODEC_H
-#define FXCP1256CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP1256 Codec
-class FXAPI FXCP1256Codec : public FXTextCodec {
-  FXDECLARE(FXCP1256Codec)
-public:
-  FXCP1256Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP1256Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP1257Codec.h b/fox-includes/FXCP1257Codec.h
deleted file mode 100644
index 05bc9a41..00000000
--- a/fox-includes/FXCP1257Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP1257CODEC_H
-#define FXCP1257CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP1257 Codec
-class FXAPI FXCP1257Codec : public FXTextCodec {
-  FXDECLARE(FXCP1257Codec)
-public:
-  FXCP1257Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP1257Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP1258Codec.h b/fox-includes/FXCP1258Codec.h
deleted file mode 100644
index e5f5e1bd..00000000
--- a/fox-includes/FXCP1258Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP1258CODEC_H
-#define FXCP1258CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP1258 Codec
-class FXAPI FXCP1258Codec : public FXTextCodec {
-  FXDECLARE(FXCP1258Codec)
-public:
-  FXCP1258Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP1258Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP437Codec.h b/fox-includes/FXCP437Codec.h
deleted file mode 100644
index f9464cc5..00000000
--- a/fox-includes/FXCP437Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP437CODEC_H
-#define FXCP437CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP437 Codec
-class FXAPI FXCP437Codec : public FXTextCodec {
-  FXDECLARE(FXCP437Codec)
-public:
-  FXCP437Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP437Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP850Codec.h b/fox-includes/FXCP850Codec.h
deleted file mode 100644
index 47ed702a..00000000
--- a/fox-includes/FXCP850Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP850CODEC_H
-#define FXCP850CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP8502 Codec
-class FXAPI FXCP850Codec : public FXTextCodec {
-  FXDECLARE(FXCP850Codec)
-public:
-  FXCP850Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP850Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP852Codec.h b/fox-includes/FXCP852Codec.h
deleted file mode 100644
index e114ec18..00000000
--- a/fox-includes/FXCP852Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP852CODEC_H
-#define FXCP852CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP852 Codec
-class FXAPI FXCP852Codec : public FXTextCodec {
-  FXDECLARE(FXCP852Codec)
-public:
-  FXCP852Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP852Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP855Codec.h b/fox-includes/FXCP855Codec.h
deleted file mode 100644
index 1fd7a5a5..00000000
--- a/fox-includes/FXCP855Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP855CODEC_H
-#define FXCP855CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP855 Codec
-class FXAPI FXCP855Codec : public FXTextCodec {
-  FXDECLARE(FXCP855Codec)
-public:
-  FXCP855Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP855Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP856Codec.h b/fox-includes/FXCP856Codec.h
deleted file mode 100644
index 87881442..00000000
--- a/fox-includes/FXCP856Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP856CODEC_H
-#define FXCP856CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP856 Codec
-class FXAPI FXCP856Codec : public FXTextCodec {
-  FXDECLARE(FXCP856Codec)
-public:
-  FXCP856Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP856Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP857Codec.h b/fox-includes/FXCP857Codec.h
deleted file mode 100644
index 375921d4..00000000
--- a/fox-includes/FXCP857Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP857CODEC_H
-#define FXCP857CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP857 Codec
-class FXAPI FXCP857Codec : public FXTextCodec {
-  FXDECLARE(FXCP857Codec)
-public:
-  FXCP857Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP857Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP860Codec.h b/fox-includes/FXCP860Codec.h
deleted file mode 100644
index d5a5f52d..00000000
--- a/fox-includes/FXCP860Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP860CODEC_H
-#define FXCP860CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP860 Codec
-class FXAPI FXCP860Codec : public FXTextCodec {
-  FXDECLARE(FXCP860Codec)
-public:
-  FXCP860Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP860Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP861Codec.h b/fox-includes/FXCP861Codec.h
deleted file mode 100644
index ce9878b3..00000000
--- a/fox-includes/FXCP861Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP861CODEC_H
-#define FXCP861CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP861 Codec
-class FXAPI FXCP861Codec : public FXTextCodec {
-  FXDECLARE(FXCP861Codec)
-public:
-  FXCP861Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP861Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP862Codec.h b/fox-includes/FXCP862Codec.h
deleted file mode 100644
index cfd8a434..00000000
--- a/fox-includes/FXCP862Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP862CODEC_H
-#define FXCP862CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP862 Codec
-class FXAPI FXCP862Codec : public FXTextCodec {
-  FXDECLARE(FXCP862Codec)
-public:
-  FXCP862Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP862Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP863Codec.h b/fox-includes/FXCP863Codec.h
deleted file mode 100644
index 85f1dc5e..00000000
--- a/fox-includes/FXCP863Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP863CODEC_H
-#define FXCP863CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP863 Codec
-class FXAPI FXCP863Codec : public FXTextCodec {
-  FXDECLARE(FXCP863Codec)
-public:
-  FXCP863Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP863Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP864Codec.h b/fox-includes/FXCP864Codec.h
deleted file mode 100644
index d39ba3a2..00000000
--- a/fox-includes/FXCP864Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP864CODEC_H
-#define FXCP864CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP864 Codec
-class FXAPI FXCP864Codec : public FXTextCodec {
-  FXDECLARE(FXCP864Codec)
-public:
-  FXCP864Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP864Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP865Codec.h b/fox-includes/FXCP865Codec.h
deleted file mode 100644
index add2af2b..00000000
--- a/fox-includes/FXCP865Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP865CODEC_H
-#define FXCP865CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP865 Codec
-class FXAPI FXCP865Codec : public FXTextCodec {
-  FXDECLARE(FXCP865Codec)
-public:
-  FXCP865Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP865Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP866Codec.h b/fox-includes/FXCP866Codec.h
deleted file mode 100644
index 95757a91..00000000
--- a/fox-includes/FXCP866Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP866CODEC_H
-#define FXCP866CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP866 Codec
-class FXAPI FXCP866Codec : public FXTextCodec {
-  FXDECLARE(FXCP866Codec)
-public:
-  FXCP866Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP866Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP869Codec.h b/fox-includes/FXCP869Codec.h
deleted file mode 100644
index aaa23eeb..00000000
--- a/fox-includes/FXCP869Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP869CODEC_H
-#define FXCP869CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP869 Codec
-class FXAPI FXCP869Codec : public FXTextCodec {
-  FXDECLARE(FXCP869Codec)
-public:
-  FXCP869Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP869Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCP874Codec.h b/fox-includes/FXCP874Codec.h
deleted file mode 100644
index c8655a4d..00000000
--- a/fox-includes/FXCP874Codec.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FXCP874CODEC_H
-#define FXCP874CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-namespace FX {
-
-/// CP874 Codec
-class FXAPI FXCP874Codec : public FXTextCodec {
-  FXDECLARE(FXCP874Codec)
-public:
-  FXCP874Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXCP874Codec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCURCursor.h b/fox-includes/FXCURCursor.h
deleted file mode 100755
index cec6ed28..00000000
--- a/fox-includes/FXCURCursor.h
+++ /dev/null
@@ -1,89 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        C U R   C u r s o r    O b j e c t                     *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2001,2005 by Sander Jansen.   All Rights Reserved.              *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXCURCursor.h 2335 2006-01-28 02:33:03Z lyle $                       *
-********************************************************************************/
-#ifndef FXCURCURSOR_H
-#define FXCURCURSOR_H
-
-#ifndef FXCURSOR_H
-#include "FXCursor.h"
-#endif
-
-namespace FX {
-
-/// CUR Cursor class
-class FXAPI FXCURCursor : public FXCursor {
-  FXDECLARE(FXCURCursor)
-protected:
-  FXCURCursor(){}
-private:
-  FXCURCursor(const FXCURCursor&);
-  FXCURCursor &operator=(const FXCURCursor&);
-public:
-  static const FXchar fileExt[];
-public:
-
-  /**
-  * Construct a cursor from memory stream in Microsoft CUR format.
-  * The image is limited to 32x32 pixels.
-  */
-  FXCURCursor(FXApp* a,const void* pix);
-
-  /// Save pixel data only, in CUR format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixel data only, in CUR format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destructor
-  virtual ~FXCURCursor();
-  };
-
-
-#ifndef FXLOADICO
-#define FXLOADICO
-
-/**
-* Check if stream contains a ICO, return TRUE if so.
-*/
-extern FXAPI bool fxcheckICO(FXStream& store);
-
-
-/**
-* Load an ICO (Microsoft icon format) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadICO(FXStream& store,FXColor*& data,FXint& width,FXint& height,FXint& xspot,FXint& yspot);
-
-
-/**
-* Save an ICO (Microsoft icon format) file to a stream.
-* If no hot-spot given, save as an ICO instead of a CUR resource.
-*/
-extern FXAPI bool fxsaveICO(FXStream& store,const FXColor *data,FXint width,FXint height,FXint xspot=-1,FXint yspot=-1);
-
-#endif
-
-}
-
-#endif
diff --git a/fox-includes/FXCanvas.h b/fox-includes/FXCanvas.h
deleted file mode 100755
index d82a633f..00000000
--- a/fox-includes/FXCanvas.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                          C a n v a s   W i d g e t                            *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXCanvas.h 2335 2006-01-28 02:33:03Z lyle $                          *
-********************************************************************************/
-#ifndef FXCANVAS_H
-#define FXCANVAS_H
-
-#ifndef FXWINDOW_H
-#include "FXWindow.h"
-#endif
-
-namespace FX {
-
-
-/// Canvas, an area drawn by another object
-class FXAPI FXCanvas : public FXWindow {
-  FXDECLARE(FXCanvas)
-protected:
-  FXCanvas();
-private:
-  FXCanvas(const FXCanvas&);
-  FXCanvas &operator=(const FXCanvas&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct new drawing canvas widget
-  FXCanvas(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=FRAME_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Return TRUE because canvas can receive focus
-  virtual bool canFocus() const;
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCheckButton.h b/fox-includes/FXCheckButton.h
deleted file mode 100755
index af64d075..00000000
--- a/fox-includes/FXCheckButton.h
+++ /dev/null
@@ -1,136 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                    C h e c k   B u t t o n   W i d g e t                      *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXCheckButton.h 2335 2006-01-28 02:33:03Z lyle $                     *
-********************************************************************************/
-#ifndef FXCHECKBUTTON_H
-#define FXCHECKBUTTON_H
-
-#ifndef FXLABEL_H
-#include "FXLabel.h"
-#endif
-
-namespace FX {
-
-
-/// CheckButton styles
-enum {
-  CHECKBUTTON_AUTOGRAY = 0x00800000,    /// Automatically gray out when not updated
-  CHECKBUTTON_AUTOHIDE = 0x01000000,    /// Automatically hide when not updated
-  CHECKBUTTON_PLUS     = 0x02000000,    /// Draw a + for unchecked and - for checked
-  CHECKBUTTON_NORMAL   = JUSTIFY_NORMAL|ICON_BEFORE_TEXT
-  };
-
-
-/**
-* A Check Button is a tri-state button.  Normally, it is either
-* TRUE or FALSE, and toggles between TRUE or FALSE whenever it is pressed.
-* A third state MAYBE may be set to indicate that no selection has been made yet
-* by the user, or that the state is ambiguous.
-* When pressed, the Check Button sends a SEL_COMMAND to its target, and the
-* message data represents the state of the check button.
-* The option CHECKBUTTON_AUTOGRAY (CHECKBUTTON_AUTOHIDE) causes the button to be
-* grayed out (hidden) if its handler does not respond to the SEL_UPDATE message.
-* With the CHECKBUTTON_PLUS option, the Check Button will draw a + or - sign instead
-* of a check.  You can use this to make collapsable panels, by hooking up a Check
-* Button to a layout manager via the ID_TOGGLE_SHOWN message.  This will give a
-* similar visual element as collapsing folders in a Tree List.
-*/
-class FXAPI FXCheckButton : public FXLabel {
-  FXDECLARE(FXCheckButton)
-protected:
-  FXColor  checkColor;  // Color of check mark
-  FXColor  boxColor;    // Color of check box
-  FXbool   check;       // Check state
-  FXbool   oldcheck;    // Old check state
-protected:
-  FXCheckButton();
-private:
-  FXCheckButton(const FXCheckButton&);
-  FXCheckButton &operator=(const FXCheckButton&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onUpdate(FXObject*,FXSelector,void*);
-  long onEnter(FXObject*,FXSelector,void*);
-  long onLeave(FXObject*,FXSelector,void*);
-  long onFocusIn(FXObject*,FXSelector,void*);
-  long onFocusOut(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onHotKeyPress(FXObject*,FXSelector,void*);
-  long onHotKeyRelease(FXObject*,FXSelector,void*);
-  long onCheck(FXObject*,FXSelector,void*);
-  long onUncheck(FXObject*,FXSelector,void*);
-  long onUnknown(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct new check button
-  FXCheckButton(FXComposite* p,const FXString& text,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=CHECKBUTTON_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Returns true because a check button can receive focus
-  virtual bool canFocus() const;
-
-  /// Get default width
-  virtual FXint getDefaultWidth();
-
-  /// Get default height
-  virtual FXint getDefaultHeight();
-
-  /// Set check button state (TRUE, FALSE or MAYBE)
-  void setCheck(FXbool state=TRUE,FXbool notify=FALSE);
-
-  /// Get check button state (TRUE, FALSE or MAYBE)
-  FXbool getCheck() const { return check; }
-
-  /// Change check button style
-  void setCheckButtonStyle(FXuint style);
-
-  /// Return current check button style
-  FXuint getCheckButtonStyle() const;
-
-  /// Get the box background color
-  FXColor getBoxColor() const { return boxColor; }
-
-  /// Set the box background color
-  void setBoxColor(FXColor clr);
-
-  /// Get the box check color
-  FXColor getCheckColor() const { return checkColor; }
-
-  /// Set the box check color
-  void setCheckColor(FXColor clr);
-
-  /// Save check button to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load check button from a stream
-  virtual void load(FXStream& store);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXChoiceBox.h b/fox-includes/FXChoiceBox.h
deleted file mode 100644
index 2efe35ae..00000000
--- a/fox-includes/FXChoiceBox.h
+++ /dev/null
@@ -1,120 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                            C h o i c e   B o x                                *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2004,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXChoiceBox.h 2187 2005-08-24 07:41:39Z lyle $                        *
-********************************************************************************/
-#ifndef FXCHOICEBOX_H
-#define FXCHOICEBOX_H
-
-#ifndef FXDIALOGBOX_H
-#include "FXDialogBox.h"
-#endif
-
-namespace FX {
-
-
-class FXList;
-
-
-/**
-* The Choice Box provides a dialog panel to select one item out of a list
-* of choices.  The choices are provided as a list of text strings.
-* When the dialog closes, the index of the selected choice is returned,
-* while a -1 is returned if the dialog was canceled,
-*/
-class FXAPI FXChoiceBox : public FXDialogBox {
-  FXDECLARE(FXChoiceBox)
-protected:
-  FXList *list;
-protected:
-  FXChoiceBox(){}
-private:
-  FXChoiceBox(const FXChoiceBox&);
-  FXChoiceBox &operator=(const FXChoiceBox&);
-  void initialize(const FXString& text,FXIcon* icon);
-public:
-  long onCmdClicked(FXObject*,FXSelector,void*);
-  long onCmdCancel(FXObject*,FXSelector,void*);
-public:
-  enum{
-    ID_CLICKED=FXDialogBox::ID_LAST,
-    ID_LAST
-    };
-public:
-
-  /// Construct choice box with given caption, icon, message text, and with choices from array of strings
-  FXChoiceBox(FXWindow* owner,const FXString& caption,const FXString& text,FXIcon* icon,const FXchar** choices,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Construct choice box with given caption, icon, message text, and with choices from newline separated strings
-  FXChoiceBox(FXWindow* owner,const FXString& caption,const FXString& text,FXIcon* icon,const FXString& choices,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Construct free floating choice box with given caption, icon, message text, and with choices from array of strings
-  FXChoiceBox(FXApp* app,const FXString& caption,const FXString& text,FXIcon* icon,const FXchar** choices,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Construct free floating choice box with given caption, icon, message text, and with choices from newline separated strings
-  FXChoiceBox(FXApp* app,const FXString& caption,const FXString& text,FXIcon* icon,const FXString& choices,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /**
-  * Show a modal choice dialog.
-  * Prompt the user using a dialog with given caption, icon,
-  * message text, and with choices from newline array of strings.
-  * The return value is -1 if cancelled, or the given choice.
-  */
-  static FXint ask(FXWindow* owner,FXuint opts,const FXString& caption,const FXString& text,FXIcon* icon,const FXchar** choices);
-
-  /**
-  * Show a modal choice dialog.
-  * Prompt the user using a dialog with given caption, icon,
-  * message text, and with choices from newline separated strings.
-  * The return value is -1 if cancelled, or the given choice
-  */
-  static FXint ask(FXWindow* owner,FXuint opts,const FXString& caption,const FXString& text,FXIcon* icon,const FXString& choices);
-
-  /**
-  * Show modal choice message, in free floating window.
-  * Prompt the user using a dialog with given caption, icon,
-  * message text, and with choices from newline array of strings.
-  * The return value is -1 if cancelled, or the given choice
-  */
-  static FXint ask(FXApp* app,FXuint opts,const FXString& caption,const FXString& text,FXIcon* icon,const FXchar** choices);
-
-  /**
-  * Show modal choice message, in free floating window.
-  * Prompt the user using a dialog with given caption, icon,
-  * message text, and with choices from newline separated strings.
-  * The return value is -1 if cancelled, or the given choice
-  */
-  static FXint ask(FXApp* app,FXuint opts,const FXString& caption,const FXString& text,FXIcon* icon,const FXString& choices);
-
-
-  /// Save choice box to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load choice box from a stream
-  virtual void load(FXStream& store);
-
-  /// Destroy choice box
-  virtual ~FXChoiceBox();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXColorBar.h b/fox-includes/FXColorBar.h
deleted file mode 100755
index beb2d2f1..00000000
--- a/fox-includes/FXColorBar.h
+++ /dev/null
@@ -1,144 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                         C o l o r B a r   W i d g e t                         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2001,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXColorBar.h 2127 2005-08-07 20:21:35Z lyle $                        *
-********************************************************************************/
-#ifndef FXCOLORBAR_H
-#define FXCOLORBAR_H
-
-#ifndef FXFRAME_H
-#include "FXFrame.h"
-#endif
-
-namespace FX {
-
-
-/// Color bar orientation
-enum {
-  COLORBAR_HORIZONTAL = 0,            /// Color bar shown horizontally
-  COLORBAR_VERTICAL   = 0x00008000    /// Color bar shown vertically
-  };
-
-
-class FXImage;
-
-
-/**
-* A Color Bar is a widget which controls the brightness (value) of a
-* color by means of the hue, saturation, value specification system.
-* It is most useful when used together with the Color Wheel which controls
-* the hue and saturation.
-* The options COLORBAR_HORIZONTAL and COLORBAR_VERTICAL control the orientation
-* of the bar.
-*/
-class FXAPI FXColorBar : public FXFrame {
-  FXDECLARE(FXColorBar)
-protected:
-  FXImage  *bar;          // Intensity bar
-  FXfloat   hsv[3];       // Hue, saturation, value
-  FXString  tip;          // Tooltip value
-  FXString  help;         // Help value
-protected:
-  FXColorBar();
-  void updatebar();
-private:
-  FXColorBar(const FXColorBar&);
-  FXColorBar &operator=(const FXColorBar&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onCmdSetHelp(FXObject*,FXSelector,void*);
-  long onCmdGetHelp(FXObject*,FXSelector,void*);
-  long onCmdSetTip(FXObject*,FXSelector,void*);
-  long onCmdGetTip(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct color bar
-  FXColorBar(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=FRAME_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Change hue
-  void setHue(FXfloat h);
-
-  /// Return hue
-  FXfloat getHue() const { return hsv[0]; }
-
-  /// Change saturation
-  void setSat(FXfloat s);
-
-  /// Return saturation
-  FXfloat getSat() const { return hsv[1]; }
-
-  /// Change value
-  void setVal(FXfloat v);
-
-  /// Return value
-  FXfloat getVal() const { return hsv[2]; }
-
-  /// Change the color bar style
-  FXuint getBarStyle() const;
-
-  /// Get the color bar style
-  void setBarStyle(FXuint style);
-
-  /// Set status line help text for this color bar
-  void setHelpText(const FXString& text){ help=text; }
-
-  /// Get status line help text for this color bar
-  const FXString& getHelpText() const { return help; }
-
-  /// Set tool tip message for this color bar
-  void setTipText(const FXString& text){ tip=text; }
-
-  /// Get tool tip message for this color bar
-  const FXString& getTipText() const { return tip; }
-
-  /// Save color bar to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load color bar from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXColorBar();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXColorDialog.h b/fox-includes/FXColorDialog.h
deleted file mode 100755
index 801da903..00000000
--- a/fox-includes/FXColorDialog.h
+++ /dev/null
@@ -1,92 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                           C o l o r   D i a l o g                             *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXColorDialog.h 2127 2005-08-07 20:21:35Z lyle $                     *
-********************************************************************************/
-#ifndef FXCOLORDIALOG_H
-#define FXCOLORDIALOG_H
-
-#ifndef FXDIALOGBOX_H
-#include "FXDialogBox.h"
-#endif
-
-namespace FX {
-
-
-class FXColorSelector;
-
-
-/**
-* The Color dialog is a standard dialog panel used to edit colors.
-* Colors can be edited via RGB (Red, Green, Blue additive color model),
-* via HSV (Hue, Saturation, Value color modal), via CMY (Cyan, Magenta,
-* Yellow subtractive color model), or by name.
-* Commonly used colors can be dragged into a number of small color wells
-* to be used repeatedly; colors dropped into the small color wells are
-* automatically saved into the registry for future use.
-*/
-class FXAPI FXColorDialog : public FXDialogBox {
-  FXDECLARE(FXColorDialog)
-protected:
-  FXColorSelector *colorbox;
-protected:
-  FXColorDialog(){}
-private:
-  FXColorDialog(const FXColorDialog&);
-  FXColorDialog &operator=(const FXColorDialog&);
-public:
-  long onChgColor(FXObject*,FXSelector,void*);
-  long onCmdColor(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_COLORSELECTOR=FXDialogBox::ID_LAST,
-    ID_LAST
-    };
-public:
-
-  /// Construct color dialog
-  FXColorDialog(FXWindow* owner,const FXString& name,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Set the color
-  void setRGBA(FXColor clr);
-
-  /// Get the color
-  FXColor getRGBA() const;
-
-  /// Return true if only opaque colors allowed
-  FXbool isOpaqueOnly() const;
-
-  /// Change opaque only mode
-  void setOpaqueOnly(FXbool forceopaque);
-
-  /// Save dialog to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load dialog from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXColorDialog();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXColorList.h b/fox-includes/FXColorList.h
deleted file mode 100644
index 96005f71..00000000
--- a/fox-includes/FXColorList.h
+++ /dev/null
@@ -1,101 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                         C o l o r   L i s t   W i d g e t                     *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2005 by Jeroen van der Zijp.   All Rights Reserved.             *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXColorList.h 2292 2005-12-06 02:22:28Z lyle $                        *
-********************************************************************************/
-#ifndef FXCOLORLIST_H
-#define FXCOLORLIST_H
-
-#ifndef FXLIST_H
-#include "FXList.h"
-#endif
-
-namespace FX {
-
-
-/// Color item
-class FXColorItem : public FXListItem {
-  FXDECLARE(FXColorItem)
-protected:
-  FXColor  color;
-private:
-  FXColorItem(const FXColorItem&);
-  FXColorItem& operator=(const FXColorItem&);
-protected:
-  FXColorItem():color(0){}
-  virtual void draw(const FXList* list,FXDC& dc,FXint x,FXint y,FXint w,FXint h);
-  virtual FXint hitItem(const FXList* list,FXint x,FXint y) const;
-public:
-  /// Construct new item with given text, color, and user-data
-  FXColorItem(const FXString& text,FXColor clr,void* ptr=NULL):FXListItem(text,NULL,ptr),color(clr){}
-
-  /// Change item's color
-  void setColor(FXColor clr){ color=clr; }
-
-  /// Return item's color
-  FXColor getColor() const { return color; }
-
-  /// Return width of item as drawn in list
-  virtual FXint getWidth(const FXList* list) const;
-
-  /// Return height of item as drawn in list
-  virtual FXint getHeight(const FXList* list) const;
-  };
-
-
-/**
-* A ColorList Widget displays a list of colors.
-*/
-class FXAPI FXColorList : public FXList {
-  FXDECLARE(FXColorList)
-protected:
-  FXColorList(){}
-  virtual FXListItem *createItem(const FXString& text,FXIcon* icon,void* ptr);
-private:
-  FXColorList(const FXColorList&);
-  FXColorList &operator=(const FXColorList&);
-public:
-
-  /// Construct a list with initially no items in it
-  FXColorList(FXComposite *p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=LIST_BROWSESELECT,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Fill list by appending color items from array of strings and array of colors
-  FXint fillItems(const FXchar** strings,FXColor *colors=NULL,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Insert item at index with given text, color, and user-data pointer
-  FXint insertItem(FXint index,const FXString& text,FXColor color=0,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Append new item with given text, color, and user-data pointer
-  FXint appendItem(const FXString& text,FXColor color=0,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Prepend new item with given text, color, and user-data pointer
-  FXint prependItem(const FXString& text,FXColor color=0,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Change item color
-  void setItemColor(FXint index,FXColor color);
-
-  /// Return item color
-  FXColor getItemColor(FXint index) const;
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXColorRing.h b/fox-includes/FXColorRing.h
deleted file mode 100644
index b0b9fb1a..00000000
--- a/fox-includes/FXColorRing.h
+++ /dev/null
@@ -1,170 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                         C o l o r R i n g   W i d g e t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2005 by Jeroen van der Zijp.   All Rights Reserved.             *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXColorRing.h 2298 2005-12-07 12:03:24Z lyle $                        *
-********************************************************************************/
-#ifndef FXCOLORRING_H
-#define FXCOLORRING_H
-
-#ifndef FXFRAME_H
-#include "FXFrame.h"
-#endif
-
-namespace FX {
-
-
-class FXImage;
-
-
-/**
-* A Color Ring widget provides an intuitive way to specify a color.
-* The outer ring of the widget is rotated to control the hue of the color
-* being specified, while the inner triangle varies the color saturation
-* and the brightness of the color.  The color saturation axis of the
-* triangle goes from a fully saturated "pure" color to "pastel" color;
-* the brightness goes from black to a bright color.
-*/
-class FXAPI FXColorRing : public FXFrame {
-  FXDECLARE(FXColorRing)
-protected:
-  FXImage  *dial;         // HSV dial image
-  FXfloat   hsv[3];       // Hue, saturation, value
-  FXint     ringwidth;    // Width of hue ring
-  FXint     ringouter;    // Outer radius
-  FXint     ringinner;    // Inner radius
-  FXint     dialx;        // Dial x location
-  FXint     dialy;        // Dial y location
-  FXint     satvalx;      // Saturation value x
-  FXint     satvaly;      // Saturation value y
-  FXint     huex;         // Hue x
-  FXint     huey;         // Hue y
-  FXint     clrx;         // Color corner of triangle
-  FXint     clry;
-  FXint     blkx;         // Black corner of triangle
-  FXint     blky;
-  FXint     whtx;         // White corner of triangle
-  FXint     whty;
-  FXString  tip;          // Tooltip value
-  FXString  help;         // Help value
-  FXuchar   mode;         // Mode widget is in
-protected:
-  FXColorRing();
-  void updatering();
-  FXfloat hueFromXY(FXint x,FXint y) const;
-  void hueToXY(FXint& x,FXint& y,FXfloat hue) const;
-  void satValToXY(FXint& x,FXint& y,FXfloat s,FXfloat v) const;
-  void satValFromXY(FXfloat& s,FXfloat& v,FXint x,FXint y) const;
-  FXbool inCorner(FXint x,FXint y) const;
-  FXbool inHueRing(FXint x,FXint y) const;
-  FXbool inTriangle(FXint x,FXint y) const;
-protected:
-  enum {
-    MOUSE_NONE,         // No mouse operation
-    MOUSE_HUE,          // Moving in hue-ring
-    MOUSE_SATVAL        // Moving in saturation/value triangle
-    };
-private:
-  FXColorRing(const FXColorRing&);
-  FXColorRing &operator=(const FXColorRing&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onMouseWheel(FXObject*,FXSelector,void*);
-  long onCmdSetHelp(FXObject*,FXSelector,void*);
-  long onCmdGetHelp(FXObject*,FXSelector,void*);
-  long onCmdSetTip(FXObject*,FXSelector,void*);
-  long onCmdGetTip(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct color ring with initial color clr
-  FXColorRing(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=FRAME_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Change hue
-  void setHue(FXfloat h);
-
-  /// Return hue
-  FXfloat getHue() const { return hsv[0]; }
-
-  /// Change saturation
-  void setSat(FXfloat s);
-
-  /// Return saturation
-  FXfloat getSat() const { return hsv[1]; }
-
-  /// Change value
-  void setVal(FXfloat v);
-
-  /// Return value
-  FXfloat getVal() const { return hsv[2]; }
-
-  /// Set hue, saturation, value
-  void setHueSatVal(FXfloat h,FXfloat s,FXfloat v);
-
-  /// Change width of hue ring
-  void setRingWidth(FXint rw);
-
-  /// Return width of hue ring
-  FXint getRingWidth() const { return ringwidth; }
-
-  /// Set status line help text for this color well
-  void setHelpText(const FXString& text){ help=text; }
-
-  /// Get status line help text for this color well
-  const FXString& getHelpText() const { return help; }
-
-  /// Set tool tip message for this color well
-  void setTipText(const FXString& text){ tip=text; }
-
-  /// Get tool tip message for this color well
-  const FXString& getTipText() const { return tip; }
-
-  /// Save color well to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load color well from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXColorRing();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXColorSelector.h b/fox-includes/FXColorSelector.h
deleted file mode 100755
index cf154289..00000000
--- a/fox-includes/FXColorSelector.h
+++ /dev/null
@@ -1,179 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                          C o l o r   S e l e c t o r                          *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXColorSelector.h 2187 2005-08-24 07:41:39Z lyle $                   *
-********************************************************************************/
-#ifndef FXCOLORSELECTOR_H
-#define FXCOLORSELECTOR_H
-
-#ifndef FXPACKER_H
-#include "FXPacker.h"
-#endif
-
-namespace FX {
-
-
-class FXTabBook;
-class FXColorBar;
-class FXColorWell;
-class FXColorWheel;
-class FXColorRing;
-class FXColorList;
-class FXList;
-class FXSlider;
-class FXTextField;
-class FXButton;
-class FXIcon;
-class FXLabel;
-
-
-/// Color selection widget
-class FXAPI FXColorSelector : public FXPacker {
-  FXDECLARE(FXColorSelector)
-protected:
-  FXTabBook    *panels;               // Color panes
-  FXColorWell  *well;                 // Main well
-  FXColorList  *list;                 // List of color names
-  FXColorRing  *wheel;                // Color ring
-  FXSlider     *rgbaslider[4];        // RGBA sliders
-  FXTextField  *rgbatext[4];          // RGBA text fields
-  FXSlider     *hsvaslider[4];        // HSVA sliders
-  FXTextField  *hsvatext[4];          // HSVA text fields
-  FXSlider     *cmyslider[4];         // CMY sliders
-  FXTextField  *cmytext[4];           // CMY text fields
-  FXColorWell  *colorwells[24];       // Custom color wells
-  FXIcon       *eyedropicon;          // Icon for eye dropper
-  FXIcon       *dialmodeicon;         // Icon for dial mode
-  FXIcon       *rgbmodeicon;          // Icon for RGB mode
-  FXIcon       *hsvmodeicon;          // Icon for HSV mode
-  FXIcon       *cmymodeicon;          // Icon for CMY mode
-  FXIcon       *txtmodeicon;          // Icon for TEXT mode
-  FXButton     *accept;               // Accept button
-  FXButton     *cancel;               // Cancel button
-  FXfloat       rgba[4];              // Accurate RGBA color
-  FXfloat       hsva[4];              // Accurate HSVA color
-protected:
-  static const FXchar* wellname[24];  // Well names
-protected:
-  FXColorSelector(){}
-  void updateWell();
-private:
-  FXColorSelector(const FXColorSelector&);
-  FXColorSelector &operator=(const FXColorSelector&);
-public:
-  long onCmdWell(FXObject*,FXSelector,void*);
-  long onChgWell(FXObject*,FXSelector,void*);
-  long onCmdRGBSlider(FXObject*,FXSelector,void*);
-  long onUpdRGBSlider(FXObject*,FXSelector,void*);
-  long onCmdRGBText(FXObject*,FXSelector,void*);
-  long onUpdRGBText(FXObject*,FXSelector,void*);
-  long onCmdHSVSlider(FXObject*,FXSelector,void*);
-  long onUpdHSVSlider(FXObject*,FXSelector,void*);
-  long onCmdHSVText(FXObject*,FXSelector,void*);
-  long onUpdHSVText(FXObject*,FXSelector,void*);
-  long onCmdCMYSlider(FXObject*,FXSelector,void*);
-  long onUpdCMYSlider(FXObject*,FXSelector,void*);
-  long onCmdCMYText(FXObject*,FXSelector,void*);
-  long onUpdCMYText(FXObject*,FXSelector,void*);
-  long onCmdList(FXObject*,FXSelector,void*);
-  long onCmdCustomWell(FXObject*,FXSelector,void*);
-  long onChgCustomWell(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdActivePane(FXObject*,FXSelector,void*);
-  long onCmdAlphaSlider(FXObject*,FXSelector,void*);
-  long onUpdAlphaSlider(FXObject*,FXSelector,void*);
-  long onCmdAlphaText(FXObject*,FXSelector,void*);
-  long onUpdAlphaText(FXObject*,FXSelector,void*);
-  long onUpdAlphaLabel(FXObject*,FXSelector,void*);
-  long onCmdWheel(FXObject*,FXSelector,void*);
-  long onUpdWheel(FXObject*,FXSelector,void*);
-  long onCmdColorPick(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_CUSTOM_FIRST=FXPacker::ID_LAST,
-    ID_CUSTOM_LAST=ID_CUSTOM_FIRST+24,
-    ID_RGB_RED_SLIDER,
-    ID_RGB_GREEN_SLIDER,
-    ID_RGB_BLUE_SLIDER,
-    ID_RGB_RED_TEXT,
-    ID_RGB_GREEN_TEXT,
-    ID_RGB_BLUE_TEXT,
-    ID_HSV_HUE_SLIDER,
-    ID_HSV_SATURATION_SLIDER,
-    ID_HSV_VALUE_SLIDER,
-    ID_HSV_HUE_TEXT,
-    ID_HSV_SATURATION_TEXT,
-    ID_HSV_VALUE_TEXT,
-    ID_CMY_CYAN_SLIDER,
-    ID_CMY_MAGENTA_SLIDER,
-    ID_CMY_YELLOW_SLIDER,
-    ID_CMY_CYAN_TEXT,
-    ID_CMY_MAGENTA_TEXT,
-    ID_CMY_YELLOW_TEXT,
-    ID_DIAL_WHEEL,
-    ID_COLOR_LIST,
-    ID_WELL_CHANGED,
-    ID_ACTIVEPANE,
-    ID_ALPHA_SLIDER,
-    ID_ALPHA_TEXT,
-    ID_ALPHA_LABEL,
-    ID_COLORPICK,
-    ID_LAST
-    };
-public:
-
-  /// Construct a new ColorSelector
-  FXColorSelector(FXComposite *p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Create the ColorSelector
-  virtual void create();
-
-  /// Return a pointer to the "Accept" button
-  FXButton *acceptButton() const { return accept; }
-
-  /// Return a pointer to the "Cancel" button
-  FXButton *cancelButton() const { return cancel; }
-
-  /// Set the selected color
-  void setRGBA(FXColor clr);
-
-  /// Get the selected color
-  FXColor getRGBA() const;
-
-  /// Return true if only opaque colors allowed
-  FXbool isOpaqueOnly() const;
-
-  /// Change opaque only mode
-  void setOpaqueOnly(FXbool opaque);
-
-  /// Save to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXColorSelector();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXColorWell.h b/fox-includes/FXColorWell.h
deleted file mode 100755
index 8a3982ca..00000000
--- a/fox-includes/FXColorWell.h
+++ /dev/null
@@ -1,172 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                         C o l o r W e l l   W i d g e t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXColorWell.h 2335 2006-01-28 02:33:03Z lyle $                       *
-********************************************************************************/
-#ifndef FXCOLORWELL_H
-#define FXCOLORWELL_H
-
-#ifndef FXFRAME_H
-#include "FXFrame.h"
-#endif
-
-namespace FX {
-
-
-// Color Well Styles
-enum {
-  COLORWELL_OPAQUEONLY = 0x00008000,  /// Colors must be opaque
-  COLORWELL_SOURCEONLY = 0x00010000,  /// ColorWell is never a target
-  COLORWELL_NORMAL     = JUSTIFY_NORMAL
-  };
-
-
-
-/**
-* A color well is a widget which controls color settings.
-* Colors may be dragged and dropped from one color well to another.
-* A double-click inside a color well will bring up the standard
-* color dialog panel to edit the color well's color.
-* Colors may be also pasted by name using middle-mouse click into/out of
-* color wells from/to other selection-capable applications; for example,
-* you can highlight the word `red' and paste it into a color well.
-* While the color value is being changed, the color well sends a SEL_CHANGED
-* to its target; at the end of the change, it sends a SEL_COMMAND.
-* The message data represents the current color value, of the type FXColor.
-*/
-class FXAPI FXColorWell : public FXFrame {
-  FXDECLARE(FXColorWell)
-protected:
-  FXColor   wellColor[2];             // Pixel value of RGBA over black and white
-  FXColor   rgba;                     // Color with RGB and Alpha
-  FXString  tip;                      // Tooltip value
-  FXString  help;                     // Help value
-protected:
-  FXColorWell();
-  static FXColor rgbaoverblack(FXColor clr);
-  static FXColor rgbaoverwhite(FXColor clr);
-private:
-  FXColorWell(const FXColorWell&);
-  FXColorWell &operator=(const FXColorWell&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onMiddleBtnPress(FXObject*,FXSelector,void*);
-  long onMiddleBtnRelease(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onBeginDrag(FXObject*,FXSelector,void*);
-  long onEndDrag(FXObject*,FXSelector,void*);
-  long onDragged(FXObject*,FXSelector,void*);
-  long onFocusIn(FXObject*,FXSelector,void*);
-  long onFocusOut(FXObject*,FXSelector,void*);
-  long onDNDEnter(FXObject*,FXSelector,void*);
-  long onDNDLeave(FXObject*,FXSelector,void*);
-  long onDNDMotion(FXObject*,FXSelector,void*);
-  long onDNDDrop(FXObject*,FXSelector,void*);
-  long onDNDRequest(FXObject*,FXSelector,void*);
-  long onSelectionLost(FXObject*,FXSelector,void*);
-  long onSelectionGained(FXObject*,FXSelector,void*);
-  long onSelectionRequest(FXObject*,FXSelector,void*);
-  long onClicked(FXObject*,FXSelector,void*);
-  long onDoubleClicked(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-  long onCmdColorWell(FXObject*,FXSelector,void*);
-  long onChgColorWell(FXObject*,FXSelector,void*);
-  long onCmdSetHelp(FXObject*,FXSelector,void*);
-  long onCmdGetHelp(FXObject*,FXSelector,void*);
-  long onCmdSetTip(FXObject*,FXSelector,void*);
-  long onCmdGetTip(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_COLORDIALOG=FXFrame::ID_LAST,
-    ID_LAST
-    };
-public:
-
-  /// Construct color well with initial color clr
-  FXColorWell(FXComposite* p,FXColor clr=0,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=COLORWELL_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Returns true because a color well can receive focus
-  virtual bool canFocus() const;
-
-  /// Move the focus to this window
-  virtual void setFocus();
-
-  /// Remove the focus from this window
-  virtual void killFocus();
-
-  /// Set color
-  void setRGBA(FXColor clr,FXbool notify=FALSE);
-
-  /// Get color
-  FXColor getRGBA() const { return rgba; }
-
-  /// Set status line help text for this color well
-  void setHelpText(const FXString& text){ help=text; }
-
-  /// Get status line help text for this color well
-  const FXString& getHelpText() const { return help; }
-
-  /// Set tool tip message for this color well
-  void setTipText(const FXString& text){ tip=text; }
-
-  /// Get tool tip message for this color well
-  const FXString& getTipText() const { return tip; }
-
-  /// Return true if only opaque colors allowed
-  FXbool isOpaqueOnly() const;
-
-  /// Change opaque only mode
-  void setOpaqueOnly(FXbool opaque);
-
-  /// Save color well to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load color well from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXColorWell();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXColorWheel.h b/fox-includes/FXColorWheel.h
deleted file mode 100755
index 68738061..00000000
--- a/fox-includes/FXColorWheel.h
+++ /dev/null
@@ -1,139 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        C o l o r W h e e l   W i d g e t                      *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2001,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXColorWheel.h 2188 2005-08-24 07:48:22Z lyle $                      *
-********************************************************************************/
-#ifndef FXCOLORWHEEL_H
-#define FXCOLORWHEEL_H
-
-#ifndef FXFRAME_H
-#include "FXFrame.h"
-#endif
-
-namespace FX {
-
-
-class FXImage;
-
-
-/**
-* A ColorWheel is a widget which controls the hue and saturation values of a
-* color.  It is most often used together with a Color Bar which controls the
-* brighness.
-*/
-class FXAPI FXColorWheel : public FXFrame {
-  FXDECLARE(FXColorWheel)
-protected:
-  FXImage  *dial;         // HSV dial image
-  FXfloat   hsv[3];       // Hue, saturation, value
-  FXint     dialx;        // Dial x location
-  FXint     dialy;        // Dial Y location
-  FXint     spotx;        // Spot x location
-  FXint     spoty;        // Spot Y location
-  FXString  tip;          // Tooltip value
-  FXString  help;         // Help value
-protected:
-  FXColorWheel();
-  void updatedial();
-  void movespot(FXint x,FXint y);
-  FXbool hstoxy(FXint& x,FXint& y,FXfloat h,FXfloat s) const;
-  FXbool xytohs(FXfloat& h,FXfloat& s,FXint x,FXint y) const;
-private:
-  FXColorWheel(const FXColorWheel&);
-  FXColorWheel &operator=(const FXColorWheel&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onMouseWheel(FXObject*,FXSelector,void*);
-  long onCmdSetHelp(FXObject*,FXSelector,void*);
-  long onCmdGetHelp(FXObject*,FXSelector,void*);
-  long onCmdSetTip(FXObject*,FXSelector,void*);
-  long onCmdGetTip(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct color wheel with initial color clr
-  FXColorWheel(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=FRAME_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Change hue
-  void setHue(FXfloat h);
-
-  /// Return hue
-  FXfloat getHue() const { return hsv[0]; }
-
-  /// Change saturation
-  void setSat(FXfloat s);
-
-  /// Return saturation
-  FXfloat getSat() const { return hsv[1]; }
-
-  /// Change value
-  void setVal(FXfloat v);
-
-  /// Return value
-  FXfloat getVal() const { return hsv[2]; }
-
-  /// Set hue, saturation, value
-  void setHueSatVal(FXfloat h,FXfloat s,FXfloat v);
-
-  /// Set status line help text for this color well
-  void setHelpText(const FXString& text){ help=text; }
-
-  /// Get status line help text for this color well
-  const FXString& getHelpText() const { return help; }
-
-  /// Set tool tip message for this color well
-  void setTipText(const FXString& text){ tip=text; }
-
-  /// Get tool tip message for this color well
-  const FXString& getTipText() const { return tip; }
-
-  /// Save color well to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load color well from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXColorWheel();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXComboBox.h b/fox-includes/FXComboBox.h
deleted file mode 100755
index 541394c0..00000000
--- a/fox-includes/FXComboBox.h
+++ /dev/null
@@ -1,303 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       C o m b o   B o x   W i d g e t                         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXComboBox.h 2342 2006-02-10 14:24:44Z lyle $                        *
-********************************************************************************/
-#ifndef FXCOMBOBOX_H
-#define FXCOMBOBOX_H
-
-#ifndef FXPACKER_H
-#include "FXPacker.h"
-#endif
-
-namespace FX {
-
-
-/// ComboBox styles
-enum {
-  COMBOBOX_NO_REPLACE     = 0,                  /// Leave the list the same
-  COMBOBOX_REPLACE        = 0x00020000,         /// Replace current item with typed text
-  COMBOBOX_INSERT_BEFORE  = 0x00040000,         /// Typed text inserted before current
-  COMBOBOX_INSERT_AFTER   = 0x00060000,         /// Typed text inserted after current
-  COMBOBOX_INSERT_FIRST   = 0x00080000,         /// Typed text inserted at begin of list
-  COMBOBOX_INSERT_LAST    = 0x00090000,         /// Typed text inserted at end of list
-  COMBOBOX_STATIC         = 0x00100000,         /// Unchangable text box
-  COMBOBOX_NORMAL         = 0                   /// Can type text but list is not changed
-  };
-
-
-class FXTextField;
-class FXMenuButton;
-class FXList;
-class FXPopup;
-
-
-/**
-* A Combo Box provides a way to select a string from a list of strings.
-* Unless COMBOBOX_STATIC is passed, it also allows the user to enter a new
-* string into the text field, for example if the desired entry is not in the
-* list of strings.  Passing COMBOBOX_REPLACE, COMBOBOX_INSERT_BEFORE, COMBOBOX_INSERT_AFTER,
-* COMBOBOX_INSERT_FIRST, or COMBOBOX_INSERT_LAST causes a newly entered text to replace the
-* current one in the list, or be added before or after the current entry, or to be added at
-* the beginning or end of the list.
-* Combo Box is intended to enter text; if you need to enter a choice from a list of
-* options, it is recommended that the List Box widget is used instead.
-* When the text in the field is changed, a SEL_COMMAND will be send to the target.
-* The Combo Box can also receive ID_GETSTRINGVALUE and ID_SETSTRINGVALUE and so
-* on, which will behave similar to Text Field in that they will retrieve or update
-* the value of the field.
-*/
-class FXAPI FXComboBox : public FXPacker {
-  FXDECLARE(FXComboBox)
-protected:
-  FXTextField   *field;
-  FXMenuButton  *button;
-  FXList        *list;
-  FXPopup       *pane;
-protected:
-  FXComboBox(){}
-private:
-  FXComboBox(const FXComboBox&);
-  FXComboBox &operator=(const FXComboBox&);
-public:
-  long onFocusUp(FXObject*,FXSelector,void*);
-  long onFocusDown(FXObject*,FXSelector,void*);
-  long onFocusSelf(FXObject*,FXSelector,void*);
-  long onMouseWheel(FXObject*,FXSelector,void*);
-  long onTextButton(FXObject*,FXSelector,void*);
-  long onTextChanged(FXObject*,FXSelector,void*);
-  long onTextCommand(FXObject*,FXSelector,void*);
-  long onListClicked(FXObject*,FXSelector,void*);
-  long onFwdToText(FXObject*,FXSelector,void*);
-  long onUpdFmText(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_LIST=FXPacker::ID_LAST,
-    ID_TEXT,
-    ID_LAST
-    };
-public:
-
-  /// Construct a Combo Box widget with room to display cols columns of text
-  FXComboBox(FXComposite *p,FXint cols,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=COMBOBOX_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Destroy server-side resources
-  virtual void destroy();
-
-  /// Enable combo box
-  virtual void enable();
-
-  /// Disable combo box
-  virtual void disable();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return true if combobox is editable
-  FXbool isEditable() const;
-
-  /// Set editable state
-  void setEditable(FXbool edit=TRUE);
-
-  /// Set the text
-  void setText(const FXString& text);
-
-  /// Get the text
-  FXString getText() const;
-
-  /// Set the number of columns
-  void setNumColumns(FXint cols);
-
-  /// Get the number of columns
-  FXint getNumColumns() const;
-
-  /// Change text justification mode; default is JUSTIFY_LEFT
-  void setJustify(FXuint mode);
-
-  /// Return text justification mode
-  FXuint getJustify() const;
-
-  /// Return the number of items in the list
-  FXint getNumItems() const;
-
-  /// Return the number of visible items
-  FXint getNumVisible() const;
-
-  /// Set the number of visible items in the drop down list
-  void setNumVisible(FXint nvis);
-
-  /// Return true if current item
-  FXbool isItemCurrent(FXint index) const;
-
-  /// Set the current item (index is zero-based)
-  void setCurrentItem(FXint index,FXbool notify=FALSE);
-
-  /// Get the current item's index
-  FXint getCurrentItem() const;
-
-  /// Return the item at the given index
-  FXString getItem(FXint index) const;
-
-  /// Replace the item at index
-  FXint setItem(FXint index,const FXString& text,void* ptr=NULL);
-
-  /// Fill combo box by appending items from array of strings
-  FXint fillItems(const FXchar** strings);
-
-  /// Fill combo box by appending items from newline separated strings
-  FXint fillItems(const FXString& strings);
-
-  /// Insert a new item at index
-  FXint insertItem(FXint index,const FXString& text,void* ptr=NULL);
-
-  /// Append an item to the list
-  FXint appendItem(const FXString& text,void* ptr=NULL);
-
-  /// Prepend an item to the list
-  FXint prependItem(const FXString& text,void* ptr=NULL);
-
-  /// Move item from oldindex to newindex
-  FXint moveItem(FXint newindex,FXint oldindex);
-
-  /// Remove this item from the list
-  void removeItem(FXint index);
-
-  /// Remove all items from the list
-  void clearItems();
-
-  /**
-  * Search items by name, beginning from item start.  If the start item
-  * is -1 the search will start at the first item in the list.  Flags
-  * may be SEARCH_FORWARD or SEARCH_BACKWARD to control the search
-  * direction; this can be combined with SEARCH_NOWRAP or SEARCH_WRAP
-  * to control whether the search wraps at the start or end of the list.
-  * The option SEARCH_IGNORECASE causes a case-insensitive match.  Finally,
-  * passing SEARCH_PREFIX causes searching for a prefix of the item name.
-  * Return -1 if no matching item is found.
-  */
-  FXint findItem(const FXString& text,FXint start=-1,FXuint flags=SEARCH_FORWARD|SEARCH_WRAP) const;
-
-  /**
-  * Search items by associated user data, beginning from item start. If the
-  * start item is -1 the search will start at the first item in the list.
-  * Flags may be SEARCH_FORWARD or SEARCH_BACKWARD to control the
-  * search direction; this can be combined with SEARCH_NOWRAP or SEARCH_WRAP
-  * to control whether the search wraps at the start or end of the list.
-  */
-  FXint findItemByData(const void *ptr,FXint start=-1,FXuint flags=SEARCH_FORWARD|SEARCH_WRAP) const;
-
-  /// Set text for specified item
-  void setItemText(FXint index,const FXString& text);
-
-  /// Get text for specified item
-  FXString getItemText(FXint index) const;
-
-  /// Set data pointer for specified item
-  void setItemData(FXint index,void* ptr) const;
-
-  /// Get data pointer for specified item
-  void* getItemData(FXint index) const;
-
-  /// Is the pane shown
-  FXbool isPaneShown() const;
-
-  /// Sort items using current sort function
-  void sortItems();
-
-  /// Set text font
-  void setFont(FXFont* fnt);
-
-  /// Get text font
-  FXFont* getFont() const;
-
-  /// Set the combobox style.
-  void setComboStyle(FXuint mode);
-
-  /// Get the combobox style.
-  FXuint getComboStyle() const;
-
-  /// Set window background color
-  virtual void setBackColor(FXColor clr);
-
-  /// Get background color
-  FXColor getBackColor() const;
-
-  /// Change text color
-  void setTextColor(FXColor clr);
-
-  /// Return text color
-  FXColor getTextColor() const;
-
-  /// Change selected background color
-  void setSelBackColor(FXColor clr);
-
-  /// Return selected background color
-  FXColor getSelBackColor() const;
-
-  /// Change selected text color
-  void setSelTextColor(FXColor clr);
-
-  /// Return selected text color
-  FXColor getSelTextColor() const;
-
-  /// Return sort function
-  FXListSortFunc getSortFunc() const;
-
-  /// Change sort function
-  void setSortFunc(FXListSortFunc func);
-
-  /// Set the combobox help text
-  void setHelpText(const FXString& txt);
-
-  /// Get the combobox help text
-  const FXString& getHelpText() const;
-
-  /// Set the tool tip message for this combobox
-  void setTipText(const FXString& txt);
-
-  /// Get the tool tip message for this combobox
-  const FXString& getTipText() const;
-
-  /// Save combobox to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load combobox from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXComboBox();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXComposeContext.h b/fox-includes/FXComposeContext.h
deleted file mode 100644
index d004797a..00000000
--- a/fox-includes/FXComposeContext.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                         C o m p o s e - C o n t e x t                         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2005 by Jeroen van der Zijp.   All Rights Reserved.             *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXComposeContext.h 2335 2006-01-28 02:33:03Z lyle $                   *
-********************************************************************************/
-#ifndef FXCOMPOSECONTEXT_H
-#define FXCOMPOSECONTEXT_H
-
-#ifndef FXID_H
-#include "FXId.h"
-#endif
-
-namespace FX {
-
-
-class FXApp;
-class FXWindow;
-
-
-/**
-* Compose Context manages the state of an input method
-* if input method support is enabled.
-*/
-class FXAPI FXComposeContext : public FXId {
-  FXDECLARE(FXComposeContext)
-protected:
-  FXWindow  *window;            // Window we belong to
-  FXSelector message;           // Message to send it
-private:
-#ifndef WIN32
-  static int  editStartCallback(void*,FXComposeContext*,void*);
-  static void editDoneCallback(void*,FXComposeContext*,void*);
-  static void editDrawCallback(void*,FXComposeContext*,void*);
-  static void editCaretCallback(void*,FXComposeContext*,void*);
-  static void statusStartCallback(void*,FXComposeContext*,void*);
-  static void statusDoneCallback(void*,FXComposeContext*,void*);
-  static void statusDrawCallback(void*,FXComposeContext*,void*);
-#endif
-protected:
-  FXComposeContext();
-private:
-  FXComposeContext(const FXComposeContext&);
-  FXComposeContext &operator=(const FXComposeContext&);
-public:
-
-  /// Construct compose context for given window
-  FXComposeContext(FXApp* a,FXWindow* win=NULL,FXSelector sel=0);
-
-  /// Create resource
-  virtual void create();
-
-  /// Destroy resource
-  virtual void destroy();
-
-  /// Focus in
-  void focusIn();
-
-  /// Focus out
-  void focusOut();
-
-  /// Set the spot
-  void setSpot(FXint x,FXint y);
-
-  /// Set the area
-  void setArea(FXint x,FXint y,FXint w,FXint h);
-
-  /// Translate key event
-  FXString translateEvent(FXRawEvent& event);
-
-  /// Destructor
-  virtual ~FXComposeContext();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXComposite.h b/fox-includes/FXComposite.h
deleted file mode 100755
index abe1827d..00000000
--- a/fox-includes/FXComposite.h
+++ /dev/null
@@ -1,88 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       C o m p o s i t e   W i d g e t                         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXComposite.h 2335 2006-01-28 02:33:03Z lyle $                       *
-********************************************************************************/
-#ifndef FXCOMPOSITE_H
-#define FXCOMPOSITE_H
-
-#ifndef FXWINDOW_H
-#include "FXWindow.h"
-#endif
-
-namespace FX {
-
-
-/// Base composite
-class FXAPI FXComposite : public FXWindow {
-  FXDECLARE(FXComposite)
-protected:
-  FXComposite(){}
-  FXComposite(FXApp* a,FXVisual *vis);
-  FXComposite(FXApp* a,FXWindow* own,FXuint opts,FXint x,FXint y,FXint w,FXint h);
-private:
-  FXComposite(const FXComposite&);
-  FXComposite &operator=(const FXComposite&);
-public:
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onFocusNext(FXObject*,FXSelector,void*);
-  long onFocusPrev(FXObject*,FXSelector,void*);
-  long onCmdUpdate(FXObject*,FXSelector,void*);
-public:
-
-  /// Constructor
-  FXComposite(FXComposite* p,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Destroy server-side resources
-  virtual void destroy();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Return the width of the widest child window
-  FXint maxChildWidth() const;
-
-  /// Return the height of the tallest child window
-  FXint maxChildHeight() const;
-
-  /// Overrides this virtual function to return TRUE
-  virtual bool isComposite() const;
-
-  /// Destructor
-  virtual ~FXComposite();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXCursor.h b/fox-includes/FXCursor.h
deleted file mode 100755
index 61c354d3..00000000
--- a/fox-includes/FXCursor.h
+++ /dev/null
@@ -1,131 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                         C u r s o r - O b j e c t                             *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXCursor.h 2335 2006-01-28 02:33:03Z lyle $                          *
-********************************************************************************/
-#ifndef FXCURSOR_H
-#define FXCURSOR_H
-
-#ifndef FXID_H
-#include "FXId.h"
-#endif
-
-namespace FX {
-
-
-// Stock cursors
-enum FXStockCursor {
-  CURSOR_ARROW=1,               /// Default left pointing arrow
-  CURSOR_RARROW,                /// Right arrow
-  CURSOR_IBEAM,                 /// Text I-Beam
-  CURSOR_WATCH,                 /// Stopwatch or hourglass
-  CURSOR_CROSS,                 /// Crosshair
-  CURSOR_UPDOWN,                /// Move up, down
-  CURSOR_LEFTRIGHT,             /// Move left, right
-  CURSOR_MOVE                   /// Move up,down,left,right
-  };
-
-
-/// Cursor options
-enum {
-  CURSOR_KEEP  = 0x00000100,    /// Keep pixel data in client
-  CURSOR_OWNED = 0x00000200     /// Pixel data is owned by image
-  };
-
-
-/// Cursor class
-class FXAPI FXCursor : public FXId {
-  FXDECLARE(FXCursor)
-protected:
-  FXColor *data;        // Source data
-  FXint    width;       // Width
-  FXint    height;      // Height
-  FXint    hotx;        // Hot spot x
-  FXint    hoty;        // Hot spot y
-  FXuint   options;     // Options
-protected:
-  FXCursor();
-private:
-  FXCursor(const FXCursor&);
-  FXCursor &operator=(const FXCursor&);
-public:
-
-  /// Make stock cursor
-  FXCursor(FXApp* a,FXStockCursor curid=CURSOR_ARROW);
-
-  /// Make cursor from source and mask; cursor size should at most 32x32 for portability!
-  FXCursor(FXApp* a,const FXuchar* src,const FXuchar* msk,FXint w=32,FXint h=32,FXint hx=0,FXint hy=0);
-
-  /// Make cursor from FXColor pixels; cursor size should be at most 32x32 for portability!
-  FXCursor(FXApp* a,const FXColor* pix,FXint w=32,FXint h=32,FXint hx=0,FXint hy=0);
-
-  /// Width of cursor; returns 0 for stock cursors
-  FXint getWidth() const { return width; }
-
-  /// Height of cursor; returns 0 for stock cursors
-  FXint getHeight() const { return height; }
-
-  /// Set hotspot x; returns 0 for stock cursors
-  void setHotX(FXint x){ hotx=x; }
-
-  /// Get hotspot x; returns 0 for stock cursors
-  FXint getHotX() const { return hotx; }
-
-  /// Set hotspot y; returns 0 for stock cursors
-  void setHotY(FXint y){ hoty=y; }
-
-  /// Get hotspot y; returns 0 for stock cursors
-  FXint getHotY() const { return hoty; }
-
-  /// Check if there is color in the cursor
-  bool isColor() const;
-
-  /// Create cursor
-  virtual void create();
-
-  /// Detach cursor
-  virtual void detach();
-
-  /// Destroy cursor
-  virtual void destroy();
-
-  /// Release pixels buffer if it was owned
-  virtual void release();
-
-  /// Save pixel data only
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixel data only
-  virtual bool loadPixels(FXStream& store);
-
-  /// Save cursor to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load cursor from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXCursor();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXDC.h b/fox-includes/FXDC.h
deleted file mode 100755
index 4aead6ff..00000000
--- a/fox-includes/FXDC.h
+++ /dev/null
@@ -1,429 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*               D e v i c e   C o n t e x t   B a s e   C l a s s               *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1999,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDC.h 2193 2005-08-24 08:08:50Z lyle $                              *
-********************************************************************************/
-#ifndef FXDC_H
-#define FXDC_H
-
-namespace FX {
-
-/// Drawing (BITBLT) functions
-enum FXFunction {
-  BLT_CLR,                        /// D := 0
-  BLT_SRC_AND_DST,                /// D := S & D
-  BLT_SRC_AND_NOT_DST,            /// D := S & ~D
-  BLT_SRC,                        /// D := S
-  BLT_NOT_SRC_AND_DST,            /// D := ~S & D
-  BLT_DST,                        /// D := D
-  BLT_SRC_XOR_DST,                /// D := S ^ D
-  BLT_SRC_OR_DST,                 /// D := S | D
-  BLT_NOT_SRC_AND_NOT_DST,        /// D := ~S & ~D  ==  D := ~(S | D)
-  BLT_NOT_SRC_XOR_DST,            /// D := ~S ^ D
-  BLT_NOT_DST,                    /// D := ~D
-  BLT_SRC_OR_NOT_DST,             /// D := S | ~D
-  BLT_NOT_SRC,                    /// D := ~S
-  BLT_NOT_SRC_OR_DST,             /// D := ~S | D
-  BLT_NOT_SRC_OR_NOT_DST,         /// D := ~S | ~D  ==  ~(S & D)
-  BLT_SET                         /// D := 1
-  };
-
-
-/// Line Styles
-enum FXLineStyle {
-  LINE_SOLID,                     /// Solid lines
-  LINE_ONOFF_DASH,                /// On-off dashed lines
-  LINE_DOUBLE_DASH                /// Double dashed lines
-  };
-
-
-/// Line Cap Styles
-enum FXCapStyle {
-  CAP_NOT_LAST,                   /// Don't include last end cap
-  CAP_BUTT,                       /// Butting line end caps
-  CAP_ROUND,                      /// Round line end caps
-  CAP_PROJECTING                  /// Projecting line end caps
-  };
-
-
-/// Line Join Styles
-enum FXJoinStyle {
-  JOIN_MITER,                     /// Mitered or pointy joints
-  JOIN_ROUND,                     /// Round line joints
-  JOIN_BEVEL                      /// Beveled or flat joints
-  };
-
-
-/// Fill Styles
-enum FXFillStyle {
-  FILL_SOLID,                     /// Fill with solid color
-  FILL_TILED,                     /// Fill with tiled bitmap
-  FILL_STIPPLED,                  /// Fill where stipple mask is 1
-  FILL_OPAQUESTIPPLED             /// Fill with foreground where mask is 1, background otherwise
-  };
-
-
-/// Fill Rules
-enum FXFillRule {
-  RULE_EVEN_ODD,                  /// Even odd polygon filling
-  RULE_WINDING                    /// Winding rule polygon filling
-  };
-
-
-/// Stipple/dither patterns
-enum FXStipplePattern {
-  STIPPLE_0         = 0,
-  STIPPLE_NONE      = 0,
-  STIPPLE_BLACK     = 0,            /// All ones
-  STIPPLE_1         = 1,
-  STIPPLE_2         = 2,
-  STIPPLE_3         = 3,
-  STIPPLE_4         = 4,
-  STIPPLE_5         = 5,
-  STIPPLE_6         = 6,
-  STIPPLE_7         = 7,
-  STIPPLE_8         = 8,
-  STIPPLE_GRAY      = 8,            /// 50% gray
-  STIPPLE_9         = 9,
-  STIPPLE_10        = 10,
-  STIPPLE_11        = 11,
-  STIPPLE_12        = 12,
-  STIPPLE_13        = 13,
-  STIPPLE_14        = 14,
-  STIPPLE_15        = 15,
-  STIPPLE_16        = 16,
-  STIPPLE_WHITE     = 16,           /// All zeroes
-  STIPPLE_HORZ      = 17,           /// Horizontal hatch pattern
-  STIPPLE_VERT      = 18,           /// Vertical hatch pattern
-  STIPPLE_CROSS     = 19,           /// Cross-hatch pattern
-  STIPPLE_DIAG      = 20,           /// Diagonal // hatch pattern
-  STIPPLE_REVDIAG   = 21,           /// Reverse diagonal \\ hatch pattern
-  STIPPLE_CROSSDIAG = 22            /// Cross-diagonal hatch pattern
-  };
-
-
-/// Line segment
-struct FXSegment {
-  FXshort x1,y1,x2,y2;
-  };
-
-
-/// Arc
-struct FXArc {
-  FXshort x,y,w,h,a,b;
-  };
-
-
-class FXApp;
-class FXImage;
-class FXBitmap;
-class FXIcon;
-class FXFont;
-class FXDrawable;
-class FXRegion;
-
-
-/**
-* Abstract Device Context
-*
-* A Device Context is used to maintain the state of the graphics drawing system.
-* Defining your drawing code in terms of the Abstract Device Context allows the
-* drawing commands to be rendered on different types of surfaces, such as windows
-* and images (FXDCWindow), or on paper (FXDCPrint).
-* WYSYWYG may be obtained by using the same identical drawing code in your
-* application regardless of the actual device surface being utilized.
-*/
-class FXAPI FXDC {
-  friend class FXFont;
-private:
-  FXApp           *app;         // Application
-protected:
-  void            *ctx;         // Context handle
-  FXFont          *font;        // Drawing font
-  FXStipplePattern pattern;     // Stipple pattern
-  FXBitmap        *stipple;     // Stipple bitmap
-  FXImage         *tile;        // Tile image
-  FXBitmap        *mask;        // Mask bitmap
-  FXRectangle      clip;        // Clip rectangle
-  FXColor          fg;          // Foreground color
-  FXColor          bg;          // Background color
-  FXuint           width;       // Line width
-  FXCapStyle       cap;         // Line cap style
-  FXJoinStyle      join;        // Line join style
-  FXLineStyle      style;       // Line style
-  FXFillStyle      fill;        // Fill style
-  FXFillRule       rule;        // Fill rule
-  FXFunction       rop;         // RasterOp
-  FXchar           dashpat[32]; // Line dash pattern data
-  FXuint           dashlen;     // Line dash pattern length
-  FXuint           dashoff;     // Line dash pattern offset
-  FXint            tx;          // Tile dx
-  FXint            ty;          // Tile dy
-  FXint            cx;          // Clip x
-  FXint            cy;          // Clip y
-private:
-  FXDC();
-  FXDC(const FXDC&);
-  FXDC &operator=(const FXDC&);
-public:
-
-  /// Construct dummy DC
-  FXDC(FXApp* a);
-
-  /// Get application
-  FXApp* getApp() const { return app; }
-
-  /// Get context handle
-  void* context() const { return ctx; }
-
-  /// Read back pixel
-  virtual FXColor readPixel(FXint x,FXint y);
-
-  /// Draw points
-  virtual void drawPoint(FXint x,FXint y);
-  virtual void drawPoints(const FXPoint* points,FXuint npoints);
-  virtual void drawPointsRel(const FXPoint* points,FXuint npoints);
-
-  /// Draw lines
-  virtual void drawLine(FXint x1,FXint y1,FXint x2,FXint y2);
-  virtual void drawLines(const FXPoint* points,FXuint npoints);
-  virtual void drawLinesRel(const FXPoint* points,FXuint npoints);
-  virtual void drawLineSegments(const FXSegment* segments,FXuint nsegments);
-
-  /// Draw rectangles
-  virtual void drawRectangle(FXint x,FXint y,FXint w,FXint h);
-  virtual void drawRectangles(const FXRectangle* rectangles,FXuint nrectangles);
-
-  /// Draw rounded rectangle with ellipse with ew and ellips height eh
-  virtual void drawRoundRectangle(FXint x,FXint y,FXint w,FXint h,FXint ew,FXint eh);
-
-  /**
-  * Draw arcs.
-  * The argument ang1 specifies the start of the arc relative to the
-  * three-o'clock position from the center, in units of degrees*64.
-  * The argument ang2 specifies the path and extent of the arc relative
-  * to the start of the arc, in units of degrees*64.
-  * The arguments x,y,w,h specify the bounding rectangle.
-  */
-  virtual void drawArc(FXint x,FXint y,FXint w,FXint h,FXint ang1,FXint ang2);
-  virtual void drawArcs(const FXArc* arcs,FXuint narcs);
-
-  /// Draw ellipse
-  virtual void drawEllipse(FXint x,FXint y,FXint w,FXint h);
-
-  /// Filled rectangles
-  virtual void fillRectangle(FXint x,FXint y,FXint w,FXint h);
-  virtual void fillRectangles(const FXRectangle* rectangles,FXuint nrectangles);
-
-  /// Filled rounded rectangle with ellipse with ew and ellips height eh
-  virtual void fillRoundRectangle(FXint x,FXint y,FXint w,FXint h,FXint ew,FXint eh);
-
-  /// Fill chord
-  virtual void fillChord(FXint x,FXint y,FXint w,FXint h,FXint ang1,FXint ang2);
-  virtual void fillChords(const FXArc* chords,FXuint nchords);
-
-  /// Fill arcs
-  virtual void fillArc(FXint x,FXint y,FXint w,FXint h,FXint ang1,FXint ang2);
-  virtual void fillArcs(const FXArc* arcs,FXuint narcs);
-
-  /// Fill ellipse
-  virtual void fillEllipse(FXint x,FXint y,FXint w,FXint h);
-
-  /// Filled polygon
-  virtual void fillPolygon(const FXPoint* points,FXuint npoints);
-  virtual void fillConcavePolygon(const FXPoint* points,FXuint npoints);
-  virtual void fillComplexPolygon(const FXPoint* points,FXuint npoints);
-
-  /// Filled polygon with relative points
-  virtual void fillPolygonRel(const FXPoint* points,FXuint npoints);
-  virtual void fillConcavePolygonRel(const FXPoint* points,FXuint npoints);
-  virtual void fillComplexPolygonRel(const FXPoint* points,FXuint npoints);
-
-  /// Draw hashed box
-  virtual void drawHashBox(FXint x,FXint y,FXint w,FXint h,FXint b=1);
-
-  /// Draw focus rectangle
-  virtual void drawFocusRectangle(FXint x,FXint y,FXint w,FXint h);
-
-  /// Draw area from source
-  virtual void drawArea(const FXDrawable* source,FXint sx,FXint sy,FXint sw,FXint sh,FXint dx,FXint dy);
-
-  /// Draw area stretched area from source
-  virtual void drawArea(const FXDrawable* source,FXint sx,FXint sy,FXint sw,FXint sh,FXint dx,FXint dy,FXint dw,FXint dh);
-
-  /// Draw image
-  virtual void drawImage(const FXImage* image,FXint dx,FXint dy);
-
-  /// Draw bitmap
-  virtual void drawBitmap(const FXBitmap* bitmap,FXint dx,FXint dy);
-
-  /// Draw icon
-  virtual void drawIcon(const FXIcon* icon,FXint dx,FXint dy);
-  virtual void drawIconShaded(const FXIcon* icon,FXint dx,FXint dy);
-  virtual void drawIconSunken(const FXIcon* icon,FXint dx,FXint dy);
-
-  /// Draw string with base line starting at x, y
-  virtual void drawText(FXint x,FXint y,const FXString& string);
-  virtual void drawText(FXint x,FXint y,const FXchar* string,FXuint length);
-
-  /// Draw text starting at x, y over filled background
-  virtual void drawImageText(FXint x,FXint y,const FXString& string);
-  virtual void drawImageText(FXint x,FXint y,const FXchar* string,FXuint length);
-
-  /// Set foreground drawing color
-  virtual void setForeground(FXColor clr);
-
-  /// Get foreground drawing color
-  FXColor getForeground() const { return fg; }
-
-  /// Set background drawing color
-  virtual void setBackground(FXColor clr);
-
-  /// Get background drawing color
-  FXColor getBackground() const { return bg; }
-
-  /**
-  * Set dash pattern and dash offset.
-  * A dash pattern of [1 2 3 4] is a repeating pattern of 1 foreground pixel,
-  * 2 background pixels, 3 foreground pixels, and 4 background pixels.
-  * The offset is where in the pattern the system will start counting.
-  * The maximum length of the dash pattern is 32.
-  */
-  virtual void setDashes(FXuint dashoffset,const FXchar *dashpattern,FXuint dashlength);
-
-  /// Get dash pattern
-  const FXchar* getDashPattern() const { return dashpat; }
-
-  /// Get dash offset
-  FXuint getDashOffset() const { return dashoff; }
-
-  /// Get dash length
-  FXuint getDashLength() const { return dashlen; }
-
-  /// Set line width:- 0 means thinnest/fastest possible
-  virtual void setLineWidth(FXuint linewidth=0);
-
-  /// Get line width
-  FXuint getLineWidth() const { return width; }
-
-  /// Set line cap style
-  virtual void setLineCap(FXCapStyle capstyle=CAP_BUTT);
-
-  /// Get line cap style
-  FXCapStyle getLineCap() const { return cap; }
-
-  /// Set line join style
-  virtual void setLineJoin(FXJoinStyle joinstyle=JOIN_MITER);
-
-  /// Get line join style
-  FXJoinStyle getLineJoin() const { return join; }
-
-  /// Set line style
-  virtual void setLineStyle(FXLineStyle linestyle=LINE_SOLID);
-
-  /// Get line style
-  FXLineStyle getLineStyle() const { return style; }
-
-  /// Set fill style
-  virtual void setFillStyle(FXFillStyle fillstyle=FILL_SOLID);
-
-  /// Get fill style
-  FXFillStyle getFillStyle() const { return fill; }
-
-  /// Set fill rule
-  virtual void setFillRule(FXFillRule fillrule=RULE_EVEN_ODD);
-
-  /// Get fill rule
-  FXFillRule getFillRule() const { return rule; }
-
-  /// Set rasterop function
-  virtual void setFunction(FXFunction func=BLT_SRC);
-
-  /// Get rasterop function
-  FXFunction getFunction() const { return rop; }
-
-  /// Set the tile image
-  virtual void setTile(FXImage* image,FXint dx=0,FXint dy=0);
-
-  /// Get the tile image
-  FXImage *getTile() const { return tile; }
-
-  /// Set the stipple pattern
-  virtual void setStipple(FXBitmap *bitmap,FXint dx=0,FXint dy=0);
-
-  /// Get stipple bitmap
-  FXBitmap *getStippleBitmap() const { return stipple; }
-
-  /// Set the stipple pattern
-  virtual void setStipple(FXStipplePattern pat,FXint dx=0,FXint dy=0);
-
-  /// Get pattern
-  FXStipplePattern getStipplePattern() const { return pattern; }
-
-  /// Set clip region
-  virtual void setClipRegion(const FXRegion& region);
-
-  /// Set clip rectangle
-  virtual void setClipRectangle(FXint x,FXint y,FXint w,FXint h);
-
-  /// Change clip rectangle
-  virtual void setClipRectangle(const FXRectangle& rectangle);
-
-  /// Return clip rectangle
-  const FXRectangle& getClipRectangle() const { return clip; }
-
-  /// Return clip x
-  FXint getClipX() const { return clip.x; }
-
-  /// Return clip y
-  FXint getClipY() const { return clip.y; }
-
-  /// Return clip width
-  FXint getClipWidth() const { return clip.w; }
-
-  /// Return clip height
-  FXint getClipHeight() const { return clip.h; }
-
-  /// Clear clipping
-  virtual void clearClipRectangle();
-
-  /// Set clip mask
-  virtual void setClipMask(FXBitmap* bitmap,FXint dx=0,FXint dy=0);
-
-  /// Clear clip mask
-  virtual void clearClipMask();
-
-  /// Set font to draw text with
-  virtual void setFont(FXFont *fnt);
-
-  /// Get text font
-  FXFont* getFont() const { return font; }
-
-  /// Clip against child windows
-  virtual void clipChildren(FXbool yes);
-
-  /// Destructor
-  virtual ~FXDC();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXDCPrint.h b/fox-includes/FXDCPrint.h
deleted file mode 100755
index 925e9ef6..00000000
--- a/fox-includes/FXDCPrint.h
+++ /dev/null
@@ -1,294 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*           D e v i c e   C o n t e x t   F o r   P r i n t i n g               *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDCPrint.h 2194 2005-08-24 12:58:14Z lyle $                         *
-********************************************************************************/
-#ifndef FXDCPRINT_H
-#define FXDCPRINT_H
-
-#ifndef FXDC_H
-#include "FXDC.h"
-#endif
-
-//////////////////////////////  UNDER DEVELOPMENT  //////////////////////////////
-
-namespace FX {
-
-class FXApp;
-class FXDrawable;
-class FXImage;
-class FXBitmap;
-class FXIcon;
-class FXFont;
-
-
-/// Printer flags
-enum FXPrintFlags {
-  PRINT_DEST_PAPER        = 0,    /// Send print to paper
-  PRINT_DEST_FILE         = 1,    /// Send print to file
-  PRINT_PAGES_ALL         = 0,    /// Print all pages
-  PRINT_PAGES_EVEN        = 2,    /// Print even pages only
-  PRINT_PAGES_ODD         = 4,    /// Print odd pages only
-  PRINT_PAGES_RANGE       = 8,    /// Print range of pages
-  PRINT_COLLATE_NORMAL    = 0,    /// Normal collate order
-  PRINT_COLLATE_REVERSED  = 16,   /// Reversed collate order
-  PRINT_PORTRAIT          = 0,    /// Portrait orientation
-  PRINT_LANDSCAPE         = 32,   /// Landscape orientation
-  PRINT_BLACKANDWHITE     = 0,    /// Black and white output
-  PRINT_COLOR             = 64,   /// Color output
-  PRINT_NOBOUNDS          = 128   /// Must determine bounding box
-  };
-
-
-/// Printer media size
-enum FXMediaSize {
-  MEDIA_CUSTOM            = 0,    /// Custom paper size
-  MEDIA_USLETTER          = 1,    /// US Letter size
-  MEDIA_LEGAL             = 2,    /// US Legal size
-  MEDIA_A4                = 3,    /// A4
-  MEDIA_ENVELOPE          = 4     /// #10 Envelope
-  };
-
-
-/// Bounding box
-struct FXPSBounds {
-  FXdouble  xmin;
-  FXdouble  xmax;
-  FXdouble  ymin;
-  FXdouble  ymax;
-  };
-
-
-/// Describes printer
-struct FXAPI FXPrinter {
-  FXString name;                          /// Printer name
-  FXuint   firstpage;                     /// First page that can be printed
-  FXuint   lastpage;                      /// Last page that can be printed
-  FXuint   currentpage;                   /// Current page to print
-  FXuint   frompage;                      /// On output, this is the first page to print
-  FXuint   topage;                        /// On output, last page to print
-  FXuint   mediasize;                     /// Media size index
-  FXdouble mediawidth;                    /// Width of paper in points [1/72 of an inch]
-  FXdouble mediaheight;                   /// Height of paper in points
-  FXdouble leftmargin;                    /// Left margin
-  FXdouble rightmargin;                   /// Right margin
-  FXdouble topmargin;                     /// Top margin
-  FXdouble bottommargin;                  /// Bottom margin
-  FXuint   numcopies;                     /// Number of copies
-  FXuint   flags;                         /// Flags
-  };
-
-
-/// Postscript Printer Device Context
-class FXAPI FXDCPrint : public FXDC {
-//  friend class FXGLViewer; // This is TEMPORARY!!!
-protected:
-  void      *psout;                   // File Stream for PS output
-  FXFont    *font;
-  FXuint     flags;
-  FXint      Xr,Yr;
-  FXdouble   mediawidth;              // Media width
-  FXdouble   mediaheight;             // Media height
-  FXPSBounds mediabb;                 // Media bounding box
-  FXPSBounds docbb;                   // Document bounding box
-  FXPSBounds pagebb;                  // Page bounding box
-  FXint      pagecount;               // Number of pages printed
-  FXint      nchars;                  // Number of characters on a line
-  FXint      pxmin;                   // min X coord in content
-  FXint      pymin;                   // min Y coord in content
-  FXint      pxmax;                   // max X coord in content
-  FXint      pymax;                   // max Y coord in content
-protected:
-  void bbox(FXfloat x,FXfloat y);
-  void tfm(FXfloat& xo,FXfloat& yo,FXfloat xi,FXfloat yi);
-private:
-  FXDCPrint();
-  FXDCPrint(const FXDCPrint&);
-  FXDCPrint &operator=(const FXDCPrint&);
-public:
-
-  /// Construct
-  FXDCPrint(FXApp* a);
-
-  /// Generate print job prolog
-  FXbool beginPrint(FXPrinter& job);
-
-  /// Generate print job epilog
-  FXbool endPrint();
-
-  /// Generate begin of page
-  FXbool beginPage(FXuint page=1);
-
-  /// Generate end of page
-  FXbool endPage();
-
-  FXbool setContentRange(FXint pxmin, FXint pymin, FXint pxmax, FXint pymax);
-
-  /// Draw points
-  virtual void drawPoint(FXint x,FXint y);
-  virtual void drawPoints(const FXPoint* points,FXuint npoints);
-  virtual void drawPointsRel(const FXPoint* points,FXuint npoints);
-
-  /// Draw lines
-  virtual void drawLine(FXint x1,FXint y1,FXint x2,FXint y2);
-  virtual void drawLines(const FXPoint* points,FXuint npoints);
-  virtual void drawLinesRel(const FXPoint* points,FXuint npoints);
-  virtual void drawLineSegments(const FXSegment* segments,FXuint nsegments);
-
-  /// Draw rectangles
-  virtual void drawRectangle(FXint x,FXint y,FXint w,FXint h);
-  virtual void drawRectangles(const FXRectangle* rectangles,FXuint nrectangles);
-
-  /// Draw rounded rectangle with ellipse with ew and ellips height eh
-  virtual void drawRoundRectangle(FXint x,FXint y,FXint w,FXint h,FXint ew,FXint eh);
-
-  /// Draw arcs
-  virtual void drawArc(FXint x,FXint y,FXint w,FXint h,FXint ang1,FXint ang2);
-  virtual void drawArcs(const FXArc* arcs,FXuint narcs);
-
-  /// Draw ellipse
-  virtual void drawEllipse(FXint x,FXint y,FXint w,FXint h);
-
-  /// Filled rectangles
-  virtual void fillRectangle(FXint x,FXint y,FXint w,FXint h);
-  virtual void fillRectangles(const FXRectangle* rectangles,FXuint nrectangles);
-
-  /// Filled rounded rectangle with ellipse with ew and ellips height eh
-  virtual void fillRoundRectangle(FXint x,FXint y,FXint w,FXint h,FXint ew,FXint eh);
-
-  /// Fill chord
-  virtual void fillChord(FXint x,FXint y,FXint w,FXint h,FXint ang1,FXint ang2);
-  virtual void fillChords(const FXArc* chords,FXuint nchords);
-
-  /// Draw arcs
-  virtual void fillArc(FXint x,FXint y,FXint w,FXint h,FXint ang1,FXint ang2);
-  virtual void fillArcs(const FXArc* arcs,FXuint narcs);
-
-  /// Fill ellipse
-  virtual void fillEllipse(FXint x,FXint y,FXint w,FXint h);
-
-  /// Filled polygon
-  virtual void fillPolygon(const FXPoint* points,FXuint npoints);
-  virtual void fillConcavePolygon(const FXPoint* points,FXuint npoints);
-  virtual void fillComplexPolygon(const FXPoint* points,FXuint npoints);
-
-  /// Filled polygon with relative points
-  virtual void fillPolygonRel(const FXPoint* points,FXuint npoints);
-  virtual void fillConcavePolygonRel(const FXPoint* points,FXuint npoints);
-  virtual void fillComplexPolygonRel(const FXPoint* points,FXuint npoints);
-
-  /// Draw hashed box
-  virtual void drawHashBox(FXint x,FXint y,FXint w,FXint h,FXint b=1);
-
-  /// Draw area from source
-  virtual void drawArea(const FXDrawable* source,FXint sx,FXint sy,FXint sw,FXint sh,FXint dx,FXint dy);
-
-  /// Draw area stretched area from source
-  virtual void drawArea(const FXDrawable* source,FXint sx,FXint sy,FXint sw,FXint sh,FXint dx,FXint dy,FXint dw,FXint dh);
-
-  /// Draw image
-  virtual void drawImage(const FXImage* image,FXint dx,FXint dy);
-
-  /// Draw bitmap
-  virtual void drawBitmap(const FXBitmap* bitmap,FXint dx,FXint dy);
-
-  /// Draw icon
-  virtual void drawIcon(const FXIcon* icon,FXint dx,FXint dy);
-  virtual void drawIconShaded(const FXIcon* icon,FXint dx,FXint dy);
-  virtual void drawIconSunken(const FXIcon* icon,FXint dx,FXint dy);
-
-  /// Draw string with base line starting at x, y
-  virtual void drawText(FXint x,FXint y,const FXString& string);
-  virtual void drawText(FXint x,FXint y,const FXchar* string,FXuint length);
-
-  /// Draw text starting at x, y over filled background
-  virtual void drawImageText(FXint x,FXint y,const FXString& string);
-  virtual void drawImageText(FXint x,FXint y,const FXchar* string,FXuint length);
-
-  /// Set foreground/background drawing color
-  virtual void setForeground(FXColor clr);
-  virtual void setBackground(FXColor clr);
-
-  /// Set dash pattern
-  virtual void setDashes(FXuint dashoffset,const FXchar *dashlist,FXuint n);
-
-  /// Set line width
-  virtual void setLineWidth(FXuint linewidth=0);
-
-  /// Set line cap style
-  virtual void setLineCap(FXCapStyle capstyle=CAP_BUTT);
-
-  /// Set line join style
-  virtual void setLineJoin(FXJoinStyle joinstyle=JOIN_MITER);
-
-  /// Set line style
-  virtual void setLineStyle(FXLineStyle linestyle=LINE_SOLID);
-
-  /// Set fill style
-  virtual void setFillStyle(FXFillStyle fillstyle=FILL_SOLID);
-
-  /// Set fill rule
-  virtual void setFillRule(FXFillRule fillrule=RULE_EVEN_ODD);
-
-  /// Set blit function
-  virtual void setFunction(FXFunction func=BLT_SRC);
-
-  /// Set the tile
-  virtual void setTile(FXImage* tile,FXint dx=0,FXint dy=0);
-
-  /// Set the stipple pattern
-  virtual void setStipple(FXBitmap *stipple,FXint dx=0,FXint dy=0);
-
-  /// Set the stipple pattern
-  virtual void setStipple(FXStipplePattern stipple,FXint dx=0,FXint dy=0);
-
-  /// Set clip rectangle
-  virtual void setClipRectangle(FXint x,FXint y,FXint w,FXint h);
-
-  /// Set clip rectangle
-  virtual void setClipRectangle(const FXRectangle& rectangle);
-
-  /// Clear clipping
-  virtual void clearClipRectangle();
-
-  /// Set clip mask
-  virtual void setClipMask(FXBitmap* mask,FXint dx=0,FXint dy=0);
-
-  /// Clear clip mask
-  virtual void clearClipMask();
-
-  /// Set font to draw text with
-  virtual void setFont(FXFont *fnt);
-
-  /// Clip drawing by child windows
-  virtual void clipChildren(FXbool yes);
-
-  /// Temporarily public; do not rely on this!!
-  void outhex(FXuint hex);
-  void outf(const char* format,...);
-
-  /// Cleanup
-  virtual ~FXDCPrint();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXDCWindow.h b/fox-includes/FXDCWindow.h
deleted file mode 100755
index e1cc1edb..00000000
--- a/fox-includes/FXDCWindow.h
+++ /dev/null
@@ -1,253 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*  D e v i c e   C o n t e x t   F o r   W i n d o w s   a n d   I m a g e s    *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1999,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDCWindow.h 2194 2005-08-24 12:58:14Z lyle $                        *
-********************************************************************************/
-#ifndef FXDCWINDOW_H
-#define FXDCWINDOW_H
-
-#ifndef FXDC_H
-#include "FXDC.h"
-#endif
-
-namespace FX {
-
-
-class FXApp;
-class FXDrawable;
-class FXImage;
-class FXBitmap;
-class FXIcon;
-class FXFont;
-class FXVisual;
-
-
-/**
-* Window Device Context
-*
-* The Window Device Context allows drawing into an FXDrawable, such as an
-* on-screen window (FXWindow and derivatives) or an off-screen image (FXImage
-* and its derivatives).
-* Because certain hardware resources are locked down, only one FXDCWindow may be
-* locked on a drawable at any one time.
-*/
-class FXAPI FXDCWindow : public FXDC {
-  friend class FXFont;
-protected:
-  FXDrawable *surface;        // Drawable surface
-  FXVisual   *visual;         // Visual of drawable
-  FXRectangle rect;           // Paint rectangle inside drawable
-#ifndef WIN32
-  FXuint      flags;          // GC Flags
-  FXPixel     devfg;          // Device foreground pixel value
-  FXPixel     devbg;          // Device background pixel value
-  void       *xftDraw;        // Hook used only for XFT support
-#else
-  FXID        oldpalette;
-  FXID        oldbrush;
-  FXID        oldpen;
-  FXPixel     devfg;          // Device foreground pixel value
-  FXPixel     devbg;          // Device background pixel value
-  FXbool      needsNewBrush;
-  FXbool      needsNewPen;
-  FXbool      needsPath;
-  FXbool      needsClipReset;
-#endif
-private:
-#ifdef WIN32
-  void updateBrush();
-  void updatePen();
-#endif
-private:
-  FXDCWindow();
-  FXDCWindow(const FXDCWindow&);
-  FXDCWindow &operator=(const FXDCWindow&);
-public:
-
-  /// Construct for painting in response to expose;
-  /// This sets the clip rectangle to the exposed rectangle
-  FXDCWindow(FXDrawable* drawable,FXEvent* event);
-
-  /// Construct for normal drawing;
-  /// This sets clip rectangle to the whole drawable
-  FXDCWindow(FXDrawable* drawable);
-
-  /// Begin locks in a drawable surface
-  void begin(FXDrawable *drawable);
-
-  /// End unlock the drawable surface
-  void end();
-
-  /// Read back pixel
-  virtual FXColor readPixel(FXint x,FXint y);
-
-  /// Draw points
-  virtual void drawPoint(FXint x,FXint y);
-  virtual void drawPoints(const FXPoint* points,FXuint npoints);
-  virtual void drawPointsRel(const FXPoint* points,FXuint npoints);
-
-  /// Draw lines
-  virtual void drawLine(FXint x1,FXint y1,FXint x2,FXint y2);
-  virtual void drawLines(const FXPoint* points,FXuint npoints);
-  virtual void drawLinesRel(const FXPoint* points,FXuint npoints);
-  virtual void drawLineSegments(const FXSegment* segments,FXuint nsegments);
-
-  /// Draw rectangles
-  virtual void drawRectangle(FXint x,FXint y,FXint w,FXint h);
-  virtual void drawRectangles(const FXRectangle* rectangles,FXuint nrectangles);
-
-  /// Draw rounded rectangle with ellipse with ew and ellips height eh
-  virtual void drawRoundRectangle(FXint x,FXint y,FXint w,FXint h,FXint ew,FXint eh);
-
-  /// Draw arcs
-  virtual void drawArc(FXint x,FXint y,FXint w,FXint h,FXint ang1,FXint ang2);
-  virtual void drawArcs(const FXArc* arcs,FXuint narcs);
-
-  /// Draw ellipse
-  virtual void drawEllipse(FXint x,FXint y,FXint w,FXint h);
-
-  /// Filled rectangles
-  virtual void fillRectangle(FXint x,FXint y,FXint w,FXint h);
-  virtual void fillRectangles(const FXRectangle* rectangles,FXuint nrectangles);
-
-  /// Filled rounded rectangle with ellipse with ew and ellips height eh
-  virtual void fillRoundRectangle(FXint x,FXint y,FXint w,FXint h,FXint ew,FXint eh);
-
-  /// Fill chord
-  virtual void fillChord(FXint x,FXint y,FXint w,FXint h,FXint ang1,FXint ang2);
-  virtual void fillChords(const FXArc* chords,FXuint nchords);
-
-  /// Draw arcs
-  virtual void fillArc(FXint x,FXint y,FXint w,FXint h,FXint ang1,FXint ang2);
-  virtual void fillArcs(const FXArc* arcs,FXuint narcs);
-
-  /// Fill ellipse
-  virtual void fillEllipse(FXint x,FXint y,FXint w,FXint h);
-
-  /// Filled polygon
-  virtual void fillPolygon(const FXPoint* points,FXuint npoints);
-  virtual void fillConcavePolygon(const FXPoint* points,FXuint npoints);
-  virtual void fillComplexPolygon(const FXPoint* points,FXuint npoints);
-
-  /// Filled polygon with relative points
-  virtual void fillPolygonRel(const FXPoint* points,FXuint npoints);
-  virtual void fillConcavePolygonRel(const FXPoint* points,FXuint npoints);
-  virtual void fillComplexPolygonRel(const FXPoint* points,FXuint npoints);
-
-  /// Draw hashed box
-  virtual void drawHashBox(FXint x,FXint y,FXint w,FXint h,FXint b=1);
-
-  /// Draw focus rectangle
-  virtual void drawFocusRectangle(FXint x,FXint y,FXint w,FXint h);
-
-  /// Draw area from source
-  virtual void drawArea(const FXDrawable* source,FXint sx,FXint sy,FXint sw,FXint sh,FXint dx,FXint dy);
-
-  /// Draw area stretched area from source
-  virtual void drawArea(const FXDrawable* source,FXint sx,FXint sy,FXint sw,FXint sh,FXint dx,FXint dy,FXint dw,FXint dh);
-
-  /// Draw image
-  virtual void drawImage(const FXImage* image,FXint dx,FXint dy);
-
-  /// Draw bitmap
-  virtual void drawBitmap(const FXBitmap* bitmap,FXint dx,FXint dy);
-
-  /// Draw icon
-  virtual void drawIcon(const FXIcon* icon,FXint dx,FXint dy);
-  virtual void drawIconShaded(const FXIcon* icon,FXint dx,FXint dy);
-  virtual void drawIconSunken(const FXIcon* icon,FXint dx,FXint dy);
-
-  /// Draw string with base line starting at x, y
-  virtual void drawText(FXint x,FXint y,const FXString& string);
-  virtual void drawText(FXint x,FXint y,const FXchar* string,FXuint length);
-
-  /// Draw text starting at x, y over filled background
-  virtual void drawImageText(FXint x,FXint y,const FXString& string);
-  virtual void drawImageText(FXint x,FXint y,const FXchar* string,FXuint length);
-
-  /// Set foreground/background drawing color
-  virtual void setForeground(FXColor clr);
-  virtual void setBackground(FXColor clr);
-
-  /// Set dash pattern
-  virtual void setDashes(FXuint dashoffset,const FXchar *dashpattern,FXuint dashlength);
-
-  /// Set line width
-  virtual void setLineWidth(FXuint linewidth=0);
-
-  /// Set line cap style
-  virtual void setLineCap(FXCapStyle capstyle=CAP_BUTT);
-
-  /// Set line join style
-  virtual void setLineJoin(FXJoinStyle joinstyle=JOIN_MITER);
-
-  /// Set line style
-  virtual void setLineStyle(FXLineStyle linestyle=LINE_SOLID);
-
-  /// Set fill style
-  virtual void setFillStyle(FXFillStyle fillstyle=FILL_SOLID);
-
-  /// Set fill rule
-  virtual void setFillRule(FXFillRule fillrule=RULE_EVEN_ODD);
-
-  /// Set blit function
-  virtual void setFunction(FXFunction func=BLT_SRC);
-
-  /// Set the tile
-  virtual void setTile(FXImage* tile,FXint dx=0,FXint dy=0);
-
-  /// Set the stipple pattern
-  virtual void setStipple(FXBitmap *stipple,FXint dx=0,FXint dy=0);
-
-  /// Set the stipple pattern
-  virtual void setStipple(FXStipplePattern stipple,FXint dx=0,FXint dy=0);
-
-  /// Set clip region
-  virtual void setClipRegion(const FXRegion& region);
-
-  /// Set clip rectangle
-  virtual void setClipRectangle(FXint x,FXint y,FXint w,FXint h);
-
-  /// Set clip rectangle
-  virtual void setClipRectangle(const FXRectangle& rectangle);
-
-  /// Clear clipping
-  virtual void clearClipRectangle();
-
-  /// Set clip mask
-  virtual void setClipMask(FXBitmap* mask,FXint dx=0,FXint dy=0);
-
-  /// Clear clip mask
-  virtual void clearClipMask();
-
-  /// Set font to draw text with
-  virtual void setFont(FXFont *fnt);
-
-  /// Clip against child windows
-  virtual void clipChildren(FXbool yes);
-
-  /// Destructor
-  virtual ~FXDCWindow();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXDLL.h b/fox-includes/FXDLL.h
deleted file mode 100755
index b8d6f9ca..00000000
--- a/fox-includes/FXDLL.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*             D y n a m i c   L i n k   L i b r a r y   S u p p o r t           *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2002,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDLL.h 2127 2005-08-07 20:21:35Z lyle $                              *
-********************************************************************************/
-#ifndef FXDLL_H
-#define FXDLL_H
-
-namespace FX {
-
-/**
-* Open library with given name, returning handle to the
-* library, or NULL if the operation failed.
-*/
-extern FXAPI void* fxdllOpen(const FXchar *dllname);
-
-
-/**
-* Close library represented by dllhandle.
-*/
-extern FXAPI void fxdllClose(void* dllhandle);
-
-
-/**
-* Return address of the symbol in the library represented by
-* dllhandle, or NULL if the operation failed.
-*/
-extern FXAPI void* fxdllSymbol(void* dllhandle,const FXchar* dllsymbol);
-
-
-/**
-* Return the string error message when loading dll's.
-*/
-extern FXAPI FXString fxdllError();
-
-
-}
-
-#endif
-
diff --git a/fox-includes/FXDataTarget.h b/fox-includes/FXDataTarget.h
deleted file mode 100755
index 2ab5b8e3..00000000
--- a/fox-includes/FXDataTarget.h
+++ /dev/null
@@ -1,225 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                              D a t a   T a r g e t                            *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDataTarget.h 2342 2006-02-10 14:24:44Z lyle $                      *
-********************************************************************************/
-#ifndef FXDATATARGET_H
-#define FXDATATARGET_H
-
-#ifndef FXOBJECT_H
-#include "FXObject.h"
-#endif
-
-namespace FX {
-
-
-/**
-* A Data Target allows a valuator widget such as a Slider or Text Field
-* to be directly connected with a variable in the program.
-* Whenever the valuator control changes, the variable connected through
-* the data target is automatically updated; conversely, whenever the program
-* changes a variable, all the connected valuator widgets will be updated
-* to reflect this new value on the display.
-* Data Targets also allow connecting Radio Buttons, Menu Commands, and so on
-* to a variable.  In this case, the new value of the connected variable is computed
-* by subtracting ID_OPTION from the message ID.
-*/
-class FXAPI FXDataTarget : public FXObject {
-  FXDECLARE(FXDataTarget)
-protected:
-  FXObject     *target;                 // Target object
-  void         *data;                   // Associated data
-  FXSelector    message;                // Message ID
-  FXuint        type;                   // Type of data
-private:
-  FXDataTarget(const FXDataTarget&);
-  FXDataTarget& operator=(const FXDataTarget&);
-public:
-  long onCmdValue(FXObject*,FXSelector,void*);
-  long onUpdValue(FXObject*,FXSelector,void*);
-  long onCmdOption(FXObject*,FXSelector,void*);
-  long onUpdOption(FXObject*,FXSelector,void*);
-public:
-  enum {
-    DT_VOID=0,
-    DT_CHAR,
-    DT_UCHAR,
-    DT_SHORT,
-    DT_USHORT,
-    DT_INT,
-    DT_UINT,
-    DT_LONG,
-    DT_ULONG,
-    DT_FLOAT,
-    DT_DOUBLE,
-    DT_STRING,
-    DT_LAST
-    };
-public:
-  enum {
-    ID_VALUE=1,                   /// Will cause the FXDataTarget to ask sender for value
-    ID_OPTION=ID_VALUE+10001,     /// ID_OPTION+i will set the value to i where -10000<=i<=10000
-    ID_LAST=ID_OPTION+10000
-    };
-public:
-
-  /// Associate with nothing
-  FXDataTarget():target(NULL),data(NULL),message(0),type(DT_VOID){}
-
-  /// Associate with nothing
-  FXDataTarget(FXObject* tgt,FXSelector sel):target(tgt),data(NULL),message(sel),type(DT_VOID){}
-
-  /// Associate with character variable
-  FXDataTarget(FXchar& value,FXObject* tgt=NULL,FXSelector sel=0):target(tgt),data(&value),message(sel),type(DT_CHAR){}
-
-  /// Associate with unsigned character variable
-  FXDataTarget(FXuchar& value,FXObject* tgt=NULL,FXSelector sel=0):target(tgt),data(&value),message(sel),type(DT_UCHAR){}
-
-  /// Associate with signed short variable
-  FXDataTarget(FXshort& value,FXObject* tgt=NULL,FXSelector sel=0):target(tgt),data(&value),message(sel),type(DT_SHORT){}
-
-  /// Associate with unsigned short variable
-  FXDataTarget(FXushort& value,FXObject* tgt=NULL,FXSelector sel=0):target(tgt),data(&value),message(sel),type(DT_USHORT){}
-
-  /// Associate with int variable
-  FXDataTarget(FXint& value,FXObject* tgt=NULL,FXSelector sel=0):target(tgt),data(&value),message(sel),type(DT_INT){}
-
-  /// Associate with unsigned int variable
-  FXDataTarget(FXuint& value,FXObject* tgt=NULL,FXSelector sel=0):target(tgt),data(&value),message(sel),type(DT_UINT){}
-
-  /// Associate with long variable
-  FXDataTarget(FXlong& value,FXObject* tgt=NULL,FXSelector sel=0):target(tgt),data(&value),message(sel),type(DT_LONG){}
-
-  /// Associate with unsigned long variable
-  FXDataTarget(FXulong& value,FXObject* tgt=NULL,FXSelector sel=0):target(tgt),data(&value),message(sel),type(DT_ULONG){}
-
-  /// Associate with float variable
-  FXDataTarget(FXfloat& value,FXObject* tgt=NULL,FXSelector sel=0):target(tgt),data(&value),message(sel),type(DT_FLOAT){}
-
-  /// Associate with double variable
-  FXDataTarget(FXdouble& value,FXObject* tgt=NULL,FXSelector sel=0):target(tgt),data(&value),message(sel),type(DT_DOUBLE){}
-
-  /// Associate with string variable
-  FXDataTarget(FXString& value,FXObject* tgt=NULL,FXSelector sel=0):target(tgt),data(&value),message(sel),type(DT_STRING){}
-
-
-  /// Set the message target object for this data target
-  void setTarget(FXObject *t){ target=t; }
-
-  /// Get the message target object for this data target, if any
-  FXObject* getTarget() const { return target; }
-
-
-  /// Set the message identifier for this data target
-  void setSelector(FXSelector sel){ message=sel; }
-
-  /// Get the message identifier for this data target
-  FXSelector getSelector() const { return message; }
-
-
-  /// Return type of data its connected to
-  FXuint getType() const { return type; }
-
-  /// Return pointer to data its connected to
-  void* getData() const { return data; }
-
-
-  /// Associate with nothing
-  void connect(){ data=NULL; type=DT_VOID; }
-
-  /// Associate with character variable
-  void connect(FXchar& value){ data=&value; type=DT_CHAR; }
-
-  /// Associate with unsigned character variable
-  void connect(FXuchar& value){ data=&value; type=DT_UCHAR; }
-
-  /// Associate with signed short variable
-  void connect(FXshort& value){ data=&value; type=DT_SHORT; }
-
-  /// Associate with unsigned short variable
-  void connect(FXushort& value){ data=&value; type=DT_USHORT; }
-
-  /// Associate with int variable
-  void connect(FXint& value){ data=&value; type=DT_INT; }
-
-  /// Associate with unsigned int variable
-  void connect(FXuint& value){ data=&value; type=DT_UINT; }
-
-  /// Associate with long variable
-  void connect(FXlong& value){ data=&value; type=DT_LONG; }
-
-  /// Associate with unsigned long variable
-  void connect(FXulong& value){ data=&value; type=DT_ULONG; }
-
-  /// Associate with float variable
-  void connect(FXfloat& value){ data=&value; type=DT_FLOAT; }
-
-  /// Associate with double variable
-  void connect(FXdouble& value){ data=&value; type=DT_DOUBLE; }
-
-  /// Associate with string variable
-  void connect(FXString& value){ data=&value; type=DT_STRING; }
-
-
-  /// Associate with nothing; also set target and message
-  void connect(FXObject* tgt,FXSelector sel){ target=tgt; data=NULL; message=sel; type=DT_VOID; }
-
-  /// Associate with character variable; also set target and message
-  void connect(FXchar& value,FXObject* tgt,FXSelector sel){ target=tgt; data=&value; message=sel; type=DT_CHAR; }
-
-  /// Associate with unsigned character variable; also set target and message
-  void connect(FXuchar& value,FXObject* tgt,FXSelector sel){ target=tgt; data=&value; message=sel; type=DT_UCHAR; }
-
-  /// Associate with signed short variable; also set target and message
-  void connect(FXshort& value,FXObject* tgt,FXSelector sel){ target=tgt; data=&value; message=sel; type=DT_SHORT; }
-
-  /// Associate with unsigned short variable; also set target and message
-  void connect(FXushort& value,FXObject* tgt,FXSelector sel){ target=tgt; data=&value; message=sel; type=DT_USHORT; }
-
-  /// Associate with int variable; also set target and message
-  void connect(FXint& value,FXObject* tgt,FXSelector sel){ target=tgt; data=&value; message=sel; type=DT_INT; }
-
-  /// Associate with unsigned int variable; also set target and message
-  void connect(FXuint& value,FXObject* tgt,FXSelector sel){ target=tgt; data=&value; message=sel; type=DT_UINT; }
-
-  /// Associate with long variable; also set target and message
-  void connect(FXlong& value,FXObject* tgt,FXSelector sel){ target=tgt; data=&value; message=sel; type=DT_LONG; }
-
-  /// Associate with unsigned long variable; also set target and message
-  void connect(FXulong& value,FXObject* tgt,FXSelector sel){ target=tgt; data=&value; message=sel; type=DT_ULONG; }
-
-  /// Associate with float variable; also set target and message
-  void connect(FXfloat& value,FXObject* tgt,FXSelector sel){ target=tgt; data=&value; message=sel; type=DT_FLOAT; }
-
-  /// Associate with double variable; also set target and message
-  void connect(FXdouble& value,FXObject* tgt,FXSelector sel){ target=tgt; data=&value; message=sel; type=DT_DOUBLE; }
-
-  /// Associate with string variable; also set target and message
-  void connect(FXString& value,FXObject* tgt,FXSelector sel){ target=tgt; data=&value; message=sel; type=DT_STRING; }
-
-
-  /// Destroy
-  virtual ~FXDataTarget();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXDate.h b/fox-includes/FXDate.h
deleted file mode 100644
index 66779cbd..00000000
--- a/fox-includes/FXDate.h
+++ /dev/null
@@ -1,170 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                            D a t e   C l a s s                                *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2005 by Jeroen van der Zijp.   All Rights Reserved.             *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDate.h 2335 2006-01-28 02:33:03Z lyle $                             *
-********************************************************************************/
-#ifndef FXDATE_H
-#define FXDATE_H
-
-namespace FX {
-
-
-
-/**
-* Gregorian date object.
-*/
-class FXAPI FXDate {
-private:
-  FXuint julian;
-private:
-  static const FXchar shortMonthName[12][4];
-  static const FXchar longMonthName[12][10];
-  static const FXchar shortWeekDay[7][4];
-  static const FXchar longWeekDay[7][10];
-protected:
-  static void greg2jul(FXuint& jd,FXint y,FXint m,FXint d);
-  static void jul2greg(FXuint jd,FXint& y,FXint& m,FXint& d);
-public:
-
-  /// Names for the months
-  enum {
-    Jan=1,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec
-    };
-
-  /// Names for the weekdays
-  enum {
-    Sun=0,Mon,Tue,Wed,Thu,Fri,Sat
-    };
-
-public:
-
-  /// Default constructor
-  FXDate(){}
-
-  /// Copy constructor
-  FXDate(const FXDate& date):julian(date.julian){}
-
-  /// Initialize with year, month, and day
-  FXDate(FXint y,FXint m,FXint d);
-
-  /// Initialize with julian day number
-  FXDate(FXuint j):julian(j){}
-
-  /// Set julian day number
-  void setJulian(FXuint day){ julian=day; }
-
-  /// Get julian day number
-  FXuint getJulian() const { return julian; }
-
-  /// Set to year, month, and day
-  void setDate(FXint y,FXint m,FXint d);
-
-  /// Get year, month, and day
-  void getDate(FXint& y,FXint& m,FXint& d) const;
-
-  /// Return day of the month
-  FXint day() const;
-
-  /// Return month
-  FXint month() const;
-
-  /// Return year
-  FXint year() const;
-
-  /// Return day of the week
-  FXint dayOfWeek() const;
-
-  /// Return day of year
-  FXint dayOfYear() const;
-
-  /// Return days in this month
-  FXint daysInMonth() const;
-
-  /// Return true if leap year
-  bool leapYear() const;
-
-  /// Is the value a leap year
-  static bool leapYear(FXint y);
-
-  /// Get the name of the month
-  static const FXchar *monthName(FXint month){ return longMonthName[month-1]; }
-
-  /// Get the abbreviated name of the month
-  static const FXchar *monthNameShort(FXint month){ return shortMonthName[month-1]; }
-
-  /// Get the name of the day
-  static const FXchar *dayName(FXint day){ return longWeekDay[day]; }
-
-  /// Get the abbreviated name of the day
-  static const FXchar *dayNameShort(FXint day){ return shortWeekDay[day]; }
-
-  /// Return current local date
-  static FXDate localDate();
-
-  /// Return current UTC (Zulu) date
-  static FXDate zuluDate();
-
-  /// Assignment
-  FXDate& operator=(const FXDate& date){julian=date.julian;return *this;}
-
-  /// Assignment operators
-  FXDate& operator+=(FXint x){ julian+=x; return *this; }
-  FXDate& operator-=(FXint x){ julian-=x; return *this; }
-
-  /// Increment and decrement
-  FXDate& operator++(){ julian++; return *this; }
-  FXDate& operator--(){ julian--; return *this; }
-
-  /// Equality tests
-  bool operator==(const FXDate& date) const { return julian==date.julian;}
-  bool operator!=(const FXDate& date) const { return julian!=date.julian;}
-
-  /// Inequality tests
-  bool operator<(const FXDate& date) const { return julian<date.julian;}
-  bool operator<=(const FXDate& date) const { return julian<=date.julian;}
-  bool operator>(const FXDate& date) const { return julian>date.julian;}
-  bool operator>=(const FXDate& date) const { return julian>=date.julian;}
-
-  /// Add days to date yielding another date
-  friend inline FXDate operator+(const FXDate& d,FXint x);
-  friend inline FXDate operator+(FXint x,const FXDate& d);
-
-  /// Substract dates yielding days
-  friend inline FXint operator-(const FXDate& a,const FXDate& b);
-
-  /// save to stream
-  friend FXAPI FXStream& operator<<(FXStream& store,const FXDate& d);
-
-  /// load from stream
-  friend FXAPI FXStream& operator>>(FXStream& store,FXDate& d);
-  };
-
-
-inline FXDate operator+(const FXDate& d,FXint x){ return FXDate(d.julian+x); }
-inline FXDate operator+(FXint x,const FXDate& d){ return FXDate(x+d.julian); }
-inline FXint operator-(const FXDate& a,const FXDate& b){return a.julian-b.julian; }
-
-extern FXAPI FXStream& operator<<(FXStream& store,const FXDate& d);
-extern FXAPI FXStream& operator>>(FXStream& store,FXDate& d);
-
-}
-
-#endif
diff --git a/fox-includes/FXDebugTarget.h b/fox-includes/FXDebugTarget.h
deleted file mode 100755
index ed6e0e04..00000000
--- a/fox-includes/FXDebugTarget.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                              D e b u g   T a r g e t                          *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2002 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDebugTarget.h 809 2002-07-11 17:28:15Z lyle $                     *
-********************************************************************************/
-#ifndef FXDEBUGTARGET_H
-#define FXDEBUGTARGET_H
-
-#ifndef FXOBJECT_H
-#include "FXObject.h"
-#endif
-
-namespace FX {
-
-
-/**
-* A DebugTarget prints out every message it receives.
-* To use it, simply make the DebugTarget a target of the widget
-* whose messages you want to see,
-*/
-class FXAPI FXDebugTarget : public FXObject {
-  FXDECLARE(FXDebugTarget)
-protected:
-  FXObject   *lastsender;
-  FXSelector  lastsel;
-  FXuint      count;
-public:
-  static const FXchar *const messageTypeName[];
-private:
-  FXDebugTarget(const FXDebugTarget&);
-  FXDebugTarget &operator=(const FXDebugTarget&);
-public:
-  long onMessage(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct a debug target
-  FXDebugTarget();
-
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXDelegator.h b/fox-includes/FXDelegator.h
deleted file mode 100755
index 04a76ac7..00000000
--- a/fox-includes/FXDelegator.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       D e l e g a t o r   T a r g e t                         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2000,2004 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDelegator.h 1889 2004-05-26 03:13:01Z lyle $                       *
-********************************************************************************/
-#ifndef FXDELEGATOR_H
-#define FXDELEGATOR_H
-
-#ifndef FXOBJECT_H
-#include "FXObject.h"
-#endif
-
-namespace FX {
-
-
-/**
-* A delegator forwards messages to a delegate object.
-* Delegators are used when you need to multiplex messages
-* toward any number of target objects.
-* For example, many controls may be connected to FXDelegator,
-* instead of directly to the document object.  Changing the
-* delegate in FXDelegator will then reconnect the controls with their
-* new target.
-*/
-class FXAPI FXDelegator : public FXObject {
-  FXDECLARE(FXDelegator)
-protected:
-  FXObject   *delegate;
-private:
-  FXDelegator(const FXDelegator&);
-  FXDelegator &operator=(const FXDelegator&);
-public:
-  virtual long onDefault(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct a delegator
-  FXDelegator(FXObject* target=NULL):delegate(target){ }
-
-  /// Return delegate object
-  FXObject* getDelegate() const { return delegate; }
-
-  /// Change delegate object
-  void setDelegate(FXObject* target){ delegate=target; }
-
-  /// Always trash during detroy
-  virtual ~FXDelegator(){ delegate=(FXObject*)-1L; }
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXDial.h b/fox-includes/FXDial.h
deleted file mode 100755
index 509dd16c..00000000
--- a/fox-includes/FXDial.h
+++ /dev/null
@@ -1,188 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                              D i a l   W i d g e t                            *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDial.h 2335 2006-01-28 02:33:03Z lyle $                            *
-********************************************************************************/
-#ifndef FXDIAL_H
-#define FXDIAL_H
-
-#ifndef FXFRAME_H
-#include "FXFrame.h"
-#endif
-
-namespace FX {
-
-
-// Dial style options
-enum {
-  DIAL_VERTICAL   = 0,                            // Vertically oriented
-  DIAL_HORIZONTAL = 0x00008000,                   // Horizontal oriented
-  DIAL_CYCLIC     = 0x00010000,                   // Value wraps around
-  DIAL_HAS_NOTCH  = 0x00020000,                   // Dial has a Center Notch
-  DIAL_NORMAL     = DIAL_VERTICAL
-  };
-
-
-/**
-* The Dial widget is a valuator widget which is able to provide a cyclic
-* value range when the DIAL_CYCLIC is passed, or a simple linear value range.
-* While being turned, the dial sends a SEL_CHANGED message to its target;
-* at the end of the interaction, a SEL_COMMAND message is sent.
-* The message data represents the current value, of type FXint.  The options
-* DIAL_VERTICAL and DIAL_HORIZONTAL control the orientation of the dial.
-* An optional notch can be used to indicate the zero-position of
-* the dial; display of the notch is controlled by the DIAL_HAS_NOTCH option.
-*/
-class FXAPI FXDial : public FXFrame {
-  FXDECLARE(FXDial)
-protected:
-  FXint         range[2];       // Reported data range
-  FXColor       notchColor;     // Main notch color
-  FXint         notchangle;     // Angle of main notch
-  FXint         notchspacing;   // Angle between notches
-  FXint         notchoffset;    // Notch offset
-  FXint         dragpoint;      // Place where clicked
-  FXint         dragpos;        // Value where clicked
-  FXint         incr;           // Rate of change/revolution
-  FXint         pos;            // Reported data position
-  FXString      help;           // Help string
-  FXString      tip;            // Tip string
-protected:
-  FXDial();
-private:
-  FXDial(const FXDial&);
-  FXDial &operator=(const FXDial&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onMouseWheel(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void* );
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-  long onCmdSetRealValue(FXObject*,FXSelector,void*);
-  long onCmdGetRealValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntRange(FXObject*,FXSelector,void*);
-  long onCmdGetIntRange(FXObject*,FXSelector,void*);
-  long onCmdSetRealRange(FXObject*,FXSelector,void*);
-  long onCmdGetRealRange(FXObject*,FXSelector,void*);
-  long onCmdSetHelp(FXObject*,FXSelector,void*);
-  long onCmdGetHelp(FXObject*,FXSelector,void*);
-  long onCmdSetTip(FXObject*,FXSelector,void*);
-  long onCmdGetTip(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct a dial widget
-  FXDial(FXComposite *p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=DIAL_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Returns true because a dial can receive focus
-  virtual bool canFocus() const;
-
-  /// Set the dial value
-  void setValue(FXint value,FXbool notify=FALSE);
-
-  /// Return the dial value
-  FXint getValue() const { return pos; }
-
-  /// Change the dial's range
-  void setRange(FXint lo,FXint hi,FXbool notify=FALSE);
-
-  /// Obtain the current range of the dial
-  void getRange(FXint& lo,FXint& hi) const { lo=range[0]; hi=range[1]; }
-
-  /**
-  * Set the revolution increment, which is the amount of change
-  * in the position for revolution of the dial; the dial may go
-  * through multiple revolutions to go through its whole range;
-  * by default it takes one 360 degree turn of the dial to go
-  * from the lower to the upper range.
-  */
-  void setRevolutionIncrement(FXint i);
-
-  /// Get the current value of the revolution increment
-  FXint getRevolutionIncrement() const { return incr; }
-
-  /**
-  * Change the spacing for the small notches; this should be set
-  * in tenths of degrees in the range [1,3600], and the value should
-  * be a divisor of 3600, so as to make the notches come out evenly
-  */
-  void setNotchSpacing(FXint spacing);
-
-  /// Get the current notch spacing
-  FXint getNotchSpacing() const { return notchspacing; }
-
-  /**
-  * Change the notch offset, which is the position of the
-  * center notch; the value should be tenths of degrees
-  * in the range [-3600,3600]
-  */
-  void setNotchOffset(FXint offset);
-
-  /// Get the current center notch offset
-  FXint getNotchOffset() const { return notchoffset; }
-
-  /// Changes the dial style.
-  void setDialStyle(FXuint opts);
-
-  /// Get the current dial style.
-  FXuint getDialStyle() const;
-
-  /// Change the center notch color
-  void setNotchColor(FXColor clr);
-
-  /// Get the current center notch color
-  FXColor getNotchColor() const { return notchColor; }
-
-  /// Set the help text to be displayed on the status line
-  void setHelpText(const FXString& text);
-
-  /// Get the current help text
-  const FXString& getHelpText() const { return help; }
-
-  /// Set the tip text to be displayed in the tooltip
-  void setTipText(const FXString& text);
-
-  /// Get the current tooltip text value
-  const FXString& getTipText() const { return tip; }
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXDialogBox.h b/fox-includes/FXDialogBox.h
deleted file mode 100755
index c8ef09e1..00000000
--- a/fox-includes/FXDialogBox.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                              D i a l o g   B o x                              *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2002 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDialogBox.h 812 2002-07-11 18:00:42Z lyle $                       *
-********************************************************************************/
-#ifndef FXDIALOGBOX_H
-#define FXDIALOGBOX_H
-
-#ifndef FXTOPWINDOW_H
-#include "FXTopWindow.h"
-#endif
-
-namespace FX {
-
-
-/**
-* DialogBox window.
-* When receiving ID_CANCEL or ID_ACCEPT, the DialogBox breaks out of the
-* modal loop and returns FALSE or TRUE, respectively.
-* To close the DialogBox when not running modally, simply send it ID_HIDE.
-*/
-class FXAPI FXDialogBox : public FXTopWindow {
-  FXDECLARE(FXDialogBox)
-protected:
-  FXDialogBox(){}
-private:
-  FXDialogBox(const FXDialogBox&);
-  FXDialogBox &operator=(const FXDialogBox&);
-public:
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onCmdAccept(FXObject*,FXSelector,void*);
-  long onCmdCancel(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_CANCEL=FXTopWindow::ID_LAST,     /// Closes the dialog, cancel the entry
-    ID_ACCEPT,                          /// Closes the dialog, accept the entry
-    ID_LAST
-    };
-public:
-
-  /// Construct free-floating dialog
-  FXDialogBox(FXApp* a,const FXString& name,FXuint opts=DECOR_TITLE|DECOR_BORDER,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=10,FXint pr=10,FXint pt=10,FXint pb=10,FXint hs=4,FXint vs=4);
-
-  /// Construct dialog which will always float over the owner window
-  FXDialogBox(FXWindow* owner,const FXString& name,FXuint opts=DECOR_TITLE|DECOR_BORDER,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=10,FXint pr=10,FXint pt=10,FXint pb=10,FXint hs=4,FXint vs=4);
-
-  /// Run modal invocation of the dialog
-  virtual FXuint execute(FXuint placement=PLACEMENT_CURSOR);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXDict.h b/fox-includes/FXDict.h
deleted file mode 100755
index 377e0a38..00000000
--- a/fox-includes/FXDict.h
+++ /dev/null
@@ -1,176 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                  S t r i n g   D i c t i o n a r y    C l a s s               *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDict.h 2335 2006-01-28 02:33:03Z lyle $                            *
-********************************************************************************/
-#ifndef FXDICT_H
-#define FXDICT_H
-
-#ifndef FXOBJECT_H
-#include "FXObject.h"
-#endif
-
-namespace FX {
-
-
-/**
-* The dictionary class maintains a fast-access hash table of entities
-* indexed by a character string.
-* It is typically used to map strings to pointers; however, overloading
-* the createData() and deleteData() members allows any type of data to
-* be indexed by strings.
-*/
-class FXAPI FXDict : public FXObject {
-  FXDECLARE(FXDict)
-protected:
-  struct FXDictEntry {
-    FXchar *key;              // Key string
-    void   *data;             // Data
-    FXint   hash;             // Hash value of key
-    bool    mark;             // Entry is marked
-    };
-protected:
-  FXDictEntry *dict;          // Dictionary
-  FXint        total;         // Dictionary size
-  FXint        number;        // Number of entries
-protected:
-  static FXint hash(const FXchar* str);
-protected:
-
-  /**
-  * Overload this function in a derived class to return the
-  * data pointer given an input pointer; the default implementation
-  * just returns the input pointer.
-  */
-  virtual void *createData(const void*);
-
-  /**
-  * Overload this function in a derived class to delete the pointer
-  * previously returned by createData(); the default implementation
-  * does nothing.
-  */
-  virtual void deleteData(void*);
-public:
-
-  /**
-  * Construct an empty dictionary.
-  */
-  FXDict();
-
-  /// Copy constructor; does bit-copy of void pointer data.
-  FXDict(const FXDict& orig);
-
-  /// Assignment operator
-  FXDict& operator=(const FXDict& orig);
-
-  /**
-  * Resize the table to the given size.
-  */
-  void size(FXint m);
-
-  /**
-  * Return the size of the table, including the empty slots.
-  */
-  FXint size() const { return total; }
-
-  /**
-  * Return the total number of entries in the table.
-  */
-  FXint no() const { return number; }
-
-  /**
-  * Insert a new entry into the table given key and mark.
-  * If there is already an entry with that key, leave it unchanged,
-  * otherwise insert the new entry.
-  */
-  void* insert(const FXchar* ky,const void* ptr,bool mrk=false);
-
-  /**
-  * Replace data at key, if the entry's mark is less than
-  * or equal to the given mark.  If there was no existing entry,
-  * a new entry is inserted with the given mark.
-  */
-  void* replace(const FXchar* ky,const void* ptr,bool mrk=false);
-
-  /**
-  * Remove data given key.
-  */
-  void* remove(const FXchar* ky);
-
-  /**
-  * Find data pointer given key.
-  */
-  void* find(const FXchar* ky) const;
-
-  /**
-  * Return true if slot is empty.
-  */
-  bool empty(FXint pos) const { return dict[pos].hash<0; }
-
-  /**
-  * Return key at position pos.
-  */
-  const FXchar* key(FXuint pos) const { return dict[pos].key; }
-
-  /**
-  * return data pointer at position pos.
-  */
-  void* data(FXuint pos) const { return dict[pos].data; }
-
-  /**
-  * Return mark flag of entry at position pos.
-  */
-  bool mark(FXuint pos) const { return dict[pos].mark; }
-
-  /**
-  * Return position of first filled slot, or >= total
-  */
-  FXint first() const;
-
-  /**
-  * Return position of last filled slot or -1
-  */
-  FXint last() const;
-
-
-  /**
-  * Return position of next filled slot in hash table
-  * or a value greater than or equal to total if no filled
-  * slot was found
-  */
-  FXint next(FXint pos) const;
-
-  /**
-  * Return position of previous filled slot in hash table
-  * or a -1 if no filled slot was found
-  */
-  FXint prev(FXint pos) const;
-
-  /// Clear all entries
-  void clear();
-
-  /// Destructor
-  virtual ~FXDict();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXDir.h b/fox-includes/FXDir.h
deleted file mode 100644
index af43eaf2..00000000
--- a/fox-includes/FXDir.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                    D i r e c t o r y   E n u m e r a t o r                    *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2005 by Jeroen van der Zijp.   All Rights Reserved.             *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDir.h 2335 2006-01-28 02:33:03Z lyle $                             *
-********************************************************************************/
-#ifndef FXDIR_H
-#define FXDIR_H
-
-namespace FX {
-
-
-/// Directory enumerator
-class FXAPI FXDir {
-private:
-  FXuval space[256];
-private:
-  FXDir(const FXDir&);
-  FXDir &operator=(const FXDir&);
-public:
-
-  /// Options for listing files
-  enum {
-    MatchAll    = 0,              /// Matching files and directories
-    NoFiles     = 1,              /// Don't list any files
-    NoDirs      = 2,              /// Don't list any directories
-    AllFiles    = 4,              /// List all files
-    AllDirs     = 8,              /// List all directories
-    HiddenFiles = 16,             /// List hidden files also
-    HiddenDirs  = 32,             /// List hidden directories also
-    NoParent    = 64,             /// Don't include '..' in the listing
-    CaseFold    = 128             /// Matching is case-insensitive
-    };
-
-public:
-
-  /// Construct directory enumerator
-  FXDir();
-
-  /// Construct directory enumerator open on path
-  FXDir(const FXString& path);
-
-  /// Open directory to path, return true if ok.
-  virtual bool open(const FXString& path);
-
-  /// Returns true if the directory is open
-  virtual bool isOpen() const;
-
-  /// Go to next one
-  virtual bool next();
-
-  /// Return current file name
-  virtual FXString name() const;
-
-  /// Close directory
-  virtual void close();
-
-  /// Create directory
-  static bool create(const FXString& path,FXuint mode=FXIO::OwnerFull|FXIO::GroupFull|FXIO::OtherFull);
-
-  /// Remove directory
-  static bool remove(const FXString& path);
-
-  /// Rename or move srcpath to dstpath
-  static bool rename(const FXString& srcpath,const FXString& dstpath);
-
-  /**
-  * List files in a given directory.
-  * Returns the number of files in the string-array list which matched the
-  * pattern or satisfied the flag conditions.
-  */
-  static FXint listFiles(FXString*& filelist,const FXString& path,const FXString& pattern="*",FXuint flags=FXDir::MatchAll);
-
-  /**
-  * List drives, i.e. roots of directory trees.
-  * Return the number of drives in the string array.
-  */
-  static FXint listDrives(FXString*& drivelist);
-
-
-  /// Destructor
-  virtual ~FXDir();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXDirBox.h b/fox-includes/FXDirBox.h
deleted file mode 100755
index dee8df78..00000000
--- a/fox-includes/FXDirBox.h
+++ /dev/null
@@ -1,114 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                    D i r e c t o r y   B o x   W i d g e t                    *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1999,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDirBox.h 2127 2005-08-07 20:21:35Z lyle $                          *
-********************************************************************************/
-#ifndef FXDIRBOX_H
-#define FXDIRBOX_H
-
-#ifndef FXTREELISTBOX_H
-#include "FXTreeListBox.h"
-#endif
-
-namespace FX {
-
-
-class FXIcon;
-class FXFileDict;
-
-/// Directory Box options
-enum {
-  DIRBOX_NO_OWN_ASSOC = 0x00020000      /// Do not create associations for files
-  };
-
-
-/**
-* A Directory Box widget allows the user to select parts of a file path.
-* First, it is filled with a string comprising a file path, like "/a/b/c".
-* Then, the user can select "/a/b/c", "/a/b", "/a", and "/" from the drop-down
-* list.  The entries in the drop-down list are automatically provided with icons
-* by consulting the file-associations registry settings.
-* The Directory Box sends SEL_CHANGED and SEL_COMMAND messages, with the string
-* containing the full path to the selected item.
-*/
-class FXAPI FXDirBox : public FXTreeListBox {
-  FXDECLARE(FXDirBox)
-protected:
-  FXFileDict *associations;     // Association table
-  FXIcon     *foldericon;       // Folder icons
-  FXIcon     *cdromicon;        // CDROM icon
-  FXIcon     *harddiskicon;     // Hard disk icon
-  FXIcon     *netdriveicon;     // Networked drive icon
-  FXIcon     *floppyicon;       // Floppy icon
-  FXIcon     *nethoodicon;      // Network neighborhood icon
-  FXIcon     *zipdiskicon;      // Zip drive icon
-protected:
-  FXDirBox(){}
-  FXString getItemPathname(FXTreeItem *item) const;
-  FXTreeItem* getPathnameItem(const FXString& path);
-private:
-  FXDirBox(const FXDirBox&);
-  FXDirBox &operator=(const FXDirBox&);
-public:
-  long onTreeChanged(FXObject*,FXSelector,void*);
-  long onTreeClicked(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetStringValue(FXObject*,FXSelector,void*);
-  long onCmdGetStringValue(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct a Directory Box
-  FXDirBox(FXComposite *p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=FRAME_SUNKEN|FRAME_THICK|TREELISTBOX_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Destroy server-side resources
-  virtual void destroy();
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Set current directory
-  void setDirectory(const FXString& pathname);
-
-  /// Return current directory
-  FXString getDirectory() const;
-
-  /// Change file associations used to look up icons
-  void setAssociations(FXFileDict* assoc);
-
-  /// Return file associations
-  FXFileDict* getAssociations() const { return associations; }
-
-  /// Destructor
-  virtual ~FXDirBox();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXDirDialog.h b/fox-includes/FXDirDialog.h
deleted file mode 100755
index 487887c6..00000000
--- a/fox-includes/FXDirDialog.h
+++ /dev/null
@@ -1,109 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                D i r e c t o r y   S e l e c t i o n   D i a l o g            *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2000,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDirDialog.h 2127 2005-08-07 20:21:35Z lyle $                       *
-********************************************************************************/
-#ifndef FXDIRDIALOG_H
-#define FXDIRDIALOG_H
-
-#ifndef FXDIALOGBOX_H
-#include "FXDialogBox.h"
-#endif
-
-namespace FX {
-
-
-class FXDirSelector;
-
-
-/**
-* A Directory Dialog provides a way to select a directory.  In function,
-* the directory selection dialog is very similar to the file dialog, except that
-* the Directory Dialog displays a tree-structured view of the file system, and
-* thereby makes up and down navigation through the file system significantly easier.
-*/
-class FXAPI FXDirDialog : public FXDialogBox {
-  FXDECLARE(FXDirDialog)
-protected:
-  FXDirSelector *dirbox;          // Directory selection widget
-protected:
-  FXDirDialog(){}
-  void initdialog();
-private:
-  FXDirDialog(const FXDirDialog&);
-  FXDirDialog &operator=(const FXDirDialog&);
-public:
-
-  /// Construct Directory Dialog box
-  FXDirDialog(FXWindow* owner,const FXString& name,FXuint opts=0,FXint x=0,FXint y=0,FXint w=400,FXint h=300);
-
-  /// Construct free-floating Directory Dialog box
-  FXDirDialog(FXApp* a,const FXString& name,FXuint opts=0,FXint x=0,FXint y=0,FXint w=400,FXint h=300);
-
-  /// Hide this window
-  virtual void hide();
-
-  /// Change directory
-  void setDirectory(const FXString& path);
-
-  /// Return directory
-  FXString getDirectory() const;
-
-  /// Return TRUE if showing files as well as directories
-  FXbool showFiles() const;
-
-  /// Show or hide normal files
-  void showFiles(FXbool showing);
-
-  /// Return TRUE if showing hidden files
-  FXbool showHiddenFiles() const;
-
-  /// Show or hide hidden files
-  void showHiddenFiles(FXbool showing);
-
-  /// Return wildcard matching mode
-  FXuint getMatchMode() const;
-
-  /// Change wildcard matching mode
-  void setMatchMode(FXuint mode);
-
-  /// Change directory list style
-  void setDirBoxStyle(FXuint style);
-
-  /// Return directory list style
-  FXuint getDirBoxStyle() const;
-
-  /// Open directory name
-  static FXString getOpenDirectory(FXWindow* owner,const FXString& caption,const FXString& path);
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXDirDialog();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXDirList.h b/fox-includes/FXDirList.h
deleted file mode 100755
index 424614e3..00000000
--- a/fox-includes/FXDirList.h
+++ /dev/null
@@ -1,294 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                     D i r e c t o r y   L i s t   W i d g e t                 *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDirList.h 2195 2005-08-25 12:29:55Z lyle $                         *
-********************************************************************************/
-#ifndef FXDIRLIST_H
-#define FXDIRLIST_H
-
-#ifndef FXTREELIST_H
-#include "FXTreeList.h"
-#endif
-
-namespace FX {
-
-
-struct FXFileAssoc;
-class  FXFileDict;
-class  FXIcon;
-class  FXDirList;
-
-
-/// Directory List options
-enum {
-  DIRLIST_SHOWFILES     = 0x08000000, /// Show files as well as directories
-  DIRLIST_SHOWHIDDEN    = 0x10000000, /// Show hidden files or directories
-  DIRLIST_NO_OWN_ASSOC  = 0x20000000  /// Do not create associations for files
-  };
-
-
-/// Directory item
-class FXAPI FXDirItem : public FXTreeItem {
-  FXDECLARE(FXDirItem)
-  friend class FXDirList;
-protected:
-  FXFileAssoc  *assoc;                // File association
-  FXDirItem    *link;                 // Link to next item
-  FXDirItem    *list;                 // List of child items
-  FXlong        size;                 // File size (if a file)
-  FXTime        date;                 // Time of item
-private:
-  FXDirItem(const FXDirItem&);
-  FXDirItem& operator=(const FXDirItem&);
-protected:
-  FXDirItem():assoc(NULL),link(NULL),list(NULL),size(0L),date(0){}
-public:
-  enum {
-    FOLDER      = 512,          /// Directory item
-    EXECUTABLE  = 1024,         /// Executable item
-    SYMLINK     = 2048,         /// Symbolic linked item
-    CHARDEV     = 4096,         /// Character special item
-    BLOCKDEV    = 8192,         /// Block special item
-    FIFO        = 16384,        /// FIFO item
-    SOCK        = 32768         /// Socket item
-    };
-public:
-
-  /// Constructor
-  FXDirItem(const FXString& text,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL):FXTreeItem(text,oi,ci,ptr),assoc(NULL),link(NULL),list(NULL),size(0),date(0){state=HASITEMS;}
-
-  /// Return true if this is a file item
-  FXbool isFile() const { return (state&(FOLDER|BLOCKDEV|CHARDEV|FIFO|SOCK))==0; }
-
-  /// Return true if this is a directory item
-  FXbool isDirectory() const { return (state&FOLDER)!=0; }
-
-  /// Return true if this is an executable item
-  FXbool isExecutable() const { return (state&EXECUTABLE)!=0; }
-
-  /// Return true if this is a symbolic link item
-  FXbool isSymlink() const { return (state&SYMLINK)!=0; }
-
-  /// Return true if this is a character device item
-  FXbool isChardev() const { return (state&CHARDEV)!=0; }
-
-  /// Return true if this is a block device item
-  FXbool isBlockdev() const { return (state&BLOCKDEV)!=0; }
-
-  /// Return true if this is an FIFO item
-  FXbool isFifo() const { return (state&FIFO)!=0; }
-
-  /// Return true if this is a socket
-  FXbool isSocket() const { return (state&SOCK)!=0; }
-
-  /// Return the file-association object for this item
-  FXFileAssoc* getAssoc() const { return assoc; }
-
-  /// Return the file size for this item
-  FXlong getSize() const { return size; }
-
-  /// Return the date for this item
-  FXTime getDate() const { return date; }
-  };
-
-
-/**
-* A Directory List widget provides a tree-structured view of the file system.
-* It automatically updates itself periodically by re-scanning the file system
-* for any changes.  As it scans the displayed directories and files, it automatically
-* determines the icons to be displayed by consulting the file-associations registry
-* settings.  A number of messages can be sent to the Directory List to control the
-* filter pattern, sorting order, case sensitivity, and hidden file display mode.
-* The Directory list widget supports drags and drops of files.
-*/
-class FXAPI FXDirList : public FXTreeList {
-  FXDECLARE(FXDirList)
-protected:
-  FXFileDict   *associations;         // Association table
-  FXDirItem    *list;                 // Root item list
-  FXString      dropdirectory;        // Drop directory
-  FXDragAction  dropaction;           // Drop action
-  FXString      dragfiles;            // Dragged files
-  FXString      pattern;              // Pattern of file names
-  FXuint        matchmode;            // File wildcard match mode
-  FXuint        counter;              // Refresh counter
-  FXIcon       *open_folder;          // Open folder icon
-  FXIcon       *closed_folder;        // Closed folder icon
-  FXIcon       *mini_doc;             // Document icon
-  FXIcon       *mini_app;             // Application icon
-  FXIcon       *cdromicon;
-  FXIcon       *harddiskicon;
-  FXIcon       *networkicon;
-  FXIcon       *floppyicon;
-  FXIcon       *zipdiskicon;
-protected:
-  FXDirList();
-  void listRootItems();
-  void listChildItems(FXDirItem *par);
-  virtual FXTreeItem* createItem(const FXString& text,FXIcon* oi,FXIcon* ci,void* ptr);
-private:
-  FXDirList(const FXDirList&);
-  FXDirList &operator=(const FXDirList&);
-public:
-  long onRefreshTimer(FXObject*,FXSelector,void*);
-  long onBeginDrag(FXObject*,FXSelector,void*);
-  long onEndDrag(FXObject*,FXSelector,void*);
-  long onDragged(FXObject*,FXSelector,void*);
-  long onDNDEnter(FXObject*,FXSelector,void*);
-  long onDNDLeave(FXObject*,FXSelector,void*);
-  long onDNDMotion(FXObject*,FXSelector,void*);
-  long onDNDDrop(FXObject*,FXSelector,void*);
-  long onDNDRequest(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetStringValue(FXObject*,FXSelector,void*);
-  long onCmdGetStringValue(FXObject*,FXSelector,void*);
-  long onCmdToggleHidden(FXObject*,FXSelector,void*);
-  long onUpdToggleHidden(FXObject*,FXSelector,void*);
-  long onCmdShowHidden(FXObject*,FXSelector,void*);
-  long onUpdShowHidden(FXObject*,FXSelector,void*);
-  long onCmdHideHidden(FXObject*,FXSelector,void*);
-  long onUpdHideHidden(FXObject*,FXSelector,void*);
-  long onCmdToggleFiles(FXObject*,FXSelector,void*);
-  long onUpdToggleFiles(FXObject*,FXSelector,void*);
-  long onCmdShowFiles(FXObject*,FXSelector,void*);
-  long onUpdShowFiles(FXObject*,FXSelector,void*);
-  long onCmdHideFiles(FXObject*,FXSelector,void*);
-  long onUpdHideFiles(FXObject*,FXSelector,void*);
-  long onCmdSetPattern(FXObject*,FXSelector,void*);
-  long onUpdSetPattern(FXObject*,FXSelector,void*);
-  long onCmdSortReverse(FXObject*,FXSelector,void*);
-  long onUpdSortReverse(FXObject*,FXSelector,void*);
-  long onCmdSortCase(FXObject*,FXSelector,void*);
-  long onUpdSortCase(FXObject*,FXSelector,void*);
-  long onCmdRefresh(FXObject*,FXSelector,void*);
-public:
-  static FXint ascending(const FXTreeItem* a,const FXTreeItem* b);
-  static FXint descending(const FXTreeItem* a,const FXTreeItem* b);
-  static FXint ascendingCase(const FXTreeItem* a,const FXTreeItem* b);
-  static FXint descendingCase(const FXTreeItem* a,const FXTreeItem* b);
-public:
-  enum {
-    ID_REFRESHTIMER=FXTreeList::ID_LAST,
-    ID_SHOW_FILES,
-    ID_HIDE_FILES,
-    ID_TOGGLE_FILES,
-    ID_SHOW_HIDDEN,
-    ID_HIDE_HIDDEN,
-    ID_TOGGLE_HIDDEN,
-    ID_SET_PATTERN,
-    ID_SORT_REVERSE,
-    ID_SORT_CASE,
-    ID_REFRESH,
-    ID_LAST
-    };
-public:
-
-  /// Construct a directory list
-  FXDirList(FXComposite *p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Destroy server-side resources
-  virtual void destroy();
-
-  /// Scan the directories and update the items if needed, or if force is TRUE
-  void scan(FXbool force=TRUE);
-
-  /// Return TRUE if item is a directory
-  FXbool isItemDirectory(const FXTreeItem* item) const;
-
-  /// Return TRUE if item is a file
-  FXbool isItemFile(const FXTreeItem* item) const;
-
-  /// Return TRUE if item is executable
-  FXbool isItemExecutable(const FXTreeItem* item) const;
-
-  /// Collapse tree
-  virtual FXbool collapseTree(FXTreeItem* tree,FXbool notify=FALSE);
-
-  /// Expand tree
-  virtual FXbool expandTree(FXTreeItem* tree,FXbool notify=FALSE);
-
-  /// Set current file
-  void setCurrentFile(const FXString& file,FXbool notify=FALSE);
-
-  /// Return current file
-  FXString getCurrentFile() const;
-
-  /// Set current directory
-  void setDirectory(const FXString& path,FXbool notify=FALSE);
-
-  /// Return current directory
-  FXString getDirectory() const;
-
-  /// Return absolute pathname of item
-  FXString getItemPathname(const FXTreeItem* item) const;
-
-  /// Return the item from the absolute pathname
-  FXTreeItem* getPathnameItem(const FXString& path);
-
-  /// Change wildcard matching pattern
-  void setPattern(const FXString& ptrn);
-
-  /// Return wildcard pattern
-  FXString getPattern() const { return pattern; }
-
-  /// Return wildcard matching mode
-  FXuint getMatchMode() const { return matchmode; }
-
-  /// Change wildcard matching mode
-  void setMatchMode(FXuint mode);
-
-  /// Return TRUE if showing files as well as directories
-  FXbool showFiles() const;
-
-  /// Show or hide normal files
-  void showFiles(FXbool showing);
-
-  /// Return TRUE if showing hidden files and directories
-  FXbool showHiddenFiles() const;
-
-  /// Show or hide hidden files and directories
-  void showHiddenFiles(FXbool showing);
-
-  /// Change file associations
-  void setAssociations(FXFileDict* assoc);
-
-  /// Return file associations
-  FXFileDict* getAssociations() const { return associations; }
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXDirList();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXDirSelector.h b/fox-includes/FXDirSelector.h
deleted file mode 100755
index 75fb1df1..00000000
--- a/fox-includes/FXDirSelector.h
+++ /dev/null
@@ -1,154 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*              D i r e c t o r y   S e l e c t i o n   W i d g e t              *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2000,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDirSelector.h 2127 2005-08-07 20:21:35Z lyle $                     *
-********************************************************************************/
-#ifndef FXDIRSELECTOR_H
-#define FXDIRSELECTOR_H
-
-#ifndef FXPACKER_H
-#include "FXPacker.h"
-#endif
-
-namespace FX {
-
-
-class FXDirList;
-class FXTextField;
-class FXButton;
-
-
-/**
-* The Directory Selector widget is the reusable mega-widget component which
-* is the core of the Directory Dialog.  The function of the directory selector widget
-* is very similar to the file selector widget, except that the directory selector widget
-* displays a tree-structured view of the file system, and thereby makes up and down
-* navigation through the file system significantly easier.
-*/
-class FXAPI FXDirSelector : public FXPacker {
-  FXDECLARE(FXDirSelector)
-protected:
-  FXDirList     *dirbox;        // Directory list widget
-  FXTextField   *dirname;       // Directory name entry field
-  FXButton      *accept;        // Accept button
-  FXButton      *cancel;        // Cancel button
-  FXIcon        *updiricon;     // Up directory icon
-  FXIcon        *homeicon;      // Go home icon
-  FXIcon        *workicon;      // Go home icon
-  FXIcon        *markicon;      // Book mark icon
-  FXIcon        *clearicon;     // Book clear icon
-  FXIcon        *newicon;       // New directory icon
-  FXIcon        *deleteicon;    // Delete file icon
-  FXIcon        *moveicon;      // Rename file icon
-  FXIcon        *copyicon;      // Copy file icon
-  FXIcon        *linkicon;      // Link file icon
-  FXRecentFiles  mrufiles;      // Recently visited places
-protected:
-  FXDirSelector(){}
-private:
-  FXDirSelector(const FXDirSelector&);
-  FXDirSelector &operator=(const FXDirSelector&);
-public:
-  long onCmdName(FXObject*,FXSelector,void*);
-  long onCmdOpened(FXObject*,FXSelector,void*);
-  long onCmdHome(FXObject*,FXSelector,void*);
-  long onCmdWork(FXObject*,FXSelector,void*);
-  long onCmdDirectoryUp(FXObject*,FXSelector,void*);
-  long onPopupMenu(FXObject*,FXSelector,void*);
-  long onCmdBookmark(FXObject*,FXSelector,void*);
-  long onCmdVisit(FXObject*,FXSelector,void*);
-  long onCmdNew(FXObject*,FXSelector,void*);
-  long onUpdNew(FXObject*,FXSelector,void*);
-  long onCmdMove(FXObject*,FXSelector,void*);
-  long onCmdCopy(FXObject*,FXSelector,void*);
-  long onCmdLink(FXObject*,FXSelector,void*);
-  long onCmdDelete(FXObject*,FXSelector,void*);
-  long onUpdSelected(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_DIRNAME=FXPacker::ID_LAST,
-    ID_DIRLIST,
-    ID_HOME,
-    ID_WORK,
-    ID_DIRECTORY_UP,
-    ID_BOOKMARK,
-    ID_VISIT,
-    ID_NEW,
-    ID_DELETE,
-    ID_MOVE,
-    ID_COPY,
-    ID_LINK,
-    ID_LAST
-    };
-public:
-
-  /// Constructor
-  FXDirSelector(FXComposite *p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Return a pointer to the "Accept" button
-  FXButton *acceptButton() const { return accept; }
-
-  /// Return a pointer to the "Cancel" button
-  FXButton *cancelButton() const { return cancel; }
-
-  /// Change directory
-  void setDirectory(const FXString& path);
-
-  /// Return directory
-  FXString getDirectory() const;
-
-  /// Return TRUE if showing files as well as directories
-  FXbool showFiles() const;
-
-  /// Show or hide normal files
-  void showFiles(FXbool showing);
-
-  /// Return TRUE if showing hidden directories
-  FXbool showHiddenFiles() const;
-
-  /// Show or hide hidden directories
-  void showHiddenFiles(FXbool showing);
-
-  /// Return wildcard matching mode
-  FXuint getMatchMode() const;
-
-  /// Change wildcard matching mode
-  void setMatchMode(FXuint mode);
-
-  /// Change Directory List style
-  void setDirBoxStyle(FXuint style);
-
-  /// Return Directory List style
-  FXuint getDirBoxStyle() const;
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXDirSelector();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXDockBar.h b/fox-includes/FXDockBar.h
deleted file mode 100644
index 18b7a414..00000000
--- a/fox-includes/FXDockBar.h
+++ /dev/null
@@ -1,191 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        D o c k B a r   W i d g e t                            *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2004,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDockBar.h 2225 2005-11-08 13:51:28Z lyle $                         *
-********************************************************************************/
-#ifndef FXDOCKBAR_H
-#define FXDOCKBAR_H
-
-#ifndef FXPACKER_H
-#include "FXPacker.h"
-#endif
-
-namespace FX {
-
-class FXDockSite;
-
-
-/**
-* A dock bar widget can be docked inside a dock site widget, or floated
-* around freely.  Users can move, undock, and dock the dock bar widget
-* by means of a handle such as a tool bar grip.  When docking, the dock
-* bar sends a SEL_DOCKED message to its target; when undocking, it sends
-* a SEL_FLOATED message.  In either case the dock site involved is passed
-* in the void* pointer argument of the message.
-*/
-class FXAPI FXDockBar : public FXPacker {
-  FXDECLARE(FXDockBar)
-protected:
-  FXComposite *drydock;	        // Parent when docked
-  FXComposite *wetdock;	        // Parent when floating
-  FXint        gripx;           // Grip offset x
-  FXint        gripy;           // Grip offset y
-  FXuchar      allowed;         // Where we're allowed to dock
-protected:
-  FXDockBar();
-private:
-  FXDockBar(const FXDockBar&);
-  FXDockBar &operator=(const FXDockBar&);
-public:
-  long onCmdUndock(FXObject*,FXSelector,void*);
-  long onUpdUndock(FXObject*,FXSelector,void*);
-  long onCmdDockTop(FXObject*,FXSelector,void*);
-  long onUpdDockTop(FXObject*,FXSelector,void*);
-  long onCmdDockBottom(FXObject*,FXSelector,void*);
-  long onUpdDockBottom(FXObject*,FXSelector,void*);
-  long onCmdDockLeft(FXObject*,FXSelector,void*);
-  long onUpdDockLeft(FXObject*,FXSelector,void*);
-  long onCmdDockRight(FXObject*,FXSelector,void*);
-  long onUpdDockRight(FXObject*,FXSelector,void*);
-  long onUpdDockFlip(FXObject*,FXSelector,void*);
-  long onBeginDragGrip(FXObject*,FXSelector,void*);
-  long onEndDragGrip(FXObject*,FXSelector,void*);
-  long onDraggedGrip(FXObject*,FXSelector,void*);
-  long onPopupMenu(FXObject*,FXSelector,void*);
-  long onDockTimer(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_DOCK_FLOAT=FXPacker::ID_LAST,    /// Undock the dock bar
-    ID_DOCK_TOP,                        /// Dock on the top
-    ID_DOCK_BOTTOM,                     /// Dock on the bottom
-    ID_DOCK_LEFT,                       /// Dock on the left
-    ID_DOCK_RIGHT,                      /// Dock on the right
-    ID_DOCK_FLIP,                       /// Flip orientation
-    ID_TOOLBARGRIP,                     /// Tool bar grip
-    ID_TIMER,
-    ID_LAST
-    };
-public:
-  enum {
-    ALLOW_NOWHERE=0,                                    /// Don't allow docking anywhere
-    ALLOW_TOP=1,                                        /// Docking at the top only
-    ALLOW_BOTTOM=2,                                     /// Docking at the bottom only
-    ALLOW_LEFT=4,                                       /// Docking at the left only
-    ALLOW_RIGHT=8,                                      /// Docking at the right only
-    ALLOW_HORIZONTAL=ALLOW_TOP|ALLOW_BOTTOM,            /// Docking at the top and bottom
-    ALLOW_VERTICAL=ALLOW_LEFT|ALLOW_RIGHT,              /// Docking at the left and right
-    ALLOW_EVERYWHERE=ALLOW_HORIZONTAL|ALLOW_VERTICAL    /// Docking can be everywhere
-    };
-public:
-
-  /**
-  * Construct a floatable dock bar, with a default parent p and an
-  * alternate parent q.  To allow docking and dragging the default parent
-  * p must be of type FXDockSite, and the alternate parent q must be of
-  * type FXToolBarShell.
-  * Normally, the dock bar is docked under a window p of type FXDockSite.
-  * When floated, the toolbar can be docked under window q, which is
-  * usually an kind of FXToolBarShell window.
-  */
-  FXDockBar(FXComposite* p,FXComposite* q,FXuint opts=LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=3,FXint pr=3,FXint pt=2,FXint pb=2,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING);
-
-  /**
-  * Construct a non-floatable dock bar.
-  * The dock bar can not be undocked.
-  */
-  FXDockBar(FXComposite* p,FXuint opts,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=2,FXint pr=3,FXint pt=3,FXint pb=2,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING);
-
-  /// Return true if docked
-  FXbool isDocked() const;
-
-  /**
-  * Check if the dock bar would dock or undock if at locaton barx, bary.
-  */
-  FXbool insideDock(FXDockSite* docksite,FXint barx,FXint bary);
-
-  /**
-  * Set parent when docked.
-  * If it was docked, reparent under the new docking window.
-  */
-  void setDryDock(FXComposite* dry);
-
-  /**
-  * Set parent when floating.
-  * If it was undocked, then reparent under the new floating window.
-  */
-  void setWetDock(FXComposite* wet);
-
-  /// Return parent when docked
-  FXComposite* getDryDock() const { return drydock; }
-
-  /// Return parent when floating
-  FXComposite* getWetDock() const { return wetdock; }
-
-  /// Search for dock against given side of main window
-  FXDockSite* findDockAtSide(FXuint side=LAYOUT_SIDE_TOP);
-
-  /// Search for dock close to coordinates rootx, rooty
-  FXDockSite* findDockNear(FXint rootx,FXint rooty);
-
-  /**
-  * Dock the bar against the given side, after some other widget.
-  * However, if after is -1, it will be docked as the innermost bar just before
-  * the work-area, while if after is 0, if will be docked as the outermost bar.
-  */
-  virtual void dock(FXDockSite* docksite,FXWindow* before=NULL,FXbool notify=FALSE);
-
-  /**
-  * Dock the bar against the given side, near the given position relative
-  * to the toolbar dock's origin.
-  */
-  virtual void dock(FXDockSite* docksite,FXint localx,FXint localy,FXbool notify);
-
-  /**
-  * Undock or float the bar.
-  * The initial position of the wet dock is a few pixels
-  * below and to the right of the original docked position.
-  */
-  virtual void undock(FXint rootx,FXint rooty,FXbool notify=FALSE);
-
-  /**
-  * Change set of sides (a combination of ALLOW_TOP, ALLOW_LEFT, etc.),
-  * where docking is allowed. The default is to allow docking on all sides.
-  */
-  void allowedSides(FXuchar allow){ allowed=allow; }
-
-  /**
-  * Return set of sides where docking is allowed
-  */
-  FXuchar allowedSides() const { return allowed; }
-
-  /// Save toolbar to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load toolbar from a stream
-  virtual void load(FXStream& store);
-
-  /// Destroy
-  virtual ~FXDockBar();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXDockHandler.h b/fox-includes/FXDockHandler.h
deleted file mode 100644
index 2ddb0538..00000000
--- a/fox-includes/FXDockHandler.h
+++ /dev/null
@@ -1,90 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       D o c k H a n d l e r   W i d g e t                     *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2005 by Jeroen van der Zijp.   All Rights Reserved.             *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDockHandler.h 2335 2006-01-28 02:33:03Z lyle $                     *
-********************************************************************************/
-#ifndef FXDOCKHANDLER_H
-#define FXDOCKHANDLER_H
-
-#ifndef FXFRAME_H
-#include "FXFrame.h"
-#endif
-
-namespace FX {
-
-
-/**
-* The dock handler exists as a common base class for tool bar grip
-* and dock title.
-*/
-class FXAPI FXDockHandler : public FXFrame {
-  FXDECLARE_ABSTRACT(FXDockHandler)
-protected:
-  FXString  tip;        // Tool tip
-  FXString  help;       // Help string
-private:
-  FXID      xxx;
-protected:
-  FXDockHandler();
-private:
-  FXDockHandler(const FXDockHandler&);
-  FXDockHandler& operator=(const FXDockHandler&);
-public:
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onCmdSetTip(FXObject*,FXSelector,void*);
-  long onCmdGetTip(FXObject*,FXSelector,void*);
-  long onCmdSetHelp(FXObject*,FXSelector,void*);
-  long onCmdGetHelp(FXObject*,FXSelector,void*);
-protected:
-  FXDockHandler(FXComposite* p,FXObject* tgt,FXSelector sel,FXuint opts,FXint x,FXint y,FXint w,FXint h,FXint pl,FXint pr,FXint pt,FXint pb);
-public:
-
-  /// The grip can receive the focus
-  virtual bool canFocus() const;
-
-  /// Set the status line help text for grip
-  void setHelpText(const FXString& text){ help=text; }
-
-  /// Get the status line help text for grip
-  const FXString& getHelpText() const { return help; }
-
-  /// Set the tool tip message for the grip
-  void setTipText(const FXString& text){ tip=text; }
-
-  /// Get the tool tip message for the grip
-  const FXString& getTipText() const { return tip; }
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXDockSite.h b/fox-includes/FXDockSite.h
deleted file mode 100644
index b1de8d72..00000000
--- a/fox-includes/FXDockSite.h
+++ /dev/null
@@ -1,157 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                         D o c k S i t e   W i d g e t                         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2004,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDockSite.h 2335 2006-01-28 02:33:03Z lyle $                        *
-********************************************************************************/
-#ifndef FXDOCKSITE_H
-#define FXDOCKSITE_H
-
-#ifndef FXPACKER_H
-#include "FXPacker.h"
-#endif
-
-namespace FX {
-
-
-class FXDockBar;
-
-/// Dock site options
-enum {
-  DOCKSITE_WRAP    = 0,           /// Dockbars are wrapped to another galley when not enough space on current galley
-  DOCKSITE_NO_WRAP = 0x00020000   /// Never wrap dockbars to another galley even if not enough space
-  };
-
-
-/**
-* The dock site widget is a widget where dock bars can be docked.
-* Dock site widgets are typically embedded inside the main window, placed
-* against those sides where docking of toolbars is to be allowed.
-* Dock bars placed inside a dock site are laid out in horizontal or vertical bands
-* called galleys.  A toolbar with the LAYOUT_DOCK_SAME hint is preferentially placed
-* on the same galley as its previous sibling.  A dock bar with the LAYOUT_DOCK_NEXT is
-* always placed on the next galley.
-* Each galley will have at least one dock bar shown in it.  Several dock bars
-* may be placed side-by-side inside one galley, unless there is insufficient
-* room.  If there is insufficient room to place another dock bar, that dock bar
-* will be moved to the next galley, even though its LAYOUT_DOCK_NEXT option
-* is not set.  This implies that when the main window is resized and more room
-* becomes available, it will jump back to its preferred galley.
-* Within a galley, dock bars will be placed from left to right, at the given
-* x and y coordinates, with the constraints that the dock bar will stay within
-* the galley, and do not overlap each other.  It is possible to use LAYOUT_FILL_X
-* and/or LAYOUT_FILL_Y to stretch a toolbar to the available space on its galley.
-* The galleys are oriented horizontally if the dock site is placed inside
-* a top level window using LAYOUT_SIDE_TOP or LAYOUT_SIDE_BOTTOM, and
-* vertically oriented if placed with LAYOUT_SIDE_LEFT or LAYOUT_SIDE_RIGHT.
-*/
-class FXAPI FXDockSite : public FXPacker {
-  FXDECLARE(FXDockSite)
-protected:
-  FXDockSite(){}
-private:
-  FXDockSite(const FXDockSite&);
-  FXDockSite &operator=(const FXDockSite&);
-protected:
-  void moveVerBar(FXWindow* bar,FXWindow *begin,FXWindow* end,FXint bx,FXint by);
-  void moveHorBar(FXWindow* bar,FXWindow *begin,FXWindow* end,FXint bx,FXint by);
-  FXint galleyWidth(FXWindow *begin,FXWindow*& end,FXint space,FXint& require,FXint& expand) const;
-  FXint galleyHeight(FXWindow *begin,FXWindow*& end,FXint space,FXint& require,FXint& expand) const;
-public:
-
-  /**
-  * Construct a toolbar dock layout manager.  Passing LAYOUT_SIDE_TOP or LAYOUT_SIDE_BOTTOM
-  * causes the toolbar dock to be oriented horizontally.  Passing LAYOUT_SIDE_LEFT or
-  * LAYOUT_SIDE_RIGHT causes it to be oriented vertically.
-  */
-  FXDockSite(FXComposite *p,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=0,FXint pr=0,FXint pt=0,FXint pb=0,FXint hs=0,FXint vs=0);
-
-  /**
-  * Return default width.  This is the width the toolbar
-  * dock would have if no toolbars need to be moved to other
-  * galleys than they would be logically placed.
-  */
-  virtual FXint getDefaultWidth();
-
-  /**
-  * Return default height.  This is the height the toolbar
-  * dock would have if no toolbars need to be moved to other
-  * galleys than they would be logically placed.
-  */
-  virtual FXint getDefaultHeight();
-
-  /**
-  * For a vertically oriented dock site, this computes
-  * the total width of all the galleys based on any "wrapping"
-  * needed to fit the toolbars on a galley.
-  */
-  virtual FXint getWidthForHeight(FXint h);
-
-  /**
-  * For a horizontally oriented dock site, this computes
-  * the total height of all the galleys based on any "wrapping"
-  * needed to fit the toolbars on a galley.
-  */
-  virtual FXint getHeightForWidth(FXint w);
-
-  /// Perform layout
-  virtual void layout();
-
-  /**
-  * Move tool bar, changing its options to suite the new position.
-  * Used by the toolbar dragging to rearrange the toolbars inside the
-  * toolbar dock.
-  */
-  virtual void moveToolBar(FXDockBar* bar,FXint barx,FXint bary);
-
-  /**
-  * The dock site is notified that the given bar has been added
-  * logically before the given window, and is to placed on a new
-  * galley all by itself.  The default implementation adjusts
-  * the layout options of the bars accordingly.
-  */
-  virtual void dockToolBar(FXDockBar* bar,FXWindow* before);
-
-  /**
-  * The dock site is informed that the given bar has been docked
-  * at the given coordinates.  The default implementation determines
-  * where to insert the newly docked bar and adjusts the layout
-  * options of the bars accordingly.
-  */
-  virtual void dockToolBar(FXDockBar* bar,FXint barx,FXint bary);
-
-  /**
-  * The dock site is informed that the given bar has been removed.
-  * In the default implementation, the dock site fixes the layout
-  * options of the remaining bars so they stay in the same place
-  * if possible.
-  */
-  virtual void undockToolBar(FXDockBar* bar);
-
-  /// Change wrap option
-  void wrapGalleys(FXbool wrap);
-
-  /// Get wrap option
-  FXbool wrapGalleys() const;
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXDockTitle.h b/fox-includes/FXDockTitle.h
deleted file mode 100644
index c1c122e1..00000000
--- a/fox-includes/FXDockTitle.h
+++ /dev/null
@@ -1,108 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                         D o c k T i t l e   W i d g e t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2005 by Jeroen van der Zijp.   All Rights Reserved.             *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDockTitle.h 2129 2005-08-07 20:24:37Z lyle $                        *
-********************************************************************************/
-#ifndef FXDOCKTITLE_H
-#define FXDOCKTITLE_H
-
-#ifndef FXDOCKHANDLER_H
-#include "FXDockHandler.h"
-#endif
-
-namespace FX {
-
-
-/**
-* A dock title is used to move its container, a dock bar.
-* The dock title is also used simultaneously to provide a
-* caption above the dock bar.
-*/
-class FXAPI FXDockTitle : public FXDockHandler {
-  FXDECLARE(FXDockTitle)
-protected:
-  FXString  caption;            // Caption text
-  FXFont   *font;               // Caption font
-  FXColor   captionColor;       // Caption color
-protected:
-  FXDockTitle();
-private:
-  FXDockTitle(const FXDockTitle&);
-  FXDockTitle& operator=(const FXDockTitle&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetStringValue(FXObject*,FXSelector,void*);
-  long onCmdGetStringValue(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct dock bar title widget
-  FXDockTitle(FXComposite* p,const FXString& text,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=FRAME_NORMAL|JUSTIFY_CENTER_X|JUSTIFY_CENTER_Y,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=0,FXint pr=0,FXint pt=0,FXint pb=0);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Set the caption for the grip
-  void setCaption(const FXString& text);
-
-  /// Get the caption for the grip
-  FXString getCaption() const { return caption; }
-
-  /// Set caption font
-  void setFont(FXFont *fnt);
-
-  /// Get caption font
-  FXFont* getFont() const { return font; }
-
-  /// Get the current caption color
-  FXColor getCaptionColor() const { return captionColor; }
-
-  /// Set the current caption color
-  void setCaptionColor(FXColor clr);
-
-  /// Set the current justification mode.
-  void setJustify(FXuint mode);
-
-  /// Get the current justification mode.
-  FXuint getJustify() const;
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destroy
-  virtual ~FXDockTitle();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXDocument.h b/fox-includes/FXDocument.h
deleted file mode 100755
index 7c301c67..00000000
--- a/fox-includes/FXDocument.h
+++ /dev/null
@@ -1,89 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                         D o c u m e n t   O b j e c t                         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDocument.h 2127 2005-08-07 20:21:35Z lyle $                        *
-********************************************************************************/
-#ifndef FXDOCUMENT_H
-#define FXDOCUMENT_H
-
-#ifndef FXOBJECT_H
-#include "FXObject.h"
-#endif
-
-namespace FX {
-
-
-// Forward
-class FXWindow;
-
-
-/// Abstract base class for documents
-class FXAPI FXDocument : public FXObject {
-  FXDECLARE(FXDocument)
-private:
-  FXString     title;             // Title to appear above windows
-  FXString     filename;          // File name to save to
-  FXbool       modified;          // Document has been modified
-public:
-  long onUpdTitle(FXObject*,FXSelector,void*);
-  long onUpdFilename(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_TITLE=10000,                 // Don't interfere with viewer's message id's
-    ID_FILENAME,
-    ID_LAST
-    };
-public:
-
-  /// Constructor
-  FXDocument();
-
-  /// Return true if document is modified
-  FXbool isModified() const { return modified; }
-
-  /// Set its modified state
-  void setModified(FXbool mdfy=TRUE){ modified=mdfy; }
-
-  /// Set document title
-  void setTitle(const FXString& name);
-
-  /// Get document title
-  const FXString& getTitle() const { return title; }
-
-  /// Set document filename
-  void setFilename(const FXString& path);
-
-  /// Get document filename
-  const FXString& getFilename() const { return filename; }
-
-  /// Save document to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load document from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXDocument();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXDragCorner.h b/fox-includes/FXDragCorner.h
deleted file mode 100755
index 9f6d872a..00000000
--- a/fox-includes/FXDragCorner.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       D r a g   C o r n e r   W i d g e t                     *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDragCorner.h 2196 2005-08-26 02:53:31Z lyle $                      *
-********************************************************************************/
-#ifndef FXDRAGCORNER_H
-#define FXDRAGCORNER_H
-
-#ifndef FXWINDOW_H
-#include "FXWindow.h"
-#endif
-
-namespace FX {
-
-
-/**
-* A drag corner widget may be placed in the bottom right corner
-* so as to allow the window to be resized more easily.
-*/
-class FXAPI FXDragCorner : public FXWindow {
-  FXDECLARE(FXDragCorner)
-protected:
-  FXColor hiliteColor;
-  FXColor shadowColor;
-  FXint   oldw;
-  FXint   oldh;
-  FXint   xoff;
-  FXint   yoff;
-  FXbool  ewmh;
-protected:
-  FXDragCorner();
-private:
-  FXDragCorner(const FXDragCorner&);
-  FXDragCorner &operator=(const FXDragCorner&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct a drag corner
-  FXDragCorner(FXComposite* p);
-
-  /// Get default width
-  virtual FXint getDefaultWidth();
-
-  /// Get default height
-  virtual FXint getDefaultHeight();
-
-  /// Create all of the server-side resources for this window
-  virtual void create();
-
-  /// Change highlight color
-  void setHiliteColor(FXColor clr);
-
-  /// Return current highlight color
-  FXColor getHiliteColor() const { return hiliteColor; }
-
-  /// Change shadow color
-  void setShadowColor(FXColor clr);
-
-  /// Return current shadow color
-  FXColor getShadowColor() const { return shadowColor; }
-
-  /// Save drag corner to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load drag corner from a stream
-  virtual void load(FXStream& store);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXDrawable.h b/fox-includes/FXDrawable.h
deleted file mode 100755
index 6c91bb53..00000000
--- a/fox-includes/FXDrawable.h
+++ /dev/null
@@ -1,88 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                           D r a w a b l e   A r e a                           *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2003 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDrawable.h 1641 2003-07-09 19:55:56Z lyle $                        *
-********************************************************************************/
-#ifndef FXDRAWABLE_H
-#define FXDRAWABLE_H
-
-#ifndef FXID_H
-#include "FXId.h"
-#endif
-
-namespace FX {
-
-
-class FXVisual;
-
-
-/**
-* Drawable is an abstract base class for any surface that can be
-* drawn upon, such as a FXWindow, or FXImage.
-*/
-class FXAPI FXDrawable : public FXId {
-  FXDECLARE_ABSTRACT(FXDrawable)
-  friend class FXDC;
-  friend class FXDCWindow;
-protected:
-  FXVisual     *visual;                 // Visual for this window
-  FXint         width;                  // Width
-  FXint         height;                 // Height
-protected:
-  FXDrawable();
-  FXDrawable(FXApp* a,FXint w,FXint h);
-private:
-  FXDrawable(const FXDrawable&);
-  FXDrawable &operator=(const FXDrawable&);
-#ifdef WIN32
-  virtual FXID GetDC() const { return NULL; }
-  virtual int ReleaseDC(FXID) const { return 0; }
-#endif
-public:
-
-  /// Width of drawable
-  FXint getWidth() const { return width; }
-
-  /// Height of drawable
-  FXint getHeight() const { return height; }
-
-  /// Get the visual
-  FXVisual* getVisual() const { return visual; }
-
-  /// Change visual
-  void setVisual(FXVisual* vis);
-
-  /// Resize drawable to the specified width and height
-  virtual void resize(FXint w,FXint h);
-
-  /// Save object to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load object from stream
-  virtual void load(FXStream& store);
-
-  /// Cleanup
-  virtual ~FXDrawable();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXDriveBox.h b/fox-includes/FXDriveBox.h
deleted file mode 100755
index 4d9757ef..00000000
--- a/fox-includes/FXDriveBox.h
+++ /dev/null
@@ -1,105 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        D r i v e   B o x   W i d g e t                        *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1999,2004 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXDriveBox.h 1889 2004-05-26 03:13:01Z lyle $                        *
-********************************************************************************/
-#ifndef FXDRIVEBOX_H
-#define FXDRIVEBOX_H
-
-#ifndef FXLISTBOX_H
-#include "FXListBox.h"
-#endif
-
-namespace FX {
-
-
-class FXIcon;
-class FXFileDict;
-
-/// Drive Box options
-enum {
-  DRIVEBOX_NO_OWN_ASSOC = 0x00020000    /// Do not create associations for files
-  };
-
-
-/// Directory Box
-class FXAPI FXDriveBox : public FXListBox {
-  FXDECLARE(FXDriveBox)
-protected:
-  FXFileDict *associations;     // Association table
-  FXIcon     *foldericon;       // Folder icons
-  FXIcon     *cdromicon;        // CDROM icon
-  FXIcon     *harddiskicon;     // Hard disk icon
-  FXIcon     *netdriveicon;     // Networked drive icon
-  FXIcon     *floppyicon;       // Floppy icon
-  FXIcon     *nethoodicon;      // Network neighborhood icon
-  FXIcon     *zipdiskicon;      // Zip drive icon
-protected:
-  FXDriveBox(){}
-  void listDrives();
-private:
-  FXDriveBox(const FXDriveBox&);
-  FXDriveBox &operator=(const FXDriveBox&);
-public:
-  long onListChanged(FXObject*,FXSelector,void*);
-  long onListClicked(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetStringValue(FXObject*,FXSelector,void*);
-  long onCmdGetStringValue(FXObject*,FXSelector,void*);
-public:
-
-  /// Constructor
-  FXDriveBox(FXComposite *p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=FRAME_SUNKEN|FRAME_THICK|LISTBOX_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Destroy server-side resources
-  virtual void destroy();
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Set current drive
-  FXbool setDrive(const FXString& drive);
-
-  /// Return current drive
-  FXString getDrive() const;
-
-  /// Change file associations
-  void setAssociations(FXFileDict* assoc);
-
-  /// Return file associations
-  FXFileDict* getAssociations() const { return associations; }
-
-  /// Destructor
-  virtual ~FXDriveBox();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXElement.h b/fox-includes/FXElement.h
deleted file mode 100755
index cfaf9fdd..00000000
--- a/fox-includes/FXElement.h
+++ /dev/null
@@ -1,209 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                           Generic Element Handling                            *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXElement.h 2335 2006-01-28 02:33:03Z lyle $                         *
-********************************************************************************/
-#ifndef FXELEMENT_H
-#define FXELEMENT_H
-
-namespace FX {
-
-/****************************  D e f i n i t i o n  ****************************/
-
-// Generic implementations for generic objects
-
-
-/// Construct some elements at a location
-template<class TYPE>
-inline void constructElms(TYPE* ptr,unsigned long n){
-  while(n--){ ::new ((void*)ptr) TYPE; ptr++; }
-  }
-
-
-/// Destruct some elements at a location
-template<class TYPE>
-inline void destructElms(TYPE* ptr,unsigned long n){
-  while(n--){ ptr->~TYPE(); ptr++; }
-  }
-
-
-/// Copy some elements from one place to another
-template<class TYPE>
-inline void copyElms(TYPE* dst,const TYPE* src,unsigned long n){
-  while(n--){ *dst++ = *src++; }
-  }
-
-
-/// Move some elements from overlapping place to another
-template<class TYPE>
-inline void moveElms(TYPE* dst,const TYPE* src,unsigned long n){
-  if(src>dst){
-    while(n--){ *dst++ = *src++; }
-    }
-  else if(dst>src){
-    dst+=n;
-    src+=n;
-    while(n--){ *--dst = *--src; }
-    }
-  }
-
-
-/// Fill array of elements with given element
-template<class TYPE>
-inline void fillElms(TYPE* dst,const TYPE& src,unsigned long n){
-  while(n--){ *dst++ = src; }
-  }
-
-
-/// Zero out array of elements
-template<class TYPE>
-inline void clearElms(TYPE* dst,unsigned long n){
-  memset(dst,0,sizeof(TYPE)*n);
-  }
-
-
-/// Save some elements to persistent store
-template<class TYPE>
-inline void saveElms(FXStream& store,const TYPE* ptr,unsigned long n){
-  while(n--){ store << *ptr; ptr++; }
-  }
-
-
-/// Load some elements from persistent store
-template<class TYPE>
-inline void loadElms(FXStream& store,TYPE* ptr,unsigned long n){
-  while(n--){ store >> *ptr; ptr++; }
-  }
-
-
-/// Allocate array of elements, uninitialized
-template<class TYPE>
-inline FXint allocElms(TYPE*& ptr,unsigned long n){
-  return fxmalloc((void**)&ptr,sizeof(TYPE)*n);
-  }
-
-
-/// Allocate array of elements, initialized with zero
-template<class TYPE>
-inline FXint callocElms(TYPE*& ptr,unsigned long n){
-  return fxcalloc((void**)&ptr,sizeof(TYPE)*n);
-  }
-
-
-/// Allocate array of elements, initialized with bit-wise copy of src array
-template<class TYPE>
-inline FXint dupElms(TYPE*& ptr,const TYPE* src,unsigned long n){
-  return fxmemdup((void**)&ptr,src,sizeof(TYPE)*n);
-  }
-
-
-/// Resize array of elements, without constructor or destructor
-template<class TYPE>
-inline FXint resizeElms(TYPE*& ptr,unsigned long n){
-  return fxresize((void**)&ptr,sizeof(TYPE)*n);
-  }
-
-
-/// Free array of elements, without destruction
-template<class TYPE>
-inline void freeElms(TYPE*& ptr){
-  fxfree((void**)&ptr);
-  }
-
-
-/**********************  I m p l e m e n t a t i o n  ************************/
-
-// Specific implementations for built-in types
-
-
-// No-op constructors for array of basic type
-inline void constructElms(FXuchar*,unsigned long){ }
-inline void constructElms(FXchar*,unsigned long){ }
-inline void constructElms(FXushort*,unsigned long){ }
-inline void constructElms(FXshort*,unsigned long){ }
-inline void constructElms(FXuint*,unsigned long){ }
-inline void constructElms(FXint*,unsigned long){ }
-inline void constructElms(FXfloat*,unsigned long){ }
-inline void constructElms(FXdouble*,unsigned long){ }
-
-// No-op destructors for array of basic type
-inline void destructElms(FXuchar*,unsigned long){ }
-inline void destructElms(FXchar*,unsigned long){ }
-inline void destructElms(FXushort*,unsigned long){ }
-inline void destructElms(FXshort*,unsigned long){ }
-inline void destructElms(FXuint*,unsigned long){ }
-inline void destructElms(FXint*,unsigned long){ }
-inline void destructElms(FXfloat*,unsigned long){ }
-inline void destructElms(FXdouble*,unsigned long){ }
-
-// Simple bit-wise copy for array of basic type
-inline void copyElms(FXuchar* dst,const FXuchar* src,unsigned long n){ memcpy(dst,src,n); }
-inline void copyElms(FXchar* dst,const FXchar* src,unsigned long n){ memcpy(dst,src,n); }
-inline void copyElms(FXushort* dst,const FXushort* src,unsigned long n){ memcpy(dst,src,n<<1); }
-inline void copyElms(FXshort* dst,const FXshort* src,unsigned long n){ memcpy(dst,src,n<<1); }
-inline void copyElms(FXuint* dst,const FXuint* src,unsigned long n){ memcpy(dst,src,n<<2); }
-inline void copyElms(FXint* dst,const FXint* src,unsigned long n){ memcpy(dst,src,n<<2); }
-inline void copyElms(FXfloat* dst,const FXfloat* src,unsigned long n){ memcpy(dst,src,n<<2); }
-inline void copyElms(FXdouble* dst,const FXdouble* src,unsigned long n){ memcpy(dst,src,n<<3); }
-
-// Simple bit-wise copy for array of pointers to any type
-template<class TYPE> inline void copyElms(TYPE** dst,const TYPE** src,unsigned long n){ memcpy(dst,src,n*sizeof(void*)); }
-
-// Simple bit-wise move for array of basic type
-inline void moveElms(FXuchar* dst,const FXuchar* src,unsigned long n){ memmove(dst,src,n); }
-inline void moveElms(FXchar* dst,const FXchar* src,unsigned long n){ memmove(dst,src,n); }
-inline void moveElms(FXushort* dst,const FXushort* src,unsigned long n){ memmove(dst,src,n<<1); }
-inline void moveElms(FXshort* dst,const FXshort* src,unsigned long n){ memmove(dst,src,n<<1); }
-inline void moveElms(FXuint* dst,const FXuint* src,unsigned long n){ memmove(dst,src,n<<2); }
-inline void moveElms(FXint* dst,const FXint* src,unsigned long n){ memmove(dst,src,n<<2); }
-inline void moveElms(FXfloat* dst,const FXfloat* src,unsigned long n){ memmove(dst,src,n<<2); }
-inline void moveElms(FXdouble* dst,const FXdouble* src,unsigned long n){ memmove(dst,src,n<<3); }
-
-// Simple bit-wise move for array of pointers to any type
-template<class TYPE> inline void moveElms(TYPE** dst,const TYPE** src,unsigned long n){ memmove(dst,src,n*sizeof(void*)); }
-
-// Fill byte arrays with constant
-inline void fillElms(FXuchar* dst,const FXuchar& src,unsigned long n){ memset(dst,src,n); }
-inline void fillElms(FXchar* dst,const FXchar& src,unsigned long n){ memset(dst,src,n); }
-
-// Type-safe save for basic types
-inline void saveElms(FXStream& store,const FXuchar* ptr,unsigned long n){ store.save(ptr,n); }
-inline void saveElms(FXStream& store,const FXchar* ptr,unsigned long n){ store.save(ptr,n); }
-inline void saveElms(FXStream& store,const FXushort* ptr,unsigned long n){ store.save(ptr,n); }
-inline void saveElms(FXStream& store,const FXshort* ptr,unsigned long n){ store.save(ptr,n); }
-inline void saveElms(FXStream& store,const FXuint* ptr,unsigned long n){ store.save(ptr,n); }
-inline void saveElms(FXStream& store,const FXint* ptr,unsigned long n){ store.save(ptr,n); }
-inline void saveElms(FXStream& store,const FXfloat* ptr,unsigned long n){ store.save(ptr,n); }
-inline void saveElms(FXStream& store,const FXdouble* ptr,unsigned long n){ store.save(ptr,n); }
-
-// Type-safe load for basic types
-inline void loadElms(FXStream& store,FXuchar* ptr,unsigned long n){ store.load(ptr,n); }
-inline void loadElms(FXStream& store,FXchar* ptr,unsigned long n){ store.load(ptr,n); }
-inline void loadElms(FXStream& store,FXushort* ptr,unsigned long n){ store.load(ptr,n); }
-inline void loadElms(FXStream& store,FXshort* ptr,unsigned long n){ store.load(ptr,n); }
-inline void loadElms(FXStream& store,FXuint* ptr,unsigned long n){ store.load(ptr,n); }
-inline void loadElms(FXStream& store,FXint* ptr,unsigned long n){ store.load(ptr,n); }
-inline void loadElms(FXStream& store,FXfloat* ptr,unsigned long n){ store.load(ptr,n); }
-inline void loadElms(FXStream& store,FXdouble* ptr,unsigned long n){ store.load(ptr,n); }
-
-}
-
-#endif
diff --git a/fox-includes/FXException.h b/fox-includes/FXException.h
deleted file mode 100755
index a5e21530..00000000
--- a/fox-includes/FXException.h
+++ /dev/null
@@ -1,125 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                          E x c e p t i o n  T y p e s                         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2000,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXException.h 2127 2005-08-07 20:21:35Z lyle $                       *
-********************************************************************************/
-#ifndef FXEXCEPTION_H
-#define FXEXCEPTION_H
-
-
-namespace FX {
-
-/// Generic catch-all exception
-class FXAPI FXException {
-private:
-  const FXchar *message;
-private:
-  static const FXchar exceptionName[];
-public:
-  FXException():message(FXException::exceptionName){}
-  FXException(const FXchar *msg):message(msg){}
-  const FXchar *what() const { return message; }
-  ~FXException(){}
-  };
-
-
-/// Generic error exception
-class FXAPI FXErrorException : public FXException {
-private:
-  static const FXchar exceptionName[];
-public:
-  FXErrorException():FXException(FXErrorException::exceptionName){}
-  FXErrorException(const FXchar *msg):FXException(msg){}
-  };
-
-
-/// Index out of range
-class FXAPI FXRangeException : public FXErrorException {
-private:
-  static const FXchar exceptionName[];
-public:
-  FXRangeException():FXErrorException(FXRangeException::exceptionName){}
-  FXRangeException(const FXchar *msg):FXErrorException(msg){}
-  };
-
-
-/// Invalid pointer
-class FXAPI FXPointerException : public FXErrorException {
-private:
-  static const FXchar exceptionName[];
-public:
-  FXPointerException():FXErrorException(FXPointerException::exceptionName){}
-  FXPointerException(const FXchar *msg):FXErrorException(msg){}
-  };
-
-
-/// Generic resource exception
-class FXAPI FXResourceException : public FXException {
-private:
-  static const FXchar exceptionName[];
-public:
-  FXResourceException():FXException(FXResourceException::exceptionName){}
-  FXResourceException(const FXchar *msg):FXException(msg){}
-  };
-
-
-/// Out of memory
-class FXAPI FXMemoryException : public FXResourceException {
-private:
-  static const FXchar exceptionName[];
-public:
-  FXMemoryException():FXResourceException(FXMemoryException::exceptionName){}
-  FXMemoryException(const FXchar *msg):FXResourceException(msg){}
-  };
-
-
-/// Window exception
-class FXAPI FXWindowException : public FXResourceException {
-private:
-  static const FXchar exceptionName[];
-public:
-  FXWindowException():FXResourceException(FXWindowException::exceptionName){}
-  FXWindowException(const FXchar *msg):FXResourceException(msg){}
-  };
-
-
-/// Image, cursor, bitmap exception
-class FXAPI FXImageException : public FXResourceException {
-private:
-  static const FXchar exceptionName[];
-public:
-  FXImageException():FXResourceException(FXImageException::exceptionName){}
-  FXImageException(const FXchar *msg):FXResourceException(msg){}
-  };
-
-
-/// Font exception
-class FXAPI FXFontException : public FXResourceException {
-private:
-  static const FXchar exceptionName[];
-public:
-  FXFontException():FXResourceException(FXFontException::exceptionName){}
-  FXFontException(const FXchar *msg):FXResourceException(msg){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXExpression.h b/fox-includes/FXExpression.h
deleted file mode 100644
index 6116d4c5..00000000
--- a/fox-includes/FXExpression.h
+++ /dev/null
@@ -1,88 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                      E x p r e s s i o n   E v a l u a t o r                  *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXExpression.h 2401 2006-04-27 00:46:49Z lyle $                      *
-********************************************************************************/
-#ifndef FXEXPRESSION_H
-#define FXEXPRESSION_H
-
-
-namespace FX {
-
-
-/// Expression error codes
-enum FXExpressionError {
-  EXPRERR_OK,
-  EXPRERR_EMPTY,             /// Empty input
-  EXPRERR_MEMORY,            /// Out of memory
-  EXPRERR_PAREN,             /// Unmatched parentheses
-  EXPRERR_TOKEN,             /// Illegal token
-  EXPRERR_COMMA,             /// Expected comma
-  EXPRERR_IDENT              /// Unknown identifier
-  };
-
-
-/// Expression
-class FXAPI FXExpression {
-private:
-  FXuchar *code;
-private:
-  static const FXuchar initial[];
-  static const FXchar *const errors[];
-public:
-
-  /// Construct empty expression object
-  FXExpression();
-
-  /// Copy expression object
-  FXExpression(const FXExpression& orig);
-
-  /// Compile expression; if error is not NULL, error code is returned
-  FXExpression(const FXchar* expression,const FXchar* variables=NULL,FXExpressionError* error=NULL);
-
-  /// Compile expression; if error is not NULL, error code is returned
-  FXExpression(const FXString& expression,const FXString& variables=FXString::null,FXExpressionError* error=NULL);
-
-  /// Assign another expression to this one
-  FXExpression& operator=(const FXExpression& orig);
-
-  /// See if expression is empty
-  bool empty() const { return (code==initial); }
-
-  /// Evaluate expression with given arguments, if any
-  FXdouble evaluate(const FXdouble *args=NULL);
-
-  /// Parse expression, return error code if syntax error is found
-  FXExpressionError parse(const FXchar* expression,const FXchar* variables=NULL);
-
-  /// Parse expression, return error code if syntax error is found
-  FXExpressionError parse(const FXString& expression,const FXString& variables=FXString::null);
-
-  /// Returns error code for given error
-  static const FXchar* getError(FXExpressionError err){ return errors[err]; }
-
-  /// Delete
- ~FXExpression();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXExtentd.h b/fox-includes/FXExtentd.h
deleted file mode 100644
index c3b3c37b..00000000
--- a/fox-includes/FXExtentd.h
+++ /dev/null
@@ -1,139 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*          D o u b l e - P r e c i s i o n    E x t e n t    C l a s s          *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2004,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXExtentd.h 2335 2006-01-28 02:33:03Z lyle $                          *
-********************************************************************************/
-#ifndef FXEXTENTD_H
-#define FXEXTENTD_H
-
-
-namespace FX {
-
-
-/// Extent
-class FXExtentd {
-public:
-  FXVec2d lower;
-  FXVec2d upper;
-public:
-
-  /// Default constructor
-  FXExtentd(){}
-
-  /// Copy constructor
-  FXExtentd(const FXExtentd& ext):lower(ext.lower),upper(ext.upper){}
-
-  /// Initialize from two vectors
-  FXExtentd(const FXVec2d& lo,const FXVec2d& hi):lower(lo),upper(hi){}
-
-  /// Initialize from six numbers
-  FXExtentd(FXdouble xlo,FXdouble xhi,FXdouble ylo,FXdouble yhi):lower(xlo,ylo),upper(xhi,yhi){}
-
-  /// Assignment
-  FXExtentd& operator=(const FXExtentd& ext){ lower=ext.lower; upper=ext.upper; return *this; }
-
-  /// Indexing with 0..1
-  FXVec2d& operator[](FXint i){ return (&lower)[i]; }
-
-  /// Indexing with 0..1
-  const FXVec2d& operator[](FXint i) const { return (&lower)[i]; }
-
-  /// Comparison
-  bool operator==(const FXExtentd& ext) const { return lower==ext.lower && upper==ext.upper;}
-  bool operator!=(const FXExtentd& ext) const { return lower!=ext.lower || upper!=ext.upper;}
-
-  /// Width of box
-  FXdouble width() const { return upper.x-lower.x; }
-
-  /// Height of box
-  FXdouble height() const { return upper.y-lower.y; }
-
-  /// Longest side
-  FXdouble longest() const;
-
-  /// shortest side
-  FXdouble shortest() const;
-
-  /// Length of diagonal
-  FXdouble diameter() const;
-
-  /// Get radius of box
-  FXdouble radius() const;
-
-  /// Compute diagonal
-  FXVec2d diagonal() const;
-
-  /// Get center of box
-  FXVec2d center() const;
-
-  /// Test if empty
-  bool empty() const;
-
-  /// Test if box contains point x,y
-  bool contains(FXdouble x,FXdouble y) const;
-
-  /// Test if box contains point p
-  bool contains(const FXVec2d& p) const;
-
-  /// Test if box properly contains another box
-  bool contains(const FXExtentd& ext) const;
-
-  /// Include point
-  FXExtentd& include(FXdouble x,FXdouble y);
-
-  /// Include point
-  FXExtentd& include(const FXVec2d& v);
-
-  /// Include given range into extent
-  FXExtentd& include(const FXExtentd& ext);
-
-  /// Test if bounds overlap
-  friend FXAPI bool overlap(const FXExtentd& a,const FXExtentd& b);
-
-  /// Get corner number 0..3
-  FXVec2d corner(FXint c) const { return FXVec2d((&lower)[c&1].x, (&lower)[(c>>1)&1].y); }
-
-  /// Union of two boxes
-  friend FXAPI FXExtentd unite(const FXExtentd& a,const FXExtentd& b);
-
-  /// Intersection of two boxes
-  friend FXAPI FXExtentd intersect(const FXExtentd& a,const FXExtentd& b);
-
-  /// Save object to a stream
-  friend FXAPI FXStream& operator<<(FXStream& store,const FXExtentd& ext);
-
-  /// Load object from a stream
-  friend FXAPI FXStream& operator>>(FXStream& store,FXExtentd& ext);
-  };
-
-
-extern FXAPI bool overlap(const FXExtentd& a,const FXExtentd& b);
-
-extern FXAPI FXExtentd unite(const FXExtentd& a,const FXExtentd& b);
-extern FXAPI FXExtentd intersect(const FXExtentd& a,const FXExtentd& b);
-
-extern FXAPI FXStream& operator<<(FXStream& store,const FXExtentd& ext);
-extern FXAPI FXStream& operator>>(FXStream& store,FXExtentd& ext);
-
-}
-
-#endif
-
diff --git a/fox-includes/FXExtentf.h b/fox-includes/FXExtentf.h
deleted file mode 100644
index 1feeb995..00000000
--- a/fox-includes/FXExtentf.h
+++ /dev/null
@@ -1,139 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*          S i n g l e - P r e c i s i o n    E x t e n t    C l a s s          *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2004,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXExtentf.h 2335 2006-01-28 02:33:03Z lyle $                          *
-********************************************************************************/
-#ifndef FXEXTENTF_H
-#define FXEXTENTF_H
-
-
-namespace FX {
-
-
-/// Extent
-class FXExtentf {
-public:
-  FXVec2f lower;
-  FXVec2f upper;
-public:
-
-  /// Default constructor
-  FXExtentf(){}
-
-  /// Copy constructor
-  FXExtentf(const FXExtentf& ext):lower(ext.lower),upper(ext.upper){}
-
-  /// Initialize from two vectors
-  FXExtentf(const FXVec2f& lo,const FXVec2f& hi):lower(lo),upper(hi){}
-
-  /// Initialize from six numbers
-  FXExtentf(FXfloat xlo,FXfloat xhi,FXfloat ylo,FXfloat yhi):lower(xlo,ylo),upper(xhi,yhi){}
-
-  /// Assignment
-  FXExtentf& operator=(const FXExtentf& ext){ lower=ext.lower; upper=ext.upper; return *this; }
-
-  /// Indexing with 0..1
-  FXVec2f& operator[](FXint i){ return (&lower)[i]; }
-
-  /// Indexing with 0..1
-  const FXVec2f& operator[](FXint i) const { return (&lower)[i]; }
-
-  /// Comparison
-  bool operator==(const FXExtentf& ext) const { return lower==ext.lower && upper==ext.upper;}
-  bool operator!=(const FXExtentf& ext) const { return lower!=ext.lower || upper!=ext.upper;}
-
-  /// Width of box
-  FXfloat width() const { return upper.x-lower.x; }
-
-  /// Height of box
-  FXfloat height() const { return upper.y-lower.y; }
-
-  /// Longest side
-  FXfloat longest() const;
-
-  /// shortest side
-  FXfloat shortest() const;
-
-  /// Length of diagonal
-  FXfloat diameter() const;
-
-  /// Get radius of box
-  FXfloat radius() const;
-
-  /// Compute diagonal
-  FXVec2f diagonal() const;
-
-  /// Get center of box
-  FXVec2f center() const;
-
-  /// Test if empty
-  bool empty() const;
-
-  /// Test if box contains point x,y
-  bool contains(FXfloat x,FXfloat y) const;
-
-  /// Test if box contains point p
-  bool contains(const FXVec2f& p) const;
-
-  /// Test if box properly contains another box
-  bool contains(const FXExtentf& ext) const;
-
-  /// Include point
-  FXExtentf& include(FXfloat x,FXfloat y);
-
-  /// Include point
-  FXExtentf& include(const FXVec2f& v);
-
-  /// Include given range into extent
-  FXExtentf& include(const FXExtentf& ext);
-
-  /// Test if bounds overlap
-  friend FXAPI bool overlap(const FXExtentf& a,const FXExtentf& b);
-
-  /// Get corner number 0..3
-  FXVec2f corner(FXint c) const { return FXVec2f((&lower)[c&1].x, (&lower)[(c>>1)&1].y); }
-
-  /// Union of two boxes
-  friend FXAPI FXExtentf unite(const FXExtentf& a,const FXExtentf& b);
-
-  /// Intersection of two boxes
-  friend FXAPI FXExtentf intersect(const FXExtentf& a,const FXExtentf& b);
-
-  /// Save object to a stream
-  friend FXAPI FXStream& operator<<(FXStream& store,const FXExtentf& ext);
-
-  /// Load object from a stream
-  friend FXAPI FXStream& operator>>(FXStream& store,FXExtentf& ext);
-  };
-
-
-extern FXAPI bool overlap(const FXExtentf& a,const FXExtentf& b);
-
-extern FXAPI FXExtentf unite(const FXExtentf& a,const FXExtentf& b);
-extern FXAPI FXExtentf intersect(const FXExtentf& a,const FXExtentf& b);
-
-extern FXAPI FXStream& operator<<(FXStream& store,const FXExtentf& ext);
-extern FXAPI FXStream& operator>>(FXStream& store,FXExtentf& ext);
-
-}
-
-#endif
-
diff --git a/fox-includes/FXFile.h b/fox-includes/FXFile.h
deleted file mode 100755
index 9749be7d..00000000
--- a/fox-includes/FXFile.h
+++ /dev/null
@@ -1,131 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                             F i l e   C l a s s                               *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2000,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXFile.h 2335 2006-01-28 02:33:03Z lyle $                            *
-********************************************************************************/
-#ifndef FXFILE_H
-#define FXFILE_H
-
-#ifndef FXIO_H
-#include "FXIO.h"
-#endif
-
-
-namespace FX {
-
-
-/**
-* Low level file access.
-*/
-class FXAPI FXFile : public FXIO {
-private:
-  FXFile(const FXFile&);
-  FXFile &operator=(const FXFile&);
-public:
-
-  /// Construct file
-  FXFile(){ }
-
-  /// Construct file and attach existing handle h
-  FXFile(FXInputHandle handle,FXuint mode);
-
-  /// Construct and open a file
-  FXFile(const FXString& file,FXuint mode=FXIO::Reading,FXuint perm=FXIO::OwnerReadWrite|FXIO::GroupReadWrite|FXIO::OtherReadWrite);
-
-  /// Open file
-  virtual bool open(const FXString& file,FXuint mode=FXIO::Reading,FXuint perm=FXIO::OwnerReadWrite|FXIO::GroupReadWrite|FXIO::OtherReadWrite);
-
-  /// Open device with access mode and handle
-  virtual bool open(FXInputHandle handle,FXuint mode);
-
-  /// Get current file position
-  virtual FXlong position() const;
-
-  /// Change file position, returning new position from start
-  virtual FXlong position(FXlong offset,FXuint from=FXIO::Begin);
-
-  /// Read block of bytes, returning number of bytes read
-  virtual FXival readBlock(void* data,FXival count);
-
-  /// Write block of bytes, returning number of bytes written
-  virtual FXival writeBlock(const void* data,FXival count);
-
-  /// Truncate file
-  virtual FXlong truncate(FXlong size);
-
-  /// Flush to disk
-  virtual bool flush();
-
-  /// Return file size
-  virtual FXlong size();
-
-  /// Test if we're at the end
-  virtual bool eof();
-
-  /// Close file
-  virtual bool close();
-
-
-  /// Create new (empty) file
-  static bool create(const FXString& file,FXuint perm=FXIO::OwnerReadWrite|FXIO::GroupReadWrite|FXIO::OtherReadWrite);
-
-  /// Remove file
-  static bool remove(const FXString& file);
-
-  /// Rename or move srcfile to dstfile, replacing dstfile if it exists
-  static bool rename(const FXString& srcfile,const FXString& dstfile);
-
-  /// Link file
-  static bool link(const FXString& srcfile,const FXString& dstfile);
-
-  /// Read symbolic link
-  static FXString symlink(const FXString& file);
-
-  /// Symbolic link file
-  static bool symlink(const FXString& srcfile,const FXString& dstfile);
-
-  /// Return true if files are identical
-  static bool identical(const FXString& file1,const FXString& file2);
-
-  /// Copy srcfile to dstfile, overwriting dstfile if allowed
-  static bool copy(const FXString& srcfile,const FXString& dstfile,bool overwrite=false);
-
-  /// Concatenate srcfile1 and srcfile2 to dstfile, overwriting dstfile if allowed
-  static bool concat(const FXString& srcfile1,const FXString& srcfile2,const FXString& dstfile,bool overwrite=false);
-
-
-
-  /// Recursively copy files or directories from srcfile to dstfile, overwriting dstfile if allowed
-  static bool copyFiles(const FXString& srcfile,const FXString& dstfile,bool overwrite=false);
-
-  /// Recursively copy or move files or directories from srcfile to dstfile, overwriting dstfile if allowed
-  static bool moveFiles(const FXString& srcfile,const FXString& dstfile,bool overwrite=false);
-
-  /// Recursively remove file or directory, recurse if allowed
-  static bool removeFiles(const FXString& path,bool recursive=false);
-
-  /// Destroy
-  virtual ~FXFile();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXFileDialog.h b/fox-includes/FXFileDialog.h
deleted file mode 100755
index 7043c29f..00000000
--- a/fox-includes/FXFileDialog.h
+++ /dev/null
@@ -1,207 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                   F i l e   S e l e c t i o n   D i a l o g                   *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXFileDialog.h 2342 2006-02-10 14:24:44Z lyle $                      *
-********************************************************************************/
-#ifndef FXFILEDIALOG_H
-#define FXFILEDIALOG_H
-
-#ifndef FXDIALOGBOX_H
-#include "FXDialogBox.h"
-#endif
-
-namespace FX {
-
-
-class FXFileSelector;
-
-
-/// File selection dialog
-class FXAPI FXFileDialog : public FXDialogBox {
-  FXDECLARE(FXFileDialog)
-protected:
-  FXFileSelector *filebox;
-protected:
-  FXFileDialog(){}
-  void initdialog();
-private:
-  FXFileDialog(const FXFileDialog&);
-  FXFileDialog &operator=(const FXFileDialog&);
-public:
-
-  /// Construct file dialog box
-  FXFileDialog(FXWindow* owner,const FXString& name,FXuint opts=0,FXint x=0,FXint y=0,FXint w=500,FXint h=300);
-
-  /// Construct free-floating file dialog box
-  FXFileDialog(FXApp* a,const FXString& name,FXuint opts=0,FXint x=0,FXint y=0,FXint w=500,FXint h=300);
-
-  /// Hide this window
-  virtual void hide();
-
-  /// Change file name
-  void setFilename(const FXString& path);
-
-  /// Return file name, if any
-  FXString getFilename() const;
-
-  /// Return empty-string terminated list of selected file names, or NULL if none selected
-  FXString* getFilenames() const;
-
-  /// Change file pattern
-  void setPattern(const FXString& ptrn);
-
-  /// Return file pattern
-  FXString getPattern() const;
-
-  /**
-  * Change the list of file patterns shown in the file dialog.
-  * Each pattern comprises an optional name, followed by a pattern in
-  * parentheses.  The patterns are separated by newlines.
-  * For example,
-  *
-  *  "*\n*.cpp,*.cc\n*.hpp,*.hh,*.h"
-  *
-  * and
-  *
-  *  "All Files (*)\nC++ Sources (*.cpp,*.cc)\nC++ Headers (*.hpp,*.hh,*.h)"
-  *
-  * will set the same three patterns, but the former shows no pattern names.
-  */
-  void setPatternList(const FXString& patterns);
-
-  /// Return list of patterns
-  FXString getPatternList() const;
-
-  /**
-  * After setting the list of patterns, this call will
-  * initially select pattern n as the active one.
-  */
-  void setCurrentPattern(FXint n);
-
-  /// Return current pattern number
-  FXint getCurrentPattern() const;
-
-  /// Get pattern text for given pattern number
-  FXString getPatternText(FXint patno) const;
-
-  /// Change pattern text for pattern number
-  void setPatternText(FXint patno,const FXString& text);
-
-  /// Return number of patterns
-  FXint getNumPatterns() const;
-
-  /// Allow pattern entry
-  void allowPatternEntry(FXbool allow);
-
-  /// Return TRUE if pattern entry is allowed
-  FXbool allowPatternEntry() const;
-
-  /// Change directory
-  void setDirectory(const FXString& path);
-
-  /// Return directory
-  FXString getDirectory() const;
-
-  /// Set the inter-item spacing (in pixels)
-  void setItemSpace(FXint s);
-
-  /// Return the inter-item spacing (in pixels)
-  FXint getItemSpace() const;
-
-  /// Change file selection mode
-  void setSelectMode(FXuint mode);
-
-  /// Return file selection mode
-  FXuint getSelectMode() const;
-
-  /// Change wildcard matching mode
-  void setMatchMode(FXuint mode);
-
-  /// Return wildcard matching mode
-  FXuint getMatchMode() const;
-
-  /// Return TRUE if showing hidden files
-  FXbool showHiddenFiles() const;
-
-  /// Show or hide hidden files
-  void showHiddenFiles(FXbool showing);
-
-  /// Return TRUE if image preview on
-  FXbool showImages() const;
-
-  /// Show or hide preview images
-  void showImages(FXbool showing);
-
-  /// Return images preview size
-  FXint getImageSize() const;
-
-  /// Change images preview size
-  void setImageSize(FXint size);
-
-  /// Show readonly button
-  void showReadOnly(FXbool show);
-
-  /// Return TRUE if readonly is shown
-  FXbool shownReadOnly() const;
-
-  /// Set initial state of readonly button
-  void setReadOnly(FXbool state);
-
-  /// Get readonly state
-  FXbool getReadOnly() const;
-
-  /// Change File List style
-  void setFileBoxStyle(FXuint style);
-
-  /// Return File List style
-  FXuint getFileBoxStyle() const;
-
-  /// Allow or disallow navigation
-  void allowNavigation(FXbool navigable);
-
-  /// Is navigation allowed?
-  FXbool allowNavigation() const;
-
-  /// Open existing filename
-  static FXString getOpenFilename(FXWindow* owner,const FXString& caption,const FXString& path,const FXString& patterns="*",FXint initial=0);
-
-  /// Open multiple existing files
-  static FXString* getOpenFilenames(FXWindow* owner,const FXString& caption,const FXString& path,const FXString& patterns="*",FXint initial=0);
-
-  /// Save to filename
-  static FXString getSaveFilename(FXWindow* owner,const FXString& caption,const FXString& path,const FXString& patterns="*",FXint initial=0);
-
-  /// Open directory name
-  static FXString getOpenDirectory(FXWindow* owner,const FXString& caption,const FXString& path);
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXFileDialog();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXFileDict.h b/fox-includes/FXFileDict.h
deleted file mode 100755
index 6019dd9a..00000000
--- a/fox-includes/FXFileDict.h
+++ /dev/null
@@ -1,227 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                  F i l e - A s s o c i a t i o n   T a b l e                  *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXFileDict.h 2335 2006-01-28 02:33:03Z lyle $                        *
-********************************************************************************/
-#ifndef FXFILEDICT_H
-#define FXFILEDICT_H
-
-#ifndef FXDICT_H
-#include "FXDict.h"
-#endif
-
-namespace FX {
-
-
-class FXIconDict;
-
-
-/// Registers stuff to know about the extension
-struct FXFileAssoc {
-  FXString   command;           /// Command to execute
-  FXString   extension;         /// Full extension name
-  FXString   mimetype;          /// Mime type name
-  FXIcon    *bigicon;           /// Big normal icon
-  FXIcon    *bigiconopen;       /// Big open icon
-  FXIcon    *miniicon;          /// Mini normal icon
-  FXIcon    *miniiconopen;      /// Mini open icon
-  FXDragType dragtype;          /// Registered drag type
-  FXuint     flags;             /// Flags; 1=cd, 2=term
-  };
-
-
-
-/**
-* The File Association dictionary associates a file extension with a File
-* Association record which contains command name, mime type, icons, and other
-* information about the file type.  The icons referenced by the file association
-* are managed by the Icon Dictionary; this guarantees that each icon is loaded
-* only once into memory.
-* The associations are determined by the information by the FOX Registry settings;
-* each entry under the FILETYPES registry section comprises the command line,
-* extension name, large icon, small icon, and mime type:
-*
-*   command ';' extension ';' bigicon [ ':' bigiconopen ] ';' icon [ ':' iconopen ] ';' mime [ ';' flags ]
-*
-* For example, the binding for "jpg" could be:
-*
-*   xv %s &;JPEG Image;bigimage.xpm;miniimage.xpm;image/jpeg;term
-*
-* The association for a file name is determined by first looking at the entire
-* file name, then at the whole extension, and then at sub-extensions.
-* For example, "name.tar.gz", "tar.gz", and "gz" can each be given a different
-* file association.  Directory names may also be given associations; there is
-* no command-line association for a directory, however.  The association for a
-* directory is found by first checking the whole pathname, then checking the
-* pathname less the first component, and so on.  So, "/usr/local/include",
-* "/local/include", and "/include" can each be given their own file associations.
-* If the above lookup procedure has not found a file association, the system
-* uses a fallback associations: for files, the fallback association is determined
-* by the binding "defaultfilebinding".  For directories, the "defaultdirbinding"
-* is used, and for executables the "defaultexecbinding" is used.
-* The flags field is used for a number of bit-flags; two flags are currently
-* defined: 'cd' and 'term'.  The first one is intended to cause a launcher
-* to execute the application in the shown directory; the second one is meant
-* to indicate that the application is to be ran inside a new terminal.
-*/
-class FXAPI FXFileDict : public FXDict {
-  FXDECLARE(FXFileDict)
-private:
-  FXSettings *settings; // Settings database where to get bindings
-  FXIconDict *icons;    // Icon dictionary which keeps track of loaded icons
-protected:
-  FXFileDict(){}
-  virtual void *createData(const void*);
-  virtual void deleteData(void*);
-private:
-  FXFileDict(const FXFileDict&);
-  FXFileDict &operator=(const FXFileDict&);
-public:
-
-  /// Registry key used to find fallback executable icons
-  static const FXchar defaultExecBinding[];
-
-  /// Registry key used to find fallback directory icons
-  static const FXchar defaultDirBinding[];
-
-  /// Registry key used to find fallback document icons
-  static const FXchar defaultFileBinding[];
-
-public:
-
-  /**
-  * Construct a dictionary mapping file-extension to file associations,
-  * using the application registry settings as a source for the bindings.
-  * The pointer to the application class is passed down to the icon source
-  * which is inside the icon dictionary.
-  */
-  FXFileDict(FXApp* app);
-
-  /**
-  * Construct a dictionary mapping file-extension to file associations,
-  * using the specified settings database as a source for the bindings.
-  * The pointer to the application class is passed down to the icon source
-  * which is inside the icon dictionary.
-  */
-  FXFileDict(FXApp* app,FXSettings* db);
-
-  /// Change settings database
-  void setSettings(FXSettings* s){ settings=s; }
-
-  /// Return settings database
-  FXSettings* getSettings() const { return settings; }
-
-  /// Change icon dictionary
-  void setIconDict(FXIconDict *icns){ icons=icns; }
-
-  /// Return icon dictionary
-  FXIconDict* getIconDict() const { return icons; }
-
-  /**
-  * Set icon search path; the initial search path is determined by the
-  * "iconpath" registry setting in the SETTINGS section.
-  */
-  void setIconPath(const FXString& path);
-
-  /// Return current icon search path
-  const FXString& getIconPath() const;
-
-  /**
-  * Replace file association.
-  * The new association is written into the settings database under the
-  * FILETYPES section; the format of the association is as follows:
-  *
-  * <extension> = "<command> ; <type> ; <bigicon> [ : <bigopenicon> ] ; <smallicon> [ : <smalliconopen> ] ; <mimetype>"
-  *
-  * Where <command> is the command used to launch the application (e.g. "xv %s &"),
-  * and <type> is the file type string (e.g. "GIF Image"),
-  * <bigicon> and <bigiconopen> are the large icons shown in "Icons" mode,
-  * <smallicon> and <smalliconopen> are the small icons shown in "Details" mode,
-  * and <mimetype> is the RFC2045 mime type of the file.
-  *
-  * For example:
-  *
-  * [FILETYPES]
-  * gif="xv %s &;GIF Image;big.xpm:bigopen.xpm;mini.xpm:miniopen.xpm;image/gif"
-  * /home/jeroen=";Home;home.xpm;minihome.xpm;application/x-folder"
-  *
-  */
-  FXFileAssoc* replace(const FXchar* ext,const FXchar* str);
-
-  /// Remove file association
-  FXFileAssoc* remove(const FXchar* ext);
-
-  /// Find file association from registry
-  FXFileAssoc* find(const FXchar* ext);
-
-  /**
-  * Determine binding for the given file.
-  * The default implementation tries the whole filename first,
-  * then tries the extensions.
-  * For example, for a file "source.tar.gz":
-  *
-  *  "source.tar.gz",
-  *  "tar.gz",
-  *  "gz"
-  *
-  * are tried in succession.  If no association is found the
-  * key "defaultfilebinding" is tried as a fallback association.
-  * A NULL is returned if no association of any kind is found.
-  */
-  virtual FXFileAssoc* findFileBinding(const FXchar* pathname);
-
-  /**
-  * Find directory binding from registry.
-  * The default implementation tries the whole pathname first,
-  * then tries successively smaller parts of the path.
-  * For example, a pathname "/usr/people/jeroen":
-  *
-  *   "/usr/people/jeroen"
-  *   "/people/jeroen"
-  *   "/jeroen"
-  *
-  * are tried in succession.  If no bindings are found, the
-  * key "defaultdirbinding" is tried as a fallback association.
-  * A NULL is returned if no association of any kind is found.
-  */
-  virtual FXFileAssoc* findDirBinding(const FXchar* pathname);
-
-  /**
-  * Determine binding for the given executable.
-  * The default implementation returns the fallback binding associated with
-  * the key "defaultexecbinding".
-  * A NULL is returned if no association of any kind is found.
-  */
-  virtual FXFileAssoc* findExecBinding(const FXchar* pathname);
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXFileDict();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXFileList.h b/fox-includes/FXFileList.h
deleted file mode 100755
index 736e8ee7..00000000
--- a/fox-includes/FXFileList.h
+++ /dev/null
@@ -1,358 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        F i l e    L i s t   W i d g e t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXFileList.h 2336 2006-02-04 15:20:33Z lyle $                        *
-********************************************************************************/
-#ifndef FXFILELIST_H
-#define FXFILELIST_H
-
-#ifndef FXICONLIST_H
-#include "FXIconList.h"
-#endif
-
-namespace FX {
-
-struct FXFileAssoc;
-class FXFileDict;
-class FXFileList;
-class FXIcon;
-class FXIconSource;
-class FXIconDict;
-
-
-/// File List options
-enum {
-  FILELIST_SHOWHIDDEN   = 0x04000000, /// Show hidden files or directories
-  FILELIST_SHOWDIRS     = 0x08000000, /// Show only directories
-  FILELIST_SHOWFILES    = 0x10000000, /// Show only files
-  FILELIST_SHOWIMAGES   = 0x20000000, /// Show preview of images
-  FILELIST_NO_OWN_ASSOC = 0x40000000, /// Do not create associations for files
-  FILELIST_NO_PARENT    = 0x80000000  /// Suppress display of '.' and '..'
-  };
-
-
-
-/// File item
-class FXAPI FXFileItem : public FXIconItem {
-  FXDECLARE(FXFileItem)
-  friend class FXFileList;
-protected:
-  FXFileAssoc  *assoc;                  // File association record
-  FXFileItem   *link;                   // Link to next item
-  FXlong        size;                   // File size
-  FXTime        date;                   // File time
-private:
-  FXFileItem(const FXFileItem&);
-  FXFileItem& operator=(const FXFileItem&);
-protected:
-  FXFileItem():assoc(NULL),link(NULL),size(0),date(0){}
-protected:
-  enum{
-    FOLDER     = 64,                    // Directory item
-    EXECUTABLE = 128,                   // Executable item
-    SYMLINK    = 256,                   // Symbolic linked item
-    CHARDEV    = 512,                   // Character special item
-    BLOCKDEV   = 1024,                  // Block special item
-    FIFO       = 2048,                  // FIFO item
-    SOCK       = 4096,                  // Socket item
-    SHARE      = 8192                   // Share
-    };
-public:
-  /// Constructor
-  FXFileItem(const FXString& text,FXIcon* bi=NULL,FXIcon* mi=NULL,void* ptr=NULL):FXIconItem(text,bi,mi,ptr),assoc(NULL),link(NULL),size(0L),date(0){}
-
-  /// Return true if this is a file item
-  FXbool isFile() const { return (state&(FOLDER|BLOCKDEV|CHARDEV|FIFO|SOCK|SHARE))==0; }
-
-  /// Return true if this is a directory item
-  FXbool isDirectory() const { return (state&FOLDER)!=0; }
-
-  /// Return true if this is a share item
-  FXbool isShare() const { return (state&SHARE)!=0; }
-
-  /// Return true if this is an executable item
-  FXbool isExecutable() const { return (state&EXECUTABLE)!=0; }
-
-  /// Return true if this is a symbolic link item
-  FXbool isSymlink() const { return (state&SYMLINK)!=0; }
-
-  /// Return true if this is a character device item
-  FXbool isChardev() const { return (state&CHARDEV)!=0; }
-
-  /// Return true if this is a block device item
-  FXbool isBlockdev() const { return (state&BLOCKDEV)!=0; }
-
-  /// Return true if this is an FIFO item
-  FXbool isFifo() const { return (state&FIFO)!=0; }
-
-  /// Return true if this is a socket
-  FXbool isSocket() const { return (state&SOCK)!=0; }
-
-  /// Return the file-association object for this item
-  FXFileAssoc* getAssoc() const { return assoc; }
-
-  /// Return the file size for this item
-  FXlong getSize() const { return size; }
-
-  /// Return the date for this item
-  FXTime getDate() const { return date; }
-  };
-
-
-/**
-* A File List widget provides an icon rich view of the file system.
-* It automatically updates itself periodically by re-scanning the file system
-* for any changes.  As it scans the displayed directory, it automatically
-* determines the icons to be displayed by consulting the file associations registry
-* settings.  A number of messages can be sent to the File List to control the
-* filter pattern, sort category, sorting order, case sensitivity, and hidden file
-* display mode.
-* The File list widget supports drags and drops of files.
-*/
-class FXAPI FXFileList : public FXIconList {
-  FXDECLARE(FXFileList)
-protected:
-  FXString      directory;      // Current directory
-  FXString      orgdirectory;   // Original directory
-  FXString      dropdirectory;  // Drop directory
-  FXDragAction  dropaction;     // Drop action
-  FXString      dragfiles;      // Dragged files
-  FXFileDict   *associations;   // Association table
-  FXFileItem   *list;           // File item list
-  FXString      pattern;        // Pattern of file names
-  FXuint        matchmode;      // File wildcard match mode
-  FXuint        counter;        // Refresh counter
-  FXint         imagesize;      // Image size
-  FXTime        timestamp;      // Time when last refreshed
-  FXIcon       *big_folder;     // Big folder icon
-  FXIcon       *mini_folder;    // Mini folder icon
-  FXIcon       *big_doc;        // Big document icon
-  FXIcon       *mini_doc;       // Mini document icon
-  FXIcon       *big_app;        // Big application icon
-  FXIcon       *mini_app;       // Mini application icon
-protected:
-  FXFileList();
-  virtual FXIconItem *createItem(const FXString& text,FXIcon *big,FXIcon* mini,void* ptr);
-  void listItems(FXbool force);
-private:
-  FXFileList(const FXFileList&);
-  FXFileList &operator=(const FXFileList&);
-public:
-  long onOpenTimer(FXObject*,FXSelector,void*);
-  long onRefreshTimer(FXObject*,FXSelector,void*);
-  long onDNDEnter(FXObject*,FXSelector,void*);
-  long onDNDLeave(FXObject*,FXSelector,void*);
-  long onDNDMotion(FXObject*,FXSelector,void*);
-  long onDNDDrop(FXObject*,FXSelector,void*);
-  long onDNDRequest(FXObject*,FXSelector,void*);
-  long onBeginDrag(FXObject*,FXSelector,void*);
-  long onEndDrag(FXObject*,FXSelector,void*);
-  long onDragged(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdGetStringValue(FXObject*,FXSelector,void*);
-  long onCmdSetStringValue(FXObject*,FXSelector,void*);
-  long onCmdDirectoryUp(FXObject*,FXSelector,void*);
-  long onUpdDirectoryUp(FXObject*,FXSelector,void*);
-  long onCmdSortByName(FXObject*,FXSelector,void*);
-  long onUpdSortByName(FXObject*,FXSelector,void*);
-  long onCmdSortByType(FXObject*,FXSelector,void*);
-  long onUpdSortByType(FXObject*,FXSelector,void*);
-  long onCmdSortBySize(FXObject*,FXSelector,void*);
-  long onUpdSortBySize(FXObject*,FXSelector,void*);
-  long onCmdSortByTime(FXObject*,FXSelector,void*);
-  long onUpdSortByTime(FXObject*,FXSelector,void*);
-  long onCmdSortByUser(FXObject*,FXSelector,void*);
-  long onUpdSortByUser(FXObject*,FXSelector,void*);
-  long onCmdSortByGroup(FXObject*,FXSelector,void*);
-  long onUpdSortByGroup(FXObject*,FXSelector,void*);
-  long onCmdSortReverse(FXObject*,FXSelector,void*);
-  long onUpdSortReverse(FXObject*,FXSelector,void*);
-  long onCmdSortCase(FXObject*,FXSelector,void*);
-  long onUpdSortCase(FXObject*,FXSelector,void*);
-  long onCmdSetPattern(FXObject*,FXSelector,void*);
-  long onUpdSetPattern(FXObject*,FXSelector,void*);
-  long onCmdSetDirectory(FXObject*,FXSelector,void*);
-  long onUpdSetDirectory(FXObject*,FXSelector,void*);
-  long onCmdToggleHidden(FXObject*,FXSelector,void*);
-  long onUpdToggleHidden(FXObject*,FXSelector,void*);
-  long onCmdShowHidden(FXObject*,FXSelector,void*);
-  long onUpdShowHidden(FXObject*,FXSelector,void*);
-  long onCmdHideHidden(FXObject*,FXSelector,void*);
-  long onUpdHideHidden(FXObject*,FXSelector,void*);
-  long onCmdToggleImages(FXObject*,FXSelector,void*);
-  long onUpdToggleImages(FXObject*,FXSelector,void*);
-  long onCmdHeader(FXObject*,FXSelector,void*);
-  long onUpdHeader(FXObject*,FXSelector,void*);
-  long onCmdRefresh(FXObject*,FXSelector,void*);
-public:
-  static FXint ascending(const FXIconItem* a,const FXIconItem* b);
-  static FXint descending(const FXIconItem* a,const FXIconItem* b);
-  static FXint ascendingCase(const FXIconItem* a,const FXIconItem* b);
-  static FXint descendingCase(const FXIconItem* a,const FXIconItem* b);
-  static FXint ascendingType(const FXIconItem* a,const FXIconItem* b);
-  static FXint descendingType(const FXIconItem* a,const FXIconItem* b);
-  static FXint ascendingSize(const FXIconItem* a,const FXIconItem* b);
-  static FXint descendingSize(const FXIconItem* a,const FXIconItem* b);
-  static FXint ascendingTime(const FXIconItem* a,const FXIconItem* b);
-  static FXint descendingTime(const FXIconItem* a,const FXIconItem* b);
-  static FXint ascendingUser(const FXIconItem* a,const FXIconItem* b);
-  static FXint descendingUser(const FXIconItem* a,const FXIconItem* b);
-  static FXint ascendingGroup(const FXIconItem* a,const FXIconItem* b);
-  static FXint descendingGroup(const FXIconItem* a,const FXIconItem* b);
-public:
-  enum {
-    ID_REFRESHTIMER=FXIconList::ID_LAST,
-    ID_OPENTIMER,
-    ID_SORT_BY_NAME,    /// Sort by name
-    ID_SORT_BY_TYPE,    /// Sort by type
-    ID_SORT_BY_SIZE,    /// Sort by size
-    ID_SORT_BY_TIME,    /// Sort by access time
-    ID_SORT_BY_USER,    /// Sort by owner name
-    ID_SORT_BY_GROUP,   /// Sort by group name
-    ID_SORT_REVERSE,    /// Reverse sort order
-    ID_SORT_CASE,       /// Toggle sort case sensitivity
-    ID_DIRECTORY_UP,    /// Move up one directory
-    ID_SET_PATTERN,     /// Set match pattern
-    ID_SET_DIRECTORY,   /// Set directory
-    ID_SHOW_HIDDEN,     /// Show hidden files
-    ID_HIDE_HIDDEN,     /// Hide hidden files
-    ID_TOGGLE_HIDDEN,   /// Toggle display of hidden files
-    ID_TOGGLE_IMAGES,   /// Toggle display of images
-    ID_REFRESH,         /// Refresh immediately
-    ID_LAST
-    };
-public:
-
-  /// Construct a file list
-  FXFileList(FXComposite *p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Destroy server-side resources
-  virtual void destroy();
-
-  /// Scan the current directory and update the items if needed, or if force is TRUE
-  void scan(FXbool force=TRUE);
-
-  /// Set current file
-  void setCurrentFile(const FXString& file,FXbool notify=FALSE);
-
-  /// Return current file
-  FXString getCurrentFile() const;
-
-  /// Set current directory
-  void setDirectory(const FXString& path);
-
-  /// Return current directory
-  FXString getDirectory() const { return directory; }
-
-  /// Change wildcard matching pattern
-  void setPattern(const FXString& ptrn);
-
-  /// Return wildcard pattern
-  FXString getPattern() const { return pattern; }
-
-  /// Return TRUE if item is a directory
-  FXbool isItemDirectory(FXint index) const;
-
-  /// Return TRUE if item is a directory
-  FXbool isItemShare(FXint index) const;
-
-  /// Return TRUE if item is a file
-  FXbool isItemFile(FXint index) const;
-
-  /// Return TRUE if item is executable
-  FXbool isItemExecutable(FXint index) const;
-
-  /// Return name of item at index
-  FXString getItemFilename(FXint index) const;
-
-  /// Return full pathname of item at index
-  FXString getItemPathname(FXint index) const;
-
-  /// Return file association of item
-  FXFileAssoc* getItemAssoc(FXint index) const;
-
-  /// Return wildcard matching mode
-  FXuint getMatchMode() const { return matchmode; }
-
-  /// Change wildcard matching mode
-  void setMatchMode(FXuint mode);
-
-  /// Return TRUE if showing hidden files
-  FXbool showHiddenFiles() const;
-
-  /// Show or hide hidden files
-  void showHiddenFiles(FXbool showing);
-
-  /// Return TRUE if showing directories only
-  FXbool showOnlyDirectories() const;
-
-  /// Show directories only
-  void showOnlyDirectories(FXbool shown);
-
-  /// Return TRUE if showing files only
-  FXbool showOnlyFiles() const;
-
-  /// Show files only
-  void showOnlyFiles(FXbool shown);
-
-  /// Return TRUE if image preview on
-  FXbool showImages() const;
-
-  /// Show or hide preview images
-  void showImages(FXbool showing);
-
-  /// Return images preview size
-  FXint getImageSize() const { return imagesize; }
-
-  /// Change images preview size
-  void setImageSize(FXint size);
-
-  /// Return TRUE if showing parent directories
-  FXbool showParents() const;
-
-  /// Show parent directories
-  void showParents(FXbool shown);
-
-  /// Change file associations
-  void setAssociations(FXFileDict* assoc);
-
-  /// Return file associations
-  FXFileDict* getAssociations() const { return associations; }
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXFileList();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXFileSelector.h b/fox-includes/FXFileSelector.h
deleted file mode 100755
index de1dc84a..00000000
--- a/fox-includes/FXFileSelector.h
+++ /dev/null
@@ -1,308 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                  F i l e   S e l e c t i o n   W i d g e t                    *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXFileSelector.h 2342 2006-02-10 14:24:44Z lyle $                    *
-********************************************************************************/
-#ifndef FXFILESELECTOR_H
-#define FXFILESELECTOR_H
-
-#ifndef FXPACKER_H
-#include "FXPacker.h"
-#endif
-
-namespace FX {
-
-class FXFileList;
-class FXTextField;
-class FXComboBox;
-class FXDirBox;
-class FXButton;
-class FXMenuButton;
-class FXIcon;
-class FXMenuPane;
-class FXCheckButton;
-class FXMatrix;
-class FXHorizontalFrame;
-
-
-/// File selection modes
-enum {
-  SELECTFILE_ANY,             /// A single file, existing or not (to save to)
-  SELECTFILE_EXISTING,        /// An existing file (to load)
-  SELECTFILE_MULTIPLE,        /// Multiple existing files
-  SELECTFILE_MULTIPLE_ALL,    /// Multiple existing files or directories, but not '.' and '..'
-  SELECTFILE_DIRECTORY        /// Existing directory, including '.' or '..'
-  };
-
-
-/// File selection widget
-class FXAPI FXFileSelector : public FXPacker {
-  FXDECLARE(FXFileSelector)
-protected:
-  FXFileList        *filebox;           // File list widget
-  FXTextField       *filename;          // File name entry field
-  FXComboBox        *filefilter;        // Combobox for pattern list
-  FXMenuPane        *bookmarkmenu;      // Menu for bookmarks
-  FXHorizontalFrame *navbuttons;        // Navigation buttons
-  FXHorizontalFrame *fileboxframe;      // Frame around file list
-  FXMatrix          *entryblock;        // Entry block
-  FXCheckButton     *readonly;          // Open file as read only
-  FXDirBox          *dirbox;            // Directory hierarchy list
-  FXButton          *accept;            // Accept button
-  FXButton          *cancel;            // Cancel button
-  FXIcon            *updiricon;         // Up directory icon
-  FXIcon            *listicon;          // List mode icon
-  FXIcon            *detailicon;        // Detail mode icon
-  FXIcon            *iconsicon;         // Icon mode icon
-  FXIcon            *homeicon;          // Go home icon
-  FXIcon            *workicon;          // Go home icon
-  FXIcon            *shownicon;         // Files shown icon
-  FXIcon            *hiddenicon;        // Files hidden icon
-  FXIcon            *markicon;          // Book mark icon
-  FXIcon            *clearicon;         // Book clear icon
-  FXIcon            *newicon;           // New directory icon
-  FXIcon            *deleteicon;        // Delete file icon
-  FXIcon            *moveicon;          // Rename file icon
-  FXIcon            *copyicon;          // Copy file icon
-  FXIcon            *linkicon;          // Link file icon
-  FXRecentFiles      bookmarks;         // Bookmarked places
-  FXuint             selectmode;        // Select mode
-  FXbool             navigable;         // May navigate
-protected:
-  FXFileSelector(){}
-  FXString *getSelectedFiles() const;
-  FXString *getSelectedFilesOnly() const;
-private:
-  FXFileSelector(const FXFileSelector&);
-  FXFileSelector &operator=(const FXFileSelector&);
-public:
-  long onCmdAccept(FXObject*,FXSelector,void*);
-  long onCmdFilter(FXObject*,FXSelector,void*);
-  long onCmdItemDblClicked(FXObject*,FXSelector,void*);
-  long onCmdItemSelected(FXObject*,FXSelector,void*);
-  long onCmdItemDeselected(FXObject*,FXSelector,void*);
-  long onCmdDirectoryUp(FXObject*,FXSelector,void*);
-  long onUpdDirectoryUp(FXObject*,FXSelector,void*);
-  long onCmdDirTree(FXObject*,FXSelector,void*);
-  long onCmdHome(FXObject*,FXSelector,void*);
-  long onCmdWork(FXObject*,FXSelector,void*);
-  long onCmdBookmark(FXObject*,FXSelector,void*);
-  long onCmdVisit(FXObject*,FXSelector,void*);
-  long onCmdNew(FXObject*,FXSelector,void*);
-  long onUpdNew(FXObject*,FXSelector,void*);
-  long onCmdMove(FXObject*,FXSelector,void*);
-  long onCmdCopy(FXObject*,FXSelector,void*);
-  long onCmdLink(FXObject*,FXSelector,void*);
-  long onCmdDelete(FXObject*,FXSelector,void*);
-  long onUpdSelected(FXObject*,FXSelector,void*);
-  long onPopupMenu(FXObject*,FXSelector,void*);
-  long onCmdImageSize(FXObject*,FXSelector,void*);
-  long onUpdImageSize(FXObject*,FXSelector,void*);
-  long onUpdNavigable(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_FILEFILTER=FXPacker::ID_LAST,
-    ID_ACCEPT,
-    ID_FILELIST,
-    ID_DIRECTORY_UP,
-    ID_DIRTREE,
-    ID_NORMAL_SIZE,
-    ID_MEDIUM_SIZE,
-    ID_GIANT_SIZE,
-    ID_HOME,
-    ID_WORK,
-    ID_BOOKMARK,
-    ID_BOOKMENU,
-    ID_VISIT,
-    ID_NEW,
-    ID_DELETE,
-    ID_MOVE,
-    ID_COPY,
-    ID_LINK,
-    ID_LAST
-    };
-public:
-
-  /// Constructor
-  FXFileSelector(FXComposite *p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Return a pointer to the "Accept" button
-  FXButton *acceptButton() const { return accept; }
-
-  /// Return a pointer to the "Cancel" button
-  FXButton *cancelButton() const { return cancel; }
-
-  /// Change file name
-  void setFilename(const FXString& path);
-
-  /// Return file name, if any
-  FXString getFilename() const;
-
-  /**
-  * Return array of strings containing the selected file names, terminated
-  * by an empty string.  This string array must be freed using delete [].
-  * If no files were selected, a NULL is returned.
-  */
-  FXString* getFilenames() const;
-
-  /// Change file pattern
-  void setPattern(const FXString& ptrn);
-
-  /// Return file pattern
-  FXString getPattern() const;
-
-  /**
-  * Change the list of file patterns shown in the file dialog.
-  * Each pattern comprises an optional name, followed by a pattern in
-  * parentheses.  The patterns are separated by newlines.
-  * For example,
-  *
-  *  "*\n*.cpp,*.cc\n*.hpp,*.hh,*.h"
-  *
-  * and
-  *
-  *  "All Files (*)\nC++ Sources (*.cpp,*.cc)\nC++ Headers (*.hpp,*.hh,*.h)"
-  *
-  * will set the same three patterns, but the former shows no pattern names.
-  */
-  void setPatternList(const FXString& patterns);
-
-  /// Return list of patterns
-  FXString getPatternList() const;
-
-  /**
-  * After setting the list of patterns, this call will
-  * initially select pattern n as the active one.
-  */
-  void setCurrentPattern(FXint n);
-
-  /// Return current pattern number
-  FXint getCurrentPattern() const;
-
-  /// Get pattern text for given pattern number
-  FXString getPatternText(FXint patno) const;
-
-  /// Change pattern text for pattern number
-  void setPatternText(FXint patno,const FXString& text);
-
-  /// Return number of patterns
-  FXint getNumPatterns() const;
-
-  /// Allow pattern entry
-  void allowPatternEntry(FXbool allow);
-
-  /// Return TRUE if pattern entry is allowed
-  FXbool allowPatternEntry() const;
-
-  /**
-  * Given filename pattern of the form "GIF Format (*.gif)",
-  * returns the pattern only, i.e. "*.gif" in this case.
-  * If the parentheses are not found then returns the entire
-  * input pattern.
-  */
-  static FXString patternFromText(const FXString& pattern);
-
-  /**
-  * Given a pattern of the form "*.gif,*.GIF", return
-  * the first extension of the pattern, i.e. "gif" in this
-  * example. Returns empty string if it doesn't work out.
-  */
-  static FXString extensionFromPattern(const FXString& pattern);
-
-  /// Change directory
-  void setDirectory(const FXString& path);
-
-  /// Return directory
-  FXString getDirectory() const;
-
-  /// Set the inter-item spacing (in pixels)
-  void setItemSpace(FXint s);
-
-  /// Return the inter-item spacing (in pixels)
-  FXint getItemSpace() const;
-
-  /// Change file list style
-  void setFileBoxStyle(FXuint style);
-
-  /// Return file list style
-  FXuint getFileBoxStyle() const;
-
-  /// Change file selection mode
-  void setSelectMode(FXuint mode);
-
-  /// Return file selection mode
-  FXuint getSelectMode() const { return selectmode; }
-
-  /// Change wildcard matching mode
-  void setMatchMode(FXuint mode);
-
-  /// Return wildcard matching mode
-  FXuint getMatchMode() const;
-
-  /// Return TRUE if showing hidden files
-  FXbool showHiddenFiles() const;
-
-  /// Show or hide hidden files
-  void showHiddenFiles(FXbool showing);
-
-  /// Return TRUE if image preview on
-  FXbool showImages() const;
-
-  /// Show or hide preview images
-  void showImages(FXbool showing);
-
-  /// Return images preview size
-  FXint getImageSize() const;
-
-  /// Change images preview size
-  void setImageSize(FXint size);
-
-  /// Show readonly button
-  void showReadOnly(FXbool show);
-
-  /// Return TRUE if readonly is shown
-  FXbool shownReadOnly() const;
-
-  /// Set initial state of readonly button
-  void setReadOnly(FXbool state);
-
-  /// Get readonly state
-  FXbool getReadOnly() const;
-
-  /// Allow or disallow navigation
-  void allowNavigation(FXbool flag){ navigable=flag; }
-
-  /// Is navigation allowed?
-  FXbool allowNavigation() const { return navigable; }
-
-  /// Save object to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load object from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXFileSelector();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXFileStream.h b/fox-includes/FXFileStream.h
deleted file mode 100755
index 1124e954..00000000
--- a/fox-includes/FXFileStream.h
+++ /dev/null
@@ -1,121 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       F i l e   S t r e a m   C l a s s                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXFileStream.h 2336 2006-02-04 15:20:33Z lyle $                      *
-********************************************************************************/
-#ifndef FXFILESTREAM_H
-#define FXFILESTREAM_H
-
-#ifndef FXSTREAM_H
-#include "FXStream.h"
-#endif
-
-namespace FX {
-
-
-/// File Store Definition
-class FXAPI FXFileStream : public FXStream {
-protected:
-  FXFile file;
-protected:
-  virtual FXuval writeBuffer(FXuval count);
-  virtual FXuval readBuffer(FXuval count);
-public:
-
-  /// Create file store
-  FXFileStream(const FXObject* cont=NULL);
-
-  /**
-  * Open binary data file stream; allocate a buffer of the given size
-  * for the file I/O; the buffer must be at least 16 bytes.
-  */
-  bool open(const FXString& filename,FXStreamDirection save_or_load,FXuval size=8192);
-
-  /// Close file store
-  virtual bool close();
-
-  /// Get position
-  FXlong position() const { return FXStream::position(); }
-
-  /// Move to position
-  virtual bool position(FXlong offset,FXWhence whence=FXFromStart);
-
-  /// Save single items to stream
-  FXFileStream& operator<<(const FXuchar& v){ FXStream::operator<<(v); return *this; }
-  FXFileStream& operator<<(const FXchar& v){ FXStream::operator<<(v); return *this; }
-  FXFileStream& operator<<(const FXushort& v){ FXStream::operator<<(v); return *this; }
-  FXFileStream& operator<<(const FXshort& v){ FXStream::operator<<(v); return *this; }
-  FXFileStream& operator<<(const FXuint& v){ FXStream::operator<<(v); return *this; }
-  FXFileStream& operator<<(const FXint& v){ FXStream::operator<<(v); return *this; }
-  FXFileStream& operator<<(const FXfloat& v){ FXStream::operator<<(v); return *this; }
-  FXFileStream& operator<<(const FXdouble& v){ FXStream::operator<<(v); return *this; }
-  FXFileStream& operator<<(const FXlong& v){ FXStream::operator<<(v); return *this; }
-  FXFileStream& operator<<(const FXulong& v){ FXStream::operator<<(v); return *this; }
-
-  /// Save arrays of items to stream
-  FXFileStream& save(const FXuchar* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXFileStream& save(const FXchar* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXFileStream& save(const FXushort* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXFileStream& save(const FXshort* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXFileStream& save(const FXuint* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXFileStream& save(const FXint* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXFileStream& save(const FXfloat* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXFileStream& save(const FXdouble* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXFileStream& save(const FXlong* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXFileStream& save(const FXulong* p,FXuval n){ FXStream::save(p,n); return *this; }
-
-  /// Load single items from stream
-  FXFileStream& operator>>(FXuchar& v){ FXStream::operator>>(v); return *this; }
-  FXFileStream& operator>>(FXchar& v){ FXStream::operator>>(v); return *this; }
-  FXFileStream& operator>>(FXushort& v){ FXStream::operator>>(v); return *this; }
-  FXFileStream& operator>>(FXshort& v){ FXStream::operator>>(v); return *this; }
-  FXFileStream& operator>>(FXuint& v){ FXStream::operator>>(v); return *this; }
-  FXFileStream& operator>>(FXint& v){ FXStream::operator>>(v); return *this; }
-  FXFileStream& operator>>(FXfloat& v){ FXStream::operator>>(v); return *this; }
-  FXFileStream& operator>>(FXdouble& v){ FXStream::operator>>(v); return *this; }
-  FXFileStream& operator>>(FXlong& v){ FXStream::operator>>(v); return *this; }
-  FXFileStream& operator>>(FXulong& v){ FXStream::operator>>(v); return *this; }
-
-  /// Load arrays of items from stream
-  FXFileStream& load(FXuchar* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXFileStream& load(FXchar* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXFileStream& load(FXushort* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXFileStream& load(FXshort* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXFileStream& load(FXuint* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXFileStream& load(FXint* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXFileStream& load(FXfloat* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXFileStream& load(FXdouble* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXFileStream& load(FXlong* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXFileStream& load(FXulong* p,FXuval n){ FXStream::load(p,n); return *this; }
-
-  /// Save object
-  FXFileStream& saveObject(const FXObject* v){ FXStream::saveObject(v); return *this; }
-
-  /// Load object
-  FXFileStream& loadObject(FXObject*& v){ FXStream::loadObject(v); return *this; }
-
-  /// Destructor
-  virtual ~FXFileStream();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXFoldingList.h b/fox-includes/FXFoldingList.h
deleted file mode 100755
index ec06db3a..00000000
--- a/fox-includes/FXFoldingList.h
+++ /dev/null
@@ -1,653 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                    F o l d i n g   L i s t   W i d g e t                      *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXFoldingList.h 2336 2006-02-04 15:20:33Z lyle $                     *
-********************************************************************************/
-#ifndef FXFOLDINGLIST_H
-#define FXFOLDINGLIST_H
-
-#ifndef FXSCROLLAREA_H
-#include "FXScrollArea.h"
-#endif
-
-namespace FX {
-
-
-class FXIcon;
-class FXFont;
-class FXHeader;
-class FXFoldingList;
-
-
-/// Folding list styles
-enum {
-  FOLDINGLIST_EXTENDEDSELECT = 0,            /// Extended selection mode allows for drag-selection of ranges of items
-  FOLDINGLIST_SINGLESELECT   = 0x00100000,   /// Single selection mode allows up to one item to be selected
-  FOLDINGLIST_BROWSESELECT   = 0x00200000,   /// Browse selection mode enforces one single item to be selected at all times
-  FOLDINGLIST_MULTIPLESELECT = 0x00300000,   /// Multiple selection mode is used for selection of individual items
-  FOLDINGLIST_AUTOSELECT     = 0x00400000,   /// Automatically select under cursor
-  FOLDINGLIST_SHOWS_LINES    = 0x00800000,   /// Lines shown
-  FOLDINGLIST_SHOWS_BOXES    = 0x01000000,   /// Boxes to expand shown
-  FOLDINGLIST_ROOT_BOXES     = 0x02000000,   /// Display root boxes also
-  FOLDINGLIST_NORMAL         = FOLDINGLIST_EXTENDEDSELECT
-  };
-
-
-/// Tree list Item
-class FXAPI FXFoldingItem : public FXObject {
-  FXDECLARE(FXFoldingItem)
-  friend class FXFoldingList;
-  friend class FXDirList;
-protected:
-  FXFoldingItem *parent;
-  FXFoldingItem *prev;
-  FXFoldingItem *next;
-  FXFoldingItem *first;
-  FXFoldingItem *last;
-  FXString       label;
-  FXIcon        *openIcon;
-  FXIcon        *closedIcon;
-  void          *data;
-  FXuint         state;
-  FXint          x,y;
-private:
-  FXFoldingItem(const FXFoldingItem&);
-  FXFoldingItem& operator=(const FXFoldingItem&);
-protected:
-  FXFoldingItem():parent(NULL),prev(NULL),next(NULL),first(NULL),last(NULL),openIcon(NULL),closedIcon(NULL),data(NULL),state(0),x(0),y(0){}
-  virtual void draw(const FXFoldingList* list,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const;
-  virtual FXint hitItem(const FXFoldingList* list,FXint x,FXint y) const;
-public:
-  enum{
-    SELECTED        = 1,        /// Selected
-    FOCUS           = 2,        /// Focus
-    DISABLED        = 4,        /// Disabled
-    OPENED          = 8,        /// Opened
-    EXPANDED        = 16,       /// Expanded
-    HASITEMS        = 32,       /// Has virtual subitems
-    DRAGGABLE       = 64,       /// Draggable
-    OPENICONOWNED   = 128,      /// Open icon owned by item
-    CLOSEDICONOWNED = 256       /// Close icon owned by item
-    };
-public:
-
-  /// Constructor
-  FXFoldingItem(const FXString& text,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL):parent(NULL),prev(NULL),next(NULL),first(NULL),last(NULL),label(text),openIcon(oi),closedIcon(ci),data(ptr),state(0),x(0),y(0){}
-
-  /// Get parent item
-  FXFoldingItem* getParent() const { return parent; }
-
-  /// Get next sibling item
-  FXFoldingItem* getNext() const { return next; }
-
-  /// Get previous sibling item
-  FXFoldingItem* getPrev() const { return prev; }
-
-  /// Get first child item
-  FXFoldingItem* getFirst() const { return first; }
-
-  /// Get las child item
-  FXFoldingItem* getLast() const { return last; }
-
-  /// Get item below this one in list
-  FXFoldingItem* getBelow() const;
-
-  /// Get item above this one in list
-  FXFoldingItem* getAbove() const;
-
-  /// Get number of children of item
-  FXint getNumChildren() const;
-
-  /// Change item label
-  virtual void setText(const FXString& txt);
-
-  /// Get item label
-  const FXString& getText() const { return label; }
-
-  /// Change open icon, deleting old icon if it was owned
-  virtual void setOpenIcon(FXIcon* icn,FXbool owned=FALSE);
-
-  /// Get open icon
-  FXIcon* getOpenIcon() const { return openIcon; }
-
-  /// Change closed icon, deleting old icon if it was owned
-  virtual void setClosedIcon(FXIcon* icn,FXbool owned=FALSE);
-
-  /// Get closed icon
-  FXIcon* getClosedIcon() const { return closedIcon; }
-
-  /// Change item user data
-  void setData(void* ptr){ data=ptr; }
-
-  /// Get item user data
-  void* getData() const { return data; }
-
-  /// Make item draw as focused
-  virtual void setFocus(FXbool focus);
-
-  /// Return true if item has focus
-  FXbool hasFocus() const { return (state&FOCUS)!=0; }
-
-  /// Select item
-  virtual void setSelected(FXbool selected);
-
-  /// Return true if this item is selected
-  FXbool isSelected() const { return (state&SELECTED)!=0; }
-
-  /// Make item show as open
-  virtual void setOpened(FXbool opened);
-
-  /// Return true if this item is open
-  FXbool isOpened() const { return (state&OPENED)!=0; }
-
-  /// Expand or collapse item
-  virtual void setExpanded(FXbool expanded);
-
-  /// Return true if this item is expanded into sub items
-  FXbool isExpanded() const { return (state&EXPANDED)!=0; }
-
-  /// Enable or disable item
-  virtual void setEnabled(FXbool enabled);
-
-  /// Return true if this item is enabled
-  FXbool isEnabled() const { return (state&DISABLED)==0; }
-
-  /// Make item draggable
-  virtual void setDraggable(FXbool draggable);
-
-  /// Return true if this item is draggable
-  FXbool isDraggable() const { return (state&DRAGGABLE)!=0; }
-
-  /// Return TRUE if subitems, real or imagined
-  FXbool hasItems() const { return (state&HASITEMS)!=0; }
-
-  /// Change has items flag
-  void setHasItems(FXbool flag);
-
-  /// Return true if descendent of parent item
-  FXbool isChildOf(const FXFoldingItem* item) const;
-
-  /// Return true if ancestor of child item
-  FXbool isParentOf(const FXFoldingItem* item) const;
-
-  /// Return width of item as drawn in list
-  virtual FXint getWidth(const FXFoldingList* list) const;
-
-  /// Return height of item as drawn in list
-  virtual FXint getHeight(const FXFoldingList* list) const;
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Destroy server-side resources
-  virtual void destroy();
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destroy item and free icons if owned
-  virtual ~FXFoldingItem();
-  };
-
-
-
-/// Folding item collate function
-typedef FXint (*FXFoldingListSortFunc)(const FXFoldingItem*,const FXFoldingItem*);
-
-
-
-/**
-* A Folding List Widget resembles a Tree list except that it supports a
-* header control to provide each item with multiple columns of text.
-* Subtrees can be collapsed or expanded by double-clicking on an item
-* or by clicking on the optional plus button in front of the item.
-* Each item may have a text and optional open-icon as well as a closed-icon.
-* The items may be connected by optional lines to show the hierarchical
-* relationship.
-* When an item's selected state changes, the folding list emits a SEL_SELECTED
-* or SEL_DESELECTED message.  If an item is opened or closed, a message
-* of type SEL_OPENED or SEL_CLOSED is sent.  When the subtree under an
-* item is expanded, a SEL_EXPANDED or SEL_COLLAPSED message is issued.
-* A change of the current item is signified by the SEL_CHANGED message.
-* In addition, the folding list sends SEL_COMMAND messages when the user
-* clicks on an item, and SEL_CLICKED, SEL_DOUBLECLICKED, and SEL_TRIPLECLICKED
-* when the user clicks once, twice, or thrice, respectively.
-* When items are added or removed, the folding list sends messages of the
-* type SEL_INSERTED or SEL_DELETED.
-* In each of these cases, a pointer to the item, if any, is passed in the
-* 3rd argument of the message.
-*/
-class FXAPI FXFoldingList : public FXScrollArea {
-  FXDECLARE(FXFoldingList)
-protected:
-  FXHeader          *header;            // Tree header
-  FXFoldingItem     *firstitem;         // First root item
-  FXFoldingItem     *lastitem;          // Last root item
-  FXFoldingItem     *anchoritem;        // Selection anchor item
-  FXFoldingItem     *currentitem;       // Current item
-  FXFoldingItem     *extentitem;        // Selection extent
-  FXFoldingItem     *cursoritem;        // Item under cursor
-  FXFoldingItem     *viewableitem;      // Viewable item
-  FXFont            *font;              // Font
-  FXFoldingListSortFunc sortfunc;       // Item sort function
-  FXColor            textColor;         // Text color
-  FXColor            selbackColor;      // Selected background color
-  FXColor            seltextColor;      // Selected text color
-  FXColor            lineColor;         // Line color
-  FXint              treeWidth;         // Tree width
-  FXint              treeHeight;        // Tree height
-  FXint              visible;           // Number of visible items
-  FXint              indent;            // Parent to child indentation
-  FXint              grabx;             // Grab point x
-  FXint              graby;             // Grab point y
-  FXString           lookup;            // Lookup string
-  FXString           help;              // Help string
-  FXbool             state;             // State of item
-protected:
-  FXFoldingList();
-  void recompute();
-  void mergesort(FXFoldingItem*& list);
-  void sort(FXFoldingItem*& f1,FXFoldingItem*& t1,FXFoldingItem*& f2,FXFoldingItem*& t2,int n);
-  virtual void moveContents(FXint x,FXint y);
-  virtual FXFoldingItem* createItem(const FXString& text,FXIcon* oi,FXIcon* ci,void* ptr);
-  static FXint compareSection(const FXchar *p,const FXchar* q,FXint s);
-  static FXint compareSectionCase(const FXchar *p,const FXchar* q,FXint s);
-private:
-  FXFoldingList(const FXFoldingList&);
-  FXFoldingList& operator=(const FXFoldingList&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onEnter(FXObject*,FXSelector,void*);
-  long onLeave(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onRightBtnPress(FXObject*,FXSelector,void*);
-  long onRightBtnRelease(FXObject*,FXSelector,void*);
-  long onHeaderChanged(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onTipTimer(FXObject*,FXSelector,void*);
-  long onFocusIn(FXObject*,FXSelector,void*);
-  long onFocusOut(FXObject*,FXSelector,void*);
-  long onAutoScroll(FXObject*,FXSelector,void*);
-  long onClicked(FXObject*,FXSelector,void*);
-  long onDoubleClicked(FXObject*,FXSelector,void*);
-  long onTripleClicked(FXObject*,FXSelector,void*);
-  long onCommand(FXObject*,FXSelector,void*);
-  long onLookupTimer(FXObject*,FXSelector,void*);
-public:
-  static FXint ascending(const FXFoldingItem*,const FXFoldingItem*);
-  static FXint descending(const FXFoldingItem*,const FXFoldingItem*);
-  static FXint ascendingCase(const FXFoldingItem*,const FXFoldingItem*);
-  static FXint descendingCase(const FXFoldingItem*,const FXFoldingItem*);
-public:
-  enum {
-    ID_LOOKUPTIMER=FXScrollArea::ID_LAST,
-    ID_HEADER_CHANGE,
-    ID_LAST
-    };
-public:
-
-  /// Construct a folding list; the folding list is initially empty
-  FXFoldingList(FXComposite *p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=FOLDINGLIST_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Compute and return content width
-  virtual FXint getContentWidth();
-
-  /// Return content height
-  virtual FXint getContentHeight();
-
-  /// Recalculate layout
-  virtual void recalc();
-
-  /// Tree list can receive focus
-  virtual bool canFocus() const;
-
-  /// Move the focus to this window
-  virtual void setFocus();
-
-  /// Remove the focus from this window
-  virtual void killFocus();
-
-  /// Return header control
-  FXHeader* getHeader() const { return header; }
-
-  /// Set headers from array of strings
-  void setHeaders(const FXchar** strings,FXint size=1);
-
-  /// Set headers from newline separated strings
-  void setHeaders(const FXString& strings,FXint size=1);
-
-  /// Append header with given text and optional icon
-  void appendHeader(const FXString& text,FXIcon *icon=NULL,FXint size=1);
-
-  /// Remove header at index
-  void removeHeader(FXint index);
-
-  /// Change text of header at index
-  void setHeaderText(FXint index,const FXString& text);
-
-  /// Return text of header at index
-  FXString getHeaderText(FXint index) const;
-
-  /// Change icon of header at index
-  void setHeaderIcon(FXint index,FXIcon *icon);
-
-  /// Return icon of header at index
-  FXIcon* getHeaderIcon(FXint index) const;
-
-  /// Change size of header at index
-  void setHeaderSize(FXint index,FXint size);
-
-  /// Return width of header at index
-  FXint getHeaderSize(FXint index) const;
-
-  /// Return number of headers
-  FXint getNumHeaders() const;
-
-  /// Return number of items
-  FXint getNumItems() const;
-
-  /// Return number of visible items
-  FXint getNumVisible() const { return visible; }
-
-  /// Change number of visible items
-  void setNumVisible(FXint nvis);
-
-  /// Return first root item
-  FXFoldingItem* getFirstItem() const { return firstitem; }
-
-  /// Return last root item
-  FXFoldingItem* getLastItem() const { return lastitem; }
-
-  /// Fill list by appending items from array of strings
-  FXint fillItems(FXFoldingItem* father,const FXchar** strings,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Fill list by appending items from newline separated strings
-  FXint fillItems(FXFoldingItem* father,const FXString& strings,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Insert [possibly subclassed] item under father before other item
-  FXFoldingItem* insertItem(FXFoldingItem* other,FXFoldingItem* father,FXFoldingItem* item,FXbool notify=FALSE);
-
-  /// Insert item with given text and optional icons, and user-data pointer under father before other item
-  FXFoldingItem* insertItem(FXFoldingItem* other,FXFoldingItem* father,const FXString& text,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Append [possibly subclassed] item as last child of father
-  FXFoldingItem* appendItem(FXFoldingItem* father,FXFoldingItem* item,FXbool notify=FALSE);
-
-  /// Append item with given text and optional icons, and user-data pointer as last child of father
-  FXFoldingItem* appendItem(FXFoldingItem* father,const FXString& text,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Prepend [possibly subclassed] item as first child of father
-  FXFoldingItem* prependItem(FXFoldingItem* father,FXFoldingItem* item,FXbool notify=FALSE);
-
-  /// Prepend item with given text and optional icons, and user-data pointer as first child of father
-  FXFoldingItem* prependItem(FXFoldingItem* father,const FXString& text,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Move item under father before other item
-  FXFoldingItem *moveItem(FXFoldingItem* other,FXFoldingItem* father,FXFoldingItem* item);
-
-  /// Extract item
-  FXFoldingItem* extractItem(FXFoldingItem* item,FXbool notify=FALSE);
-
-  /// Remove item
-  void removeItem(FXFoldingItem* item,FXbool notify=FALSE);
-
-  /// Remove items in range [fm, to] inclusively
-  void removeItems(FXFoldingItem* fm,FXFoldingItem* to,FXbool notify=FALSE);
-
-  /// Remove all items from list
-  void clearItems(FXbool notify=FALSE);
-
-  /// Return item width
-  FXint getItemWidth(const FXFoldingItem* item) const { return item->getWidth(this); }
-
-  /// Return item height
-  FXint getItemHeight(const FXFoldingItem* item) const { return item->getHeight(this); }
-
-  /// Get item at x,y, if any
-  virtual FXFoldingItem* getItemAt(FXint x,FXint y) const;
-
-  /**
-  * Search items by name, beginning from item start.  If the start item
-  * is NULL the search will start at the first, top-most item in the list.
-  * Flags may be SEARCH_FORWARD or SEARCH_BACKWARD to control the search
-  * direction; this can be combined with SEARCH_NOWRAP or SEARCH_WRAP
-  * to control whether the search wraps at the start or end of the list.
-  * The option SEARCH_IGNORECASE causes a case-insensitive match.  Finally,
-  * passing SEARCH_PREFIX causes searching for a prefix of the item name.
-  * Return NULL if no matching item is found.
-  */
-  FXFoldingItem* findItem(const FXString& text,FXFoldingItem* start=NULL,FXuint flags=SEARCH_FORWARD|SEARCH_WRAP) const;
-
-  /**
-  * Search items by associated user data, beginning from item start. If the
-  * start item is NULL the search will start at the first, top-most item
-  * in the list.  Flags may be SEARCH_FORWARD or SEARCH_BACKWARD to control
-  * the search direction; this can be combined with SEARCH_NOWRAP or SEARCH_WRAP
-  * to control whether the search wraps at the start or end of the list.
-  */
-  FXFoldingItem* findItemByData(const void *ptr,FXFoldingItem* start=NULL,FXuint flags=SEARCH_FORWARD|SEARCH_WRAP) const;
-
-  /// Scroll to make item visible
-  virtual void makeItemVisible(FXFoldingItem* item);
-
-  /// Change item's text
-  void setItemText(FXFoldingItem* item,const FXString& text);
-
-  /// Return item's text
-  FXString getItemText(const FXFoldingItem* item) const;
-
-  /// Change item's open icon, deleting old icon if it was owned
-  void setItemOpenIcon(FXFoldingItem* item,FXIcon* icon,FXbool owned=FALSE);
-
-  /// Return item's open icon
-  FXIcon* getItemOpenIcon(const FXFoldingItem* item) const;
-
-  /// Chance item's closed icon, deleting old icon if it was owned
-  void setItemClosedIcon(FXFoldingItem* item,FXIcon* icon,FXbool owned=FALSE);
-
-  /// Return item's closed icon
-  FXIcon* getItemClosedIcon(const FXFoldingItem* item) const;
-
-  /// Change item user-data pointer
-  void setItemData(FXFoldingItem* item,void* ptr) const;
-
-  /// Return item user-data pointer
-  void* getItemData(const FXFoldingItem* item) const;
-
-  /// Return TRUE if item is selected
-  FXbool isItemSelected(const FXFoldingItem* item) const;
-
-  /// Return TRUE if item is current
-  FXbool isItemCurrent(const FXFoldingItem* item) const;
-
-  /// Return TRUE if item is visible
-  FXbool isItemVisible(const FXFoldingItem* item) const;
-
-  /// Return TRUE if item opened
-  FXbool isItemOpened(const FXFoldingItem* item) const;
-
-  /// Return TRUE if item expanded
-  FXbool isItemExpanded(const FXFoldingItem* item) const;
-
-  /// Return TRUE if item is a leaf-item, i.e. has no children
-  FXbool isItemLeaf(const FXFoldingItem* item) const;
-
-  /// Return TRUE if item is enabled
-  FXbool isItemEnabled(const FXFoldingItem* item) const;
-
-  /// Return item hit code: 0 outside, 1 icon, 2 text, 3 box
-  FXint hitItem(const FXFoldingItem* item,FXint x,FXint y) const;
-
-  /// Repaint item
-  void updateItem(FXFoldingItem* item);
-
-  /// Enable item
-  virtual FXbool enableItem(FXFoldingItem* item);
-
-  /// Disable item
-  virtual FXbool disableItem(FXFoldingItem* item);
-
-  /// Select item
-  virtual FXbool selectItem(FXFoldingItem* item,FXbool notify=FALSE);
-
-  /// Deselect item
-  virtual FXbool deselectItem(FXFoldingItem* item,FXbool notify=FALSE);
-
-  /// Toggle item selection
-  virtual FXbool toggleItem(FXFoldingItem* item,FXbool notify=FALSE);
-
-  /// Extend selection from anchor item to item
-  virtual FXbool extendSelection(FXFoldingItem* item,FXbool notify=FALSE);
-
-  /// Deselect all items
-  virtual FXbool killSelection(FXbool notify=FALSE);
-
-  /// Open item
-  virtual FXbool openItem(FXFoldingItem* item,FXbool notify=FALSE);
-
-  /// Close item
-  virtual FXbool closeItem(FXFoldingItem* item,FXbool notify=FALSE);
-
-  /// Collapse tree
-  virtual FXbool collapseTree(FXFoldingItem* tree,FXbool notify=FALSE);
-
-  /// Expand tree
-  virtual FXbool expandTree(FXFoldingItem* tree,FXbool notify=FALSE);
-
-  /// Change current item
-  virtual void setCurrentItem(FXFoldingItem* item,FXbool notify=FALSE);
-
-  /// Return current item, if any
-  FXFoldingItem* getCurrentItem() const { return currentitem; }
-
-  /// Change anchor item
-  void setAnchorItem(FXFoldingItem* item);
-
-  /// Return anchor item, if any
-  FXFoldingItem* getAnchorItem() const { return anchoritem; }
-
-  /// Return item under cursor, if any
-  FXFoldingItem* getCursorItem() const { return cursoritem; }
-
-  /// Sort all items recursively
-  void sortItems();
-
-  /// Sort root items
-  void sortRootItems();
-
-  /// Sort children of item
-  void sortChildItems(FXFoldingItem* item);
-
-  /// Return sort function
-  FXFoldingListSortFunc getSortFunc() const { return sortfunc; }
-
-  /// Change sort function
-  void setSortFunc(FXFoldingListSortFunc func){ sortfunc=func; }
-
-  /// Change text font
-  void setFont(FXFont* fnt);
-
-  /// Return text font
-  FXFont* getFont() const { return font; }
-
-  /// Change parent-child indent amount
-  void setIndent(FXint in);
-
-  /// Return parent-child indent amount
-  FXint getIndent() const { return indent; }
-
-  /// Return normal text color
-  FXColor getTextColor() const { return textColor; }
-
-  /// Change normal text color
-  void setTextColor(FXColor clr);
-
-  /// Return selected text background
-  FXColor getSelBackColor() const { return selbackColor; }
-
-  /// Change selected text background
-  void setSelBackColor(FXColor clr);
-
-  /// Return selected text color
-  FXColor getSelTextColor() const { return seltextColor; }
-
-  /// Change selected text color
-  void setSelTextColor(FXColor clr);
-
-  /// Return line color
-  FXColor getLineColor() const { return lineColor; }
-
-  /// Change line color
-  void setLineColor(FXColor clr);
-
-  /// Return list style
-  FXuint getListStyle() const;
-
-  /// Change list style
-  void setListStyle(FXuint style);
-
-  /// Set the status line help text for this list
-  void setHelpText(const FXString& text);
-
-  /// Get the status line help text for this list
-  const FXString& getHelpText() const { return help; }
-
-  /// Save object to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load object from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXFoldingList();
-  };
-
-}
-
-
-#endif
diff --git a/fox-includes/FXFont.h b/fox-includes/FXFont.h
deleted file mode 100755
index cd1382d6..00000000
--- a/fox-includes/FXFont.h
+++ /dev/null
@@ -1,404 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                               F o n t   O b j e c t                           *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXFont.h 2199 2005-09-01 00:02:05Z lyle $                            *
-********************************************************************************/
-#ifndef FXFONT_H
-#define FXFONT_H
-
-#ifndef FXID_H
-#include "FXId.h"
-#endif
-
-namespace FX {
-
-
-/// Font character set encoding
-enum FXFontEncoding {
-  FONTENCODING_DEFAULT,         /// Don't care character encoding
-
-  FONTENCODING_ISO_8859_1   = 1,        /// West European (Latin1)
-  FONTENCODING_ISO_8859_2   = 2,        /// Central and East European (Latin2)
-  FONTENCODING_ISO_8859_3   = 3,        /// Esperanto (Latin3)
-  FONTENCODING_ISO_8859_4   = 4,
-  FONTENCODING_ISO_8859_5   = 5,        /// Cyrillic (almost obsolete)
-  FONTENCODING_ISO_8859_6   = 6,        /// Arabic
-  FONTENCODING_ISO_8859_7   = 7,        /// Greek
-  FONTENCODING_ISO_8859_8   = 8,        /// Hebrew
-  FONTENCODING_ISO_8859_9   = 9,        /// Turkish (Latin5)
-  FONTENCODING_ISO_8859_10  = 10,
-  FONTENCODING_ISO_8859_11  = 11,       /// Thai
-  FONTENCODING_ISO_8859_13  = 13,       /// Baltic
-  FONTENCODING_ISO_8859_14  = 14,
-  FONTENCODING_ISO_8859_15  = 15,
-  FONTENCODING_ISO_8859_16  = 16,
-  FONTENCODING_KOI8         = 17,
-  FONTENCODING_KOI8_R       = 18,       /// Russian
-  FONTENCODING_KOI8_U       = 19,       /// Ukrainian
-  FONTENCODING_KOI8_UNIFIED = 20,
-
-  FONTENCODING_CP437        = 437,      /// IBM-PC code page
-  FONTENCODING_CP850        = 850,      /// IBMPC Multilingual
-  FONTENCODING_CP851        = 851,      /// IBM-PC Greek
-  FONTENCODING_CP852        = 852,      /// IBM-PC Latin2
-  FONTENCODING_CP855        = 855,      /// IBM-PC Cyrillic
-  FONTENCODING_CP856        = 856,      /// IBM-PC Hebrew
-  FONTENCODING_CP857        = 857,      /// IBM-PC Turkish
-  FONTENCODING_CP860        = 860,      /// IBM-PC Portugese
-  FONTENCODING_CP861        = 861,      /// IBM-PC Iceland
-  FONTENCODING_CP862        = 862,      /// IBM-PC Israel
-  FONTENCODING_CP863        = 863,      /// IBM-PC Canadian/French
-  FONTENCODING_CP864        = 864,      /// IBM-PC Arabic
-  FONTENCODING_CP865        = 865,      /// IBM-PC Nordic
-  FONTENCODING_CP866        = 866,      /// IBM-PC Cyrillic #2
-  FONTENCODING_CP869        = 869,      /// IBM-PC Greek #2
-  FONTENCODING_CP870        = 870,      /// Latin-2 Multilingual
-
-  FONTENCODING_CP1250       = 1250,     /// Windows Central European
-  FONTENCODING_CP1251       = 1251,     /// Windows Russian
-  FONTENCODING_CP1252       = 1252,     /// Windows Latin1
-  FONTENCODING_CP1253       = 1253,     /// Windows Greek
-  FONTENCODING_CP1254       = 1254,     /// Windows Turkish
-  FONTENCODING_CP1255       = 1255,     /// Windows Hebrew
-  FONTENCODING_CP1256       = 1256,     /// Windows Arabic
-  FONTENCODING_CP1257       = 1257,     /// Windows Baltic
-  FONTENCODING_CP1258       = 1258,     /// Windows Vietnam
-  FONTENCODING_CP874        = 874,      /// Windows Thai
-
-  FONTENCODING_UNICODE      = 9999,
-
-  FONTENCODING_LATIN1       = FONTENCODING_ISO_8859_1,   /// Latin 1 (West European)
-  FONTENCODING_LATIN2       = FONTENCODING_ISO_8859_2,   /// Latin 2 (East European)
-  FONTENCODING_LATIN3       = FONTENCODING_ISO_8859_3,   /// Latin 3 (South European)
-  FONTENCODING_LATIN4       = FONTENCODING_ISO_8859_4,   /// Latin 4 (North European)
-  FONTENCODING_LATIN5       = FONTENCODING_ISO_8859_9,   /// Latin 5 (Turkish)
-  FONTENCODING_LATIN6       = FONTENCODING_ISO_8859_10,  /// Latin 6 (Nordic)
-  FONTENCODING_LATIN7       = FONTENCODING_ISO_8859_13,  /// Latin 7 (Baltic Rim)
-  FONTENCODING_LATIN8       = FONTENCODING_ISO_8859_14,  /// Latin 8 (Celtic)
-  FONTENCODING_LATIN9       = FONTENCODING_ISO_8859_15,  /// Latin 9 AKA Latin 0
-  FONTENCODING_LATIN10      = FONTENCODING_ISO_8859_16,  /// Latin 10
-
-  FONTENCODING_USASCII      = FONTENCODING_ISO_8859_1,   /// Latin 1
-  FONTENCODING_WESTEUROPE   = FONTENCODING_ISO_8859_1,   /// Latin 1 (West European)
-  FONTENCODING_EASTEUROPE   = FONTENCODING_ISO_8859_2,   /// Latin 2 (East European)
-  FONTENCODING_SOUTHEUROPE  = FONTENCODING_ISO_8859_3,   /// Latin 3 (South European)
-  FONTENCODING_NORTHEUROPE  = FONTENCODING_ISO_8859_4,   /// Latin 4 (North European)
-  FONTENCODING_CYRILLIC     = FONTENCODING_ISO_8859_5,   /// Cyrillic
-  FONTENCODING_RUSSIAN      = FONTENCODING_KOI8,         /// Cyrillic
-  FONTENCODING_ARABIC       = FONTENCODING_ISO_8859_6,   /// Arabic
-  FONTENCODING_GREEK        = FONTENCODING_ISO_8859_7,   /// Greek
-  FONTENCODING_HEBREW       = FONTENCODING_ISO_8859_8,   /// Hebrew
-  FONTENCODING_TURKISH      = FONTENCODING_ISO_8859_9,   /// Latin 5 (Turkish)
-  FONTENCODING_NORDIC       = FONTENCODING_ISO_8859_10,  /// Latin 6 (Nordic)
-  FONTENCODING_THAI         = FONTENCODING_ISO_8859_11,  /// Thai
-  FONTENCODING_BALTIC       = FONTENCODING_ISO_8859_13,  /// Latin 7 (Baltic Rim)
-  FONTENCODING_CELTIC       = FONTENCODING_ISO_8859_14   /// Latin 8 (Celtic)
-  };
-
-
-/// Font style
-struct FXFontDesc {
-  FXchar          face[116];                /// Face name
-  FXushort        size;                     /// Size in deci-points
-  FXushort        weight;                   /// Weight [light, normal, bold, ...]
-  FXushort        slant;                    /// Slant [normal, italic, oblique, ...]
-  FXushort        setwidth;                 /// Set width [normal, condensed, expanded, ...]
-  FXushort        encoding;                 /// Encoding of character set
-  FXushort        flags;                    /// Flags
-  };
-
-
-class FXDC;
-class FXDCWindow;
-
-
-/// Font class
-class FXAPI FXFont : public FXId {
-  friend class FXDCWindow;
-  FXDECLARE(FXFont)
-protected:
-  FXString  wantedName;         // Desired font font name
-  FXString  actualName;         // Matched font font name
-  FXushort  wantedSize;         // Font size (points*10)
-  FXushort  actualSize;         // Actual size that was matched
-  FXushort  wantedWeight;       // Font weight
-  FXushort  actualWeight;       // Font weight
-  FXushort  wantedSlant;        // Font slant
-  FXushort  actualSlant;        // Font slant
-  FXushort  wantedSetwidth;     // Relative setwidth
-  FXushort  actualSetwidth;     // Relative setwidth
-  FXushort  wantedEncoding;     // Character set encoding
-  FXushort  actualEncoding;     // Character set encoding
-  FXushort  hints;              // Matching hint flags
-  FXushort  flags;              // Actual flags
-  FXshort   angle;              // Angle
-  void     *font;               // Info about the font
-private:
-#ifdef WIN32
-  FXID      dc;
-#endif
-protected:
-  FXFont();
-  void* match(const FXString& wantfamily,const FXString& wantforge,FXuint wantsize,FXuint wantweight,FXuint wantslant,FXuint wantsetwidth,FXuint wantencoding,FXuint wanthints,FXint res);
-private:
-  FXFont(const FXFont&);
-  FXFont &operator=(const FXFont&);
-public:
-
-  /// Font pitch hints
-  enum {
-    Fixed          = 1,         /// Fixed pitch, mono-spaced
-    Variable       = 2          /// Variable pitch, proportional spacing
-    };
-
-  /// Font style hints
-  enum {
-    Decorative     = 4,         /// Fancy fonts
-    Modern         = 8,         /// Monospace typewriter font
-    Roman          = 16,        /// Variable width times-like font, serif
-    Script         = 32,        /// Script or cursive
-    Swiss          = 64,        /// Helvetica/swiss type font, sans-serif
-    System         = 128,       /// System font
-    X11            = 256,       /// Raw X11 font string
-    Scalable       = 512,       /// Scalable fonts
-    Polymorphic    = 1024,      /// Polymorphic fonts, e.g. parametric weight, slant, etc.
-    Rotatable      = 2048       /// Rotatable fonts
-    };
-
-  /// Font slant options
-  enum {
-    ReverseOblique = 1,         /// Reversed oblique
-    ReverseItalic  = 2,         /// Reversed italic
-    Straight       = 5,         /// Straight, not slanted
-    Italic         = 8,         /// Italics
-    Oblique        = 9          /// Oblique slant
-    };
-
-  /// Font weight options
-  enum {
-    Thin           = 10,        /// Thin
-    ExtraLight     = 20,        /// Extra light
-    Light          = 30,        /// Light
-    Normal         = 40,        /// Normal or regular weight
-    Medium         = 50,        /// Medium bold face
-    DemiBold       = 60,        /// Demi bold face
-    Bold           = 70,        /// Bold face
-    ExtraBold      = 80,        /// Extra
-    Black          = 90         /// Black
-    };
-
-  /// Condensed or expanded options
-  enum {
-    UltraCondensed = 50,        /// Ultra condensed printing
-    ExtraCondensed = 63,        /// Extra condensed
-    Condensed      = 75,        /// Condensed
-    SemiCondensed  = 87,        /// Semi-condensed
-    NonExpanded    = 100,       /// Regular printing
-    SemiExpanded   = 113,       /// Semi expanded
-    Expanded       = 125,       /// Expanded
-    ExtraExpanded  = 150,       /// Extra expanded
-    UltraExpanded  = 200        /// Ultra expanded
-    };
-
-public:
-
-  /**
-  * Construct a font with given font description of the form:
-  *
-  *     fontname [ "[" foundry "]" ] ["," size ["," weight ["," slant ["," setwidth ["," encoding ["," hints]]]]]]
-  *
-  * For example:
-  *
-  *     "helvetica [bitstream],120,bold,italic,normal,iso8859-1,0"
-  *
-  * Typically, at least the font name, and size must be given for
-  * normal font matching.  As a special case, raw X11 fonts can also be
-  * passed, for example:
-  *
-  *     "9x15bold"
-  *
-  * Note: use of the raw X11 fonts is stronly discouraged.
-  */
-  FXFont(FXApp* a,const FXString& string);
-
-  /**
-  * Construct a font with given name, size in points, weight, slant, character set
-  * encoding, setwidth, and hints.
-  * The font name may be comprised of a family name and optional foundry name enclosed in
-  * square brackets, for example, "helvetica [bitstream]".
-  */
-  FXFont(FXApp* a,const FXString& face,FXuint size,FXuint weight=FXFont::Normal,FXuint slant=FXFont::Straight,FXuint encoding=FONTENCODING_DEFAULT,FXuint setwidth=FXFont::NonExpanded,FXuint h=0);
-
-  /// Construct font from font description
-  FXFont(FXApp* a,const FXFontDesc& fontdesc);
-
-  /// Create the font
-  virtual void create();
-
-  /// Detach the font
-  virtual void detach();
-
-  /// Destroy the font
-  virtual void destroy();
-
-  /// Return family part of name
-  FXString getFamily() const;
-
-  /// Return foundry part of name
-  FXString getFoundry() const;
-
-  /// Get font family name
-  const FXString& getName() const { return wantedName; }
-
-  /// Get actual family name
-  const FXString& getActualName() const { return actualName; }
-
-  /// Get size in deci-points
-  FXuint getSize() const { return wantedSize; }
-
-  /// Get actual size in deci-points
-  FXuint getActualSize() const { return actualSize; }
-
-  /// Get font weight
-  FXuint getWeight() const { return wantedWeight; }
-
-  /// Get actual font weight
-  FXuint getActualWeight() const { return actualWeight; }
-
-  /// Get slant
-  FXuint getSlant() const { return wantedSlant; }
-
-  /// Get actual slant
-  FXuint getActualSlant() const { return actualSlant; }
-
-  /// Get character set encoding
-  FXuint getEncoding() const { return wantedEncoding; }
-
-  /// Get actual encoding
-  FXuint getActualEncoding() const { return actualEncoding; }
-
-  /// Get setwidth
-  FXuint getSetWidth() const { return wantedSetwidth; }
-
-  /// Get actual setwidth
-  FXuint getActualSetWidth() const { return actualSetwidth; }
-
-  /// Get hints
-  FXuint getHints() const { return hints; }
-
-  /// Get flags
-  FXuint getFlags() const { return flags; }
-
-  /// Get font description
-  void getFontDesc(FXFontDesc& fontdesc) const;
-
-  /// Change font description
-  virtual void setFontDesc(const FXFontDesc& fontdesc);
-
-  /// Return angle
-  FXint getAngle() const { return angle; }
-
-  /// Set to new angle, in degrees*64 relative to positive x axis
-  virtual void setAngle(FXint ang);
-
-  /**
-  * Return the font description as a string suitable for
-  * parsing with setFont(), see above.
-  */
-  FXString getFont() const;
-
-  /**
-  * Change the font to the specified font description string.
-  */
-  virtual void setFont(const FXString& string);
-
-  /// Find out if the font is monotype or proportional
-  virtual FXbool isFontMono() const;
-
-  /// See if font has glyph for ch
-  virtual FXbool hasChar(FXwchar ch) const;
-
-  /// Get first character glyph in font
-  virtual FXwchar getMinChar() const;
-
-  /// Get last character glyph in font
-  virtual FXwchar getMaxChar() const;
-
-  /// Left bearing
-  virtual FXint leftBearing(FXwchar ch) const;
-
-  /// Right bearing
-  virtual FXint rightBearing(FXwchar ch) const;
-
-  /// Width of widest character in font
-  virtual FXint getFontWidth() const;
-
-  /// Height of highest character in font
-  virtual FXint getFontHeight() const;
-
-  /// Ascent from baseline
-  virtual FXint getFontAscent() const;
-
-  /// Descent from baseline
-  virtual FXint getFontDescent() const;
-
-  /// Get font leading [that is lead-ing as in Pb!]
-  virtual FXint getFontLeading() const;
-
-  /// Get font line spacing
-  virtual FXint getFontSpacing() const;
-
-  /// Calculate width of single wide character in this font
-  virtual FXint getCharWidth(const FXwchar ch) const;
-
-  /// Calculate width of given text in this font
-  virtual FXint getTextWidth(const FXString& string) const;
-
-  /// Calculate width of given text in this font
-  virtual FXint getTextWidth(const FXchar* string,FXuint length) const;
-
-  /// Calculate height of given text in this font
-  virtual FXint getTextHeight(const FXString& string) const;
-
-  /// Calculate height of given text in this font
-  virtual FXint getTextHeight(const FXchar *string,FXuint length) const;
-
-  /**
-  * List all fonts matching hints. If listFonts() returns TRUE then
-  * fonts points to a newly-allocated array of length numfonts. It
-  * is the caller's responsibility to free this array using FXFREE().
-  */
-  static FXbool listFonts(FXFontDesc*& fonts,FXuint& numfonts,const FXString& face,FXuint wt=0,FXuint sl=0,FXuint sw=0,FXuint en=0,FXuint h=0);
-
-  /// Save font data into stream
-  virtual void save(FXStream& store) const;
-
-  /// Load font data from stream
-  virtual void load(FXStream& store);
-
-  /// Destroy font
-  virtual ~FXFont();
-  };
-
-
-}
-
-#endif
diff --git a/fox-includes/FXFontDialog.h b/fox-includes/FXFontDialog.h
deleted file mode 100755
index f6fe01fc..00000000
--- a/fox-includes/FXFontDialog.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                    F o n t   S e l e c t i o n   D i a l o g                  *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1999,2002 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXFontDialog.h 809 2002-07-11 17:28:15Z lyle $                       *
-********************************************************************************/
-#ifndef FXFONTDIALOG_H
-#define FXFONTDIALOG_H
-
-#ifndef FXDIALOGBOX_H
-#include "FXDialogBox.h"
-#endif
-
-namespace FX {
-
-
-class FXFontSelector;
-
-
-/// Font selection dialog
-class FXAPI FXFontDialog : public FXDialogBox {
-  FXDECLARE(FXFontDialog)
-protected:
-  FXFontSelector *fontbox;
-protected:
-  FXFontDialog(){}
-private:
-  FXFontDialog(const FXFontDialog&);
-  FXFontDialog &operator=(const FXFontDialog&);
-public:
-  /// Constructor
-  FXFontDialog(FXWindow* owner,const FXString& name,FXuint opts=0,FXint x=0,FXint y=0,FXint w=600,FXint h=380);
-
-  /// Save dialog to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load dialog from a stream
-  virtual void load(FXStream& store);
-
-  /// Set the current font selection
-  void setFontSelection(const FXFontDesc& fontdesc);
-
-  /// Get the current font selection
-  void getFontSelection(FXFontDesc& fontdesc) const;
-
-  /// Destructor
-  virtual ~FXFontDialog();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXFontSelector.h b/fox-includes/FXFontSelector.h
deleted file mode 100755
index 886d5042..00000000
--- a/fox-includes/FXFontSelector.h
+++ /dev/null
@@ -1,139 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        F o n t   S e l e c t i o n   B o x                    *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1999,2002 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXFontSelector.h 809 2002-07-11 17:28:15Z lyle $                    *
-********************************************************************************/
-#ifndef FXFONTSELECTOR_H
-#define FXFONTSELECTOR_H
-
-#ifndef FXPACKER_H
-#include "FXPacker.h"
-#endif
-
-namespace FX {
-
-
-class FXTextField;
-class FXList;
-class FXComboBox;
-class FXLabel;
-class FXButton;
-class FXCheckButton;
-class FXFont;
-
-
-/// Font selection widget
-class FXAPI FXFontSelector : public FXPacker {
-  FXDECLARE(FXFontSelector)
-protected:
-  FXTextField   *family;
-  FXList        *familylist;
-  FXTextField   *weight;
-  FXList        *weightlist;
-  FXTextField   *style;
-  FXList        *stylelist;
-  FXTextField   *size;
-  FXList        *sizelist;
-  FXComboBox    *charset;
-  FXComboBox    *setwidth;
-  FXComboBox    *pitch;
-  FXCheckButton *scalable;
-  FXCheckButton *allfonts;
-  FXButton      *accept;
-  FXButton      *cancel;
-  FXLabel       *preview;
-  FXFont        *previewfont;
-  FXFontDesc     selected;
-protected:
-  FXFontSelector(){}
-  void listFontFaces();
-  void listWeights();
-  void listSlants();
-  void listFontSizes();
-  void previewFont();
-private:
-  FXFontSelector(const FXFontSelector&);
-  FXFontSelector &operator=(const FXFontSelector&);
-public:
-  long onCmdFamily(FXObject*,FXSelector,void*);
-  long onCmdWeight(FXObject*,FXSelector,void*);
-  long onCmdStyle(FXObject*,FXSelector,void*);
-  long onCmdStyleText(FXObject*,FXSelector,void*);
-  long onCmdSize(FXObject*,FXSelector,void*);
-  long onCmdSizeText(FXObject*,FXSelector,void*);
-  long onCmdCharset(FXObject*,FXSelector,void*);
-  long onUpdCharset(FXObject*,FXSelector,void*);
-  long onCmdSetWidth(FXObject*,FXSelector,void*);
-  long onUpdSetWidth(FXObject*,FXSelector,void*);
-  long onCmdPitch(FXObject*,FXSelector,void*);
-  long onUpdPitch(FXObject*,FXSelector,void*);
-  long onCmdScalable(FXObject*,FXSelector,void*);
-  long onUpdScalable(FXObject*,FXSelector,void*);
-  long onCmdAllFonts(FXObject*,FXSelector,void*);
-  long onUpdAllFonts(FXObject*,FXSelector,void*);
-public:
-  enum{
-    ID_FAMILY=FXPacker::ID_LAST,
-    ID_WEIGHT,
-    ID_STYLE,
-    ID_STYLE_TEXT,
-    ID_SIZE,
-    ID_SIZE_TEXT,
-    ID_CHARSET,
-    ID_SETWIDTH,
-    ID_PITCH,
-    ID_SCALABLE,
-    ID_ALLFONTS,
-    ID_LAST
-    };
-public:
-
-  /// Constructor
-  FXFontSelector(FXComposite *p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Return a pointer to the "Accept" button
-  FXButton *acceptButton() const { return accept; }
-
-  /// Return a pointer to the "Cancel" button
-  FXButton *cancelButton() const { return cancel; }
-
-  /// Set font selection
-  void setFontSelection(const FXFontDesc& fontdesc);
-
-  /// Get font selection
-  void getFontSelection(FXFontDesc& fontdesc) const;
-
-  /// Save to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXFontSelector();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXFrame.h b/fox-includes/FXFrame.h
deleted file mode 100755
index 417b763a..00000000
--- a/fox-includes/FXFrame.h
+++ /dev/null
@@ -1,165 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       F r a m e   W i n d o w   W i d g e t                   *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXFrame.h 2127 2005-08-07 20:21:35Z lyle $                           *
-********************************************************************************/
-#ifndef FXFRAME_H
-#define FXFRAME_H
-
-#ifndef FXWINDOW_H
-#include "FXWindow.h"
-#endif
-
-namespace FX {
-
-
-/// Justification modes used by certain subclasses
-enum {
-  JUSTIFY_NORMAL       = 0,			      /// Default justification is centered text
-  JUSTIFY_CENTER_X     = 0,			      /// Contents centered horizontally
-  JUSTIFY_LEFT         = 0x00008000,		      /// Contents left-justified
-  JUSTIFY_RIGHT        = 0x00010000,		      /// Contents right-justified
-  JUSTIFY_HZ_APART     = JUSTIFY_LEFT|JUSTIFY_RIGHT,  /// Combination of JUSTIFY_LEFT & JUSTIFY_RIGHT
-  JUSTIFY_CENTER_Y     = 0,			      /// Contents centered vertically
-  JUSTIFY_TOP          = 0x00020000,		      /// Contents aligned with label top
-  JUSTIFY_BOTTOM       = 0x00040000,		      /// Contents aligned with label bottom
-  JUSTIFY_VT_APART     = JUSTIFY_TOP|JUSTIFY_BOTTOM   /// Combination of JUSTIFY_TOP & JUSTIFY_BOTTOM
-  };
-
-
-/// Default padding
-enum { DEFAULT_PAD = 2 };
-
-
-/**
-* The Frame widget provides borders around some contents. Borders may be raised, sunken,
-* thick, ridged or etched.  They can also be turned off completely.
-* In addition, a certain amount of padding may be specified between the contents of
-* the widget and the borders.  The contents may be justified inside the widget using the
-* justification options.
-* The Frame widget is sometimes used by itself as a place holder, but most often is used
-* as a convenient base class for simple controls.
-*/
-class FXAPI FXFrame : public FXWindow {
-  FXDECLARE(FXFrame)
-protected:
-  FXColor baseColor;    // Base color
-  FXColor hiliteColor;  // Highlight color
-  FXColor shadowColor;  // Shadow color
-  FXColor borderColor;  // Border color
-  FXint   padtop;       // Top padding
-  FXint   padbottom;    // Bottom padding
-  FXint   padleft;      // Left padding
-  FXint   padright;     // right padding
-  FXint   border;       // Border size
-protected:
-  FXFrame();
-  void drawBorderRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawRaisedRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawSunkenRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawRidgeRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawGrooveRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawDoubleRaisedRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawDoubleSunkenRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawFrame(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-private:
-  FXFrame(const FXFrame&);
-  FXFrame &operator=(const FXFrame&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct frame window
-  FXFrame(FXComposite* p,FXuint opts=FRAME_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Change frame style
-  void setFrameStyle(FXuint style);
-
-  /// Get current frame style
-  FXuint getFrameStyle() const;
-
-  /// Get border width
-  FXint getBorderWidth() const { return border; }
-
-  /// Change top padding
-  void setPadTop(FXint pt);
-
-  /// Get top interior padding
-  FXint getPadTop() const { return padtop; }
-
-  /// Change bottom padding
-  void setPadBottom(FXint pb);
-
-  /// Get bottom interior padding
-  FXint getPadBottom() const { return padbottom; }
-
-  /// Change left padding
-  void setPadLeft(FXint pl);
-
-  /// Get left interior padding
-  FXint getPadLeft() const { return padleft; }
-
-  /// Change right padding
-  void setPadRight(FXint pr);
-
-  /// Get right interior padding
-  FXint getPadRight() const { return padright; }
-
-  /// Change highlight color
-  void setHiliteColor(FXColor clr);
-
-  /// Get highlight color
-  FXColor getHiliteColor() const { return hiliteColor; }
-
-  /// Change shadow color
-  void setShadowColor(FXColor clr);
-
-  /// Get shadow color
-  FXColor getShadowColor() const { return shadowColor; }
-
-  /// Change border color
-  void setBorderColor(FXColor clr);
-
-  /// Get border color
-  FXColor getBorderColor() const { return borderColor; }
-
-  /// Change base gui color
-  void setBaseColor(FXColor clr);
-
-  /// Get base gui color
-  FXColor getBaseColor() const { return baseColor; }
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXGIFCursor.h b/fox-includes/FXGIFCursor.h
deleted file mode 100755
index 1d97f089..00000000
--- a/fox-includes/FXGIFCursor.h
+++ /dev/null
@@ -1,91 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        G I F   C u r so r   O b j e c t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2000,2005 by Daniel Gehriger.   All Rights Reserved.            *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXGIFCursor.h 2336 2006-02-04 15:20:33Z lyle $                       *
-********************************************************************************/
-#ifndef FXGIFCURSOR_H
-#define FXGIFCURSOR_H
-
-#ifndef FXCURSOR_H
-#include "FXCursor.h"
-#endif
-
-namespace FX {
-
-
-/// GIF Cursor class
-class FXAPI FXGIFCursor : public FXCursor {
-  FXDECLARE(FXGIFCursor)
-protected:
-  FXGIFCursor(){}
-private:
-  FXGIFCursor(const FXGIFCursor&);
-  FXGIFCursor &operator=(const FXGIFCursor&);
-public:
-  static const FXchar fileExt[];
-public:
-
-  /**
-  * Construct a cursor from memory stream in Compuserve GIF format.
-  * Hot spot may be specified using hx and hy parameters, since the GIF
-  * format does not specify a hot spot. The image must be smaller than
-  * 32x32 pixels.
-  */
-  FXGIFCursor(FXApp* a,const void* pix,FXint hx=0,FXint hy=0);
-
-  /// Save pixel data only, in GIF format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixel data only, in GIF format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy
-  virtual ~FXGIFCursor(){}
-  };
-
-
-#ifndef FXLOADGIF
-#define FXLOADGIF
-
-/**
-* Check if stream contains a GIF, return TRUE if so.
-*/
-extern FXAPI bool fxcheckGIF(FXStream& store);
-
-
-/**
-* Load an GIF (Graphics Interchange Format) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadGIF(FXStream& store,FXColor*& data,FXint& width,FXint& height);
-
-
-/**
-* Save an GIF (Graphics Interchange Format) file to a stream.
-*/
-extern FXAPI bool fxsaveGIF(FXStream& store,const FXColor *data,FXint width,FXint height,bool fast=true);
-
-#endif
-
-}
-
-#endif
diff --git a/fox-includes/FXGIFIcon.h b/fox-includes/FXGIFIcon.h
deleted file mode 100755
index 608a9d6e..00000000
--- a/fox-includes/FXGIFIcon.h
+++ /dev/null
@@ -1,89 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        G I F   I c o n   O b j e c t                          *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXGIFIcon.h 2342 2006-02-10 14:24:44Z lyle $                         *
-********************************************************************************/
-#ifndef FXGIFICON_H
-#define FXGIFICON_H
-
-#ifndef FXICON_H
-#include "FXIcon.h"
-#endif
-
-namespace FX {
-
-/// GIF Icon class
-class FXAPI FXGIFIcon : public FXIcon {
-  FXDECLARE(FXGIFIcon)
-protected:
-  FXGIFIcon(){}
-private:
-  FXGIFIcon(const FXGIFIcon&);
-  FXGIFIcon &operator=(const FXGIFIcon&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct an icon from memory stream formatted as GIF format
-  FXGIFIcon(FXApp* a,const void *pix=NULL,FXColor clr=FXRGB(192,192,192),FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Save pixels into stream in GIF format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in GIF format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy
-  virtual ~FXGIFIcon();
-  };
-
-
-
-#ifndef FXLOADGIF
-#define FXLOADGIF
-
-/**
-* Check if stream contains a GIF, return TRUE if so.
-*/
-extern FXAPI bool fxcheckGIF(FXStream& store);
-
-
-/**
-* Load an GIF (Graphics Interchange Format) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadGIF(FXStream& store,FXColor*& data,FXint& width,FXint& height);
-
-
-/**
-* Save an GIF (Graphics Interchange Format) file to a stream.  The flag
-* "fast" is used to select the faster Floyd-Steinberg dither method instead
-* of the slower Wu quantization algorithm.
-*/
-extern FXAPI bool fxsaveGIF(FXStream& store,const FXColor *data,FXint width,FXint height,bool fast=true);
-
-#endif
-
-}
-
-#endif
diff --git a/fox-includes/FXGIFImage.h b/fox-includes/FXGIFImage.h
deleted file mode 100755
index 71dbaafd..00000000
--- a/fox-includes/FXGIFImage.h
+++ /dev/null
@@ -1,86 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                         G I F   I m a g e   O b j e c t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXGIFImage.h 2342 2006-02-10 14:24:44Z lyle $                        *
-********************************************************************************/
-#ifndef FXGIFIMAGE_H
-#define FXGIFIMAGE_H
-
-#ifndef FXIMAGE_H
-#include "FXImage.h"
-#endif
-
-namespace FX {
-
-/// GIF Image class
-class FXAPI FXGIFImage : public FXImage {
-  FXDECLARE(FXGIFImage)
-protected:
-  FXGIFImage(){}
-private:
-  FXGIFImage(const FXGIFImage&);
-  FXGIFImage &operator=(const FXGIFImage&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct an image from memory stream formatted as CompuServe GIF format
-  FXGIFImage(FXApp* a,const void *pix=NULL,FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Save pixels into stream in [un]GIF format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in CompuServe GIF format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy
-  virtual ~FXGIFImage();
-  };
-
-
-#ifndef FXLOADGIF
-#define FXLOADGIF
-
-/**
-* Check if stream contains a GIF, return TRUE if so.
-*/
-extern FXAPI bool fxcheckGIF(FXStream& store);
-
-
-/**
-* Load an GIF (Graphics Interchange Format) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadGIF(FXStream& store,FXColor*& data,FXint& width,FXint& height);
-
-
-/**
-* Save an GIF (Graphics Interchange Format) file to a stream.
-*/
-extern FXAPI bool fxsaveGIF(FXStream& store,const FXColor *data,FXint width,FXint height,bool fast=true);
-
-#endif
-
-}
-
-#endif
diff --git a/fox-includes/FXGLCanvas.h b/fox-includes/FXGLCanvas.h
deleted file mode 100755
index 0aa01812..00000000
--- a/fox-includes/FXGLCanvas.h
+++ /dev/null
@@ -1,111 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                G L  C a n v a s   W i n d o w   W i d g e t                   *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXGLCanvas.h 2231 2005-11-09 03:16:46Z lyle $                        *
-********************************************************************************/
-#ifndef FXGLCANVAS_H
-#define FXGLCANVAS_H
-
-#ifndef FXCANVAS_H
-#include "FXCanvas.h"
-#endif
-
-namespace FX {
-
-
-class FXGLVisual;
-
-
-/// GLCanvas, an area drawn by another object
-class FXAPI FXGLCanvas : public FXCanvas {
-  FXDECLARE(FXGLCanvas)
-private:
-  FXGLCanvas  *sgnext;  // Share group next in share list
-  FXGLCanvas  *sgprev;  // Share group previous in share list
-protected:
-  void        *ctx;     // GL Context
-protected:
-  FXGLCanvas();
-private:
-  FXGLCanvas(const FXGLCanvas&);
-  FXGLCanvas &operator=(const FXGLCanvas&);
-#ifdef WIN32
-  virtual const char* GetClass() const;
-#endif
-public:
-
-  /**
-  * Construct an OpenGL-capable canvas, with its own private display list.
-  */
-  FXGLCanvas(FXComposite* p,FXGLVisual *vis,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /**
-  * Construct an OpenGL-capable canvas, sharing display
-  * list with another GL canvas.  This canvas becomes a member
-  * of a display list share group.  All members of the display
-  * list share group have to have the same visual.
-  */
-  FXGLCanvas(FXComposite* p,FXGLVisual *vis,FXGLCanvas* sharegroup,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Return TRUE if it is sharing display lists
-  FXbool isShared() const;
-
-  /// Create all of the server-side resources for this window
-  virtual void create();
-
-  /// Detach the server-side resources for this window
-  virtual void detach();
-
-  /// Destroy the server-side resources for this window
-  virtual void destroy();
-
-  /// Make OpenGL context current prior to performing OpenGL commands
-  virtual FXbool makeCurrent();
-
-  /// Make OpenGL context non current
-  virtual FXbool makeNonCurrent();
-
-  /// Return TRUE if this window's context is current
-  virtual FXbool isCurrent() const;
-
-  /// Return current context, if any
-  static void* getCurrentContext();
-
-  /// Get GL context handle
-  void* getContext() const { return ctx; }
-
-  /// Swap front and back buffer
-  virtual void swapBuffers();
-
-  /// Save object to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load object from stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXGLCanvas();
-  };
-
-}
-
-#endif
-
diff --git a/fox-includes/FXGLCone.h b/fox-includes/FXGLCone.h
deleted file mode 100755
index 3d0afa49..00000000
--- a/fox-includes/FXGLCone.h
+++ /dev/null
@@ -1,77 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        O p e n G L   C o n e    O b j e c t                   *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1999,2002 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXGLCone.h 809 2002-07-11 17:28:15Z lyle $                          *
-********************************************************************************/
-#ifndef FXGLCONE_H
-#define FXGLCONE_H
-
-#ifndef FXGLSHAPE_H
-#include "FXGLShape.h"
-#endif
-
-namespace FX {
-
-
-/// OpenGL Cone Object
-class FXAPI FXGLCone : public FXGLShape {
-  FXDECLARE(FXGLCone)
-public:
-  FXfloat height;
-  FXfloat radius;
-protected:
-  FXGLCone();
-  virtual void drawshape(FXGLViewer* viewer);
-public:
-
-  /// Construct with specified origin, height and radius
-  FXGLCone(FXfloat x,FXfloat y,FXfloat z,FXfloat h=1.0f,FXfloat r=1.0f);
-
-  /// Construct with specified origin, height, radius and material
-  FXGLCone(FXfloat x,FXfloat y,FXfloat z,FXfloat h,FXfloat r,const FXMaterial& mtl);
-
-  /// Copy constructor
-  FXGLCone(const FXGLCone& orig);
-
-  /// Copy this object
-  virtual FXGLObject* copy();
-
-  /// Change radius
-  void setRadius(FXfloat r){ radius=r; }
-  FXfloat getRadius() const { return radius; }
-
-  /// Change height
-  void setHeight(FXfloat h){ height=h; }
-  FXfloat getHeight() const { return height; }
-
-  /// Save to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from a stream
-  virtual void load(FXStream& store);
-
-  /// Destroy
-  virtual ~FXGLCone();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXGLContext.h b/fox-includes/FXGLContext.h
deleted file mode 100755
index 4242f5b6..00000000
--- a/fox-includes/FXGLContext.h
+++ /dev/null
@@ -1,112 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        G L  C o n t e x t   C l a s s                         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2000,2002 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXGLContext.h 809 2002-07-11 17:28:15Z lyle $                        *
-********************************************************************************/
-#ifndef FXGLCONTEXT_H
-#define FXGLCONTEXT_H
-
-//////////////////////////////  UNDER DEVELOPMENT  //////////////////////////////
-
-namespace FX {
-
-class FXApp;
-class FXDrawable;
-class FXGLVisual;
-
-
-/**
-* A GL context is an object representing the OpenGL state information.
-* Multiple GL context may share display lists to conserve memory.
-* When drawing multiple windows, it may be advantageous to share not only
-* display lists, but also GL contexts.  Since the GL context is created
-* for a certain frame-buffer configuration, sharing of GL contexts is
-* only possible if the windows sharing the GL context all have the same
-* GL visual.
-* However, display lists may be shared between different GL contexts.
-*/
-class FXAPI FXGLContext : public FXId {
-  FXDECLARE(FXGLContext)
-private:
-  FXGLVisual     *visual;     // Visual for this context
-  FXDrawable     *surface;    // Drawable context is locked on
-  FXGLContext    *sgnext;     // Share group next in share list
-  FXGLContext    *sgprev;     // Share group previous in share list
-protected:
-  void           *ctx;        // GL Context
-protected:
-  FXGLContext():visual(NULL),surface(NULL),sgnext(NULL),sgprev(NULL),ctx(NULL){}
-private:
-  FXGLContext(const FXGLContext&);
-  FXGLContext &operator=(const FXGLContext&);
-public:
-
-  /**
-  * Construct an OpenGL context with its own private display list.
-  */
-  FXGLContext(FXApp* a,FXGLVisual *vis);
-
-  /**
-  * Construct an OpenGL context sharing display lists with an existing GL context.
-  */
-  FXGLContext(FXApp* a,FXGLVisual *vis,FXGLContext *shared);
-
-  /// Return TRUE if it is sharing display lists
-  FXbool isShared() const;
-
-  /// Get the visual
-  FXGLVisual* getVisual() const { return visual; }
-
-  /// Create context
-  virtual void create();
-
-  /// Detach the server-side resources for this window
-  virtual void detach();
-
-  /// Destroy the server-side resources for this window
-  virtual void destroy();
-
-  /// Make OpenGL context current prior to performing OpenGL commands
-  FXbool begin(FXDrawable *drawable);
-
-  /// Make OpenGL context non current
-  FXbool end();
-
-  /// Swap front and back buffer
-  void swapBuffers();
-
-  /// Copy part of backbuffer to front buffer [Mesa]
-  void swapSubBuffers(FXint x,FXint y,FXint w,FXint h);
-
-  /// Save object to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load object from stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXGLContext();
-  };
-
-}
-
-#endif
-
diff --git a/fox-includes/FXGLCube.h b/fox-includes/FXGLCube.h
deleted file mode 100755
index d49f762b..00000000
--- a/fox-includes/FXGLCube.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        O p e n G L   C u b e    O b j e c t                   *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1999,2002 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXGLCube.h 809 2002-07-11 17:28:15Z lyle $                          *
-********************************************************************************/
-#ifndef FXGLCUBE_H
-#define FXGLCUBE_H
-
-#ifndef FXGLSHAPE_H
-#include "FXGLShape.h"
-#endif
-
-namespace FX {
-
-
-/// OpenGL Cube Object
-class FXAPI FXGLCube : public FXGLShape {
-  FXDECLARE(FXGLCube)
-public:
-  FXfloat width;
-  FXfloat height;
-  FXfloat depth;
-protected:
-  FXGLCube();
-  virtual void drawshape(FXGLViewer* viewer);
-public:
-
-  /// Construct with specified origin, width, height and depth
-  FXGLCube(FXfloat x,FXfloat y,FXfloat z,FXfloat w=1.0f,FXfloat h=1.0f,FXfloat d=1.0f);
-
-  /// Construct with specified origin, width, height, depth and material
-  FXGLCube(FXfloat x,FXfloat y,FXfloat z,FXfloat w,FXfloat h,FXfloat d,const FXMaterial& mtl);
-
-  /// Copy constructor
-  FXGLCube(const FXGLCube& orig);
-
-  /// Copy this object
-  virtual FXGLObject* copy();
-
-  /// Change width
-  void setWidth(FXfloat w){ width=w; }
-  FXfloat getWidth() const { return width; }
-
-  /// Change height
-  void setHeight(FXfloat h){ height=h; }
-  FXfloat getHeight() const { return height; }
-
-  /// Change depth
-  void setDepth(FXfloat d){ depth=d; }
-  FXfloat getDepth() const { return depth; }
-
-  /// Save to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from a stream
-  virtual void load(FXStream& store);
-
-  /// Destroy
-  virtual ~FXGLCube();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXGLCylinder.h b/fox-includes/FXGLCylinder.h
deleted file mode 100755
index 09038896..00000000
--- a/fox-includes/FXGLCylinder.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                     O p e n G L   C y l i n d e r    O b j e c t              *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1999,2002 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXGLCylinder.h 809 2002-07-11 17:28:15Z lyle $                      *
-********************************************************************************/
-#ifndef FXGLCYLINDER_H
-#define FXGLCYLINDER_H
-
-#ifndef FXGLSHAPE_H
-#include "FXGLShape.h"
-#endif
-
-namespace FX {
-
-
-/// OpenGL Cylinder Object
-class FXAPI FXGLCylinder : public FXGLShape {
-  FXDECLARE(FXGLCylinder)
-public:
-  FXfloat height;
-  FXfloat radius;
-protected:
-  FXGLCylinder();
-  virtual void drawshape(FXGLViewer* viewer);
-public:
-
-  /// Construct with specified origin, height and radius
-  FXGLCylinder(FXfloat x,FXfloat y,FXfloat z,FXfloat h=1.0f, FXfloat r=1.0f);
-
-  /// Construct with specified origin, height, radius and material
-  FXGLCylinder(FXfloat x,FXfloat y,FXfloat z,FXfloat h,FXfloat r,const FXMaterial& mtl);
-
-  /// Copy constructor
-  FXGLCylinder(const FXGLCylinder& orig);
-
-  /// Copy this object
-  virtual FXGLObject* copy();
-
-  /// Change radius
-  void setRadius(FXfloat r){ radius=r; }
-  FXfloat getRadius() const { return radius; }
-
-  /// Change height
-  void setHeight(FXfloat h){ height=h; }
-  FXfloat getHeight() const { return height; }
-
-  /// Save to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from a stream
-  virtual void load(FXStream& store);
-
-  virtual ~FXGLCylinder();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXGLObject.h b/fox-includes/FXGLObject.h
deleted file mode 100755
index 7d566215..00000000
--- a/fox-includes/FXGLObject.h
+++ /dev/null
@@ -1,249 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                           O p e n G L   O b j e c t                           *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXGLObject.h 2231 2005-11-09 03:16:46Z lyle $                        *
-********************************************************************************/
-#ifndef FXGLOBJECT_H
-#define FXGLOBJECT_H
-
-#ifndef FXOBJECT_H
-#include "FXObject.h"
-#endif
-
-namespace FX {
-
-
-class FXGLViewer;
-class FXGLObject;
-
-
-// List of objects
-typedef FXObjectListOf<FXGLObject> FXGLObjectList;
-
-/// Basic OpenGL object
-class FXAPI FXGLObject : public FXObject {
-  FXDECLARE(FXGLObject)
-public:
-  enum {
-    ID_LAST=10000       // Leaving ample room for FXGLViewer subclasses
-    };
-public:
-
-  /// Constructors
-  FXGLObject(){}
-
-  /// Copy constructor
-  FXGLObject(const FXGLObject& orig):FXObject(orig){}
-
-  /// Called by the viewer to get bounds for this object
-  virtual void bounds(FXRangef& box);
-
-  /// Draw this object in a viewer
-  virtual void draw(FXGLViewer* viewer);
-
-  /// Draw this object for hit-testing purposes
-  virtual void hit(FXGLViewer* viewer);
-
-  /// Copy this object
-  virtual FXGLObject* copy();
-
-  /// Identify sub-object given path
-  virtual FXGLObject* identify(FXuint* path);
-
-  /// Return true if this object can be dragged around
-  virtual FXbool canDrag() const;
-
-  /// Return true if this object can be deleted from the scene
-  virtual FXbool canDelete() const;
-
-  /// Drag this object from one position to another
-  virtual FXbool drag(FXGLViewer* viewer,FXint fx,FXint fy,FXint tx,FXint ty);
-
-  /// Destructor
-  virtual ~FXGLObject(){}
-  };
-
-
-// Suppress warning about FXGLGroup::list not being exported
-#ifdef _MSC_VER
-#if _MSC_VER >= 1200
-#pragma warning( push )
-#endif
-#pragma warning( disable : 4251 )
-#endif
-
-
-/// Group object
-class FXAPI FXGLGroup : public FXGLObject {
-  FXDECLARE(FXGLGroup)
-protected:
-  FXGLObjectList list;    // List of all objects
-public:
-
-  /// Constructor
-  FXGLGroup(){ }
-
-  /// Copy constructor
-  FXGLGroup(const FXGLGroup& orig):FXGLObject(orig),list(orig.list){ }
-
-  /// Return list of childern
-  FXGLObjectList& getList(){ return list; }
-
-  /// Return bounding box
-  virtual void bounds(FXRangef& box);
-
-  /// Draw into viewer
-  virtual void draw(FXGLViewer* viewer);
-
-  /// Hit in viewer
-  virtual void hit(FXGLViewer* viewer);
-
-  /// Copy this object
-  virtual FXGLObject* copy();
-
-  /// Identify object by means of path
-  virtual FXGLObject* identify(FXuint* path);
-
-  /// Return TRUE if group can be dragged
-  virtual FXbool canDrag() const;
-
-  /// Drag group object
-  virtual FXbool drag(FXGLViewer* viewer,FXint fx,FXint fy,FXint tx,FXint ty);
-
-  /// Return number of children
-  FXint no() const { return list.no(); }
-
-  /// Child at position
-  FXGLObject* child(FXint pos) const { return list[pos]; }
-
-  /// Insert child object at given position
-  void insert(FXint pos,FXGLObject* obj){ list.insert(pos,obj); }
-
-  /// Prepend child object
-  void prepend(FXGLObject* obj){ list.prepend(obj); }
-
-  /// Append child object
-  void append(FXGLObject* obj){ list.append(obj); }
-
-  /// Replace child object
-  void replace(FXint pos,FXGLObject* obj){ list.replace(pos,obj); }
-
-  /// Remove child object
-  void remove(FXGLObject* obj){ list.remove(obj); }
-
-  /// Remove child object at given position
-  void erase(FXint pos){ list.erase(pos); }
-
-  /// Remove all children
-  void clear(){ list.clear(); }
-
-  /// Stream save and load
-  virtual void save(FXStream& store) const;
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXGLGroup();
-  };
-
-
-// Restore previous warning levels
-#ifdef _MSC_VER
-#if _MSC_VER >= 1200
-#pragma warning( pop )
-#endif
-#endif
-
-
-/// OpenGL Point Object
-class FXAPI FXGLPoint : public FXGLObject {
-  FXDECLARE(FXGLPoint)
-public:
-  FXVec3f pos;
-public:
-
-  /// Default constructor
-  FXGLPoint();
-
-  /// Copy constructor
-  FXGLPoint(const FXGLPoint& orig);
-
-  /// Construct with specified coordinates
-  FXGLPoint(FXfloat x,FXfloat y,FXfloat z);
-
-  /// Copy this object
-  virtual FXGLObject* copy();
-
-  /// Called by the viewer to get bounds for this object
-  virtual void bounds(FXRangef& box);
-
-  /// Draw this object in a viewer
-  virtual void draw(FXGLViewer* viewer);
-
-  /// Draw this object for hit-testing purposes
-  virtual void hit(FXGLViewer* viewer);
-
-  /// Save to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from a stream
-  virtual void load(FXStream& store);
-  };
-
-
-/// OpenGL Line Object
-class FXAPI FXGLLine : public FXGLObject {
-  FXDECLARE(FXGLLine)
-public:
-  FXGLPoint fm,to;
-public:
-
-  /// Default constructor
-  FXGLLine();
-
-  /// Copy constructor
-  FXGLLine(const FXGLLine& orig);
-
-  /// Construct with specified endpoints
-  FXGLLine(FXfloat fx,FXfloat fy,FXfloat fz,FXfloat tx,FXfloat ty,FXfloat tz);
-
-  /// Called by the viewer to get bounds for this object
-  virtual void bounds(FXRangef& box);
-
-  /// Draw this object in a viewer
-  virtual void draw(FXGLViewer* viewer);
-
-  /// Copy this object
-  virtual FXGLObject* copy();
-
-  /// Draw this object for hit-testing purposes
-  virtual void hit(FXGLViewer* viewer);
-
-  /// Save to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from a stream
-  virtual void load(FXStream& store);
-  };
-
-}
-
-#endif
-
diff --git a/fox-includes/FXGLShape.h b/fox-includes/FXGLShape.h
deleted file mode 100755
index 8b41d73c..00000000
--- a/fox-includes/FXGLShape.h
+++ /dev/null
@@ -1,154 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                   O p e n G L   S h a p e   O b j e c t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXGLShape.h 2127 2005-08-07 20:21:35Z lyle $                         *
-********************************************************************************/
-#ifndef FXGLSHAPE_H
-#define FXGLSHAPE_H
-
-#ifndef FXGLOBJECT_H
-#include "FXGLObject.h"
-#endif
-
-namespace FX {
-
-
-class FXGLViewer;
-class FXGLObject;
-
-
-// Shape drawing options
-enum {
-  SURFACE_SINGLESIDED   = 0,              // Single-sided [both sides same]
-  SURFACE_DUALSIDED     = 0x00000001,     // Dual-sided surface
-  SHADING_NONE          = 0,              // No light source
-  SHADING_SMOOTH        = 0x00000002,     // Smooth shaded
-  SHADING_FLAT          = 0x00000004,     // Flag shaded
-  FACECULLING_OFF       = 0,              // No face culling
-  FACECULLING_ON        = 0x00000008,     // Cull backward facing surfaces
-  STYLE_SURFACE         = 0x00000010,     // Draw filled surfaces
-  STYLE_WIREFRAME       = 0x00000020,     // Draw wire frame
-  STYLE_POINTS          = 0x00000040,     // Draw as points
-  STYLE_BOUNDBOX        = 0x00000080      // Draw bounding box
-  };
-
-
-
-/// OpenGL Shape Object
-class FXAPI FXGLShape : public FXGLObject {
-  FXDECLARE_ABSTRACT(FXGLShape)
-protected:
-  FXVec3f       position;             // Middle of the Bounding Box
-  FXMaterial    material[2];          // Front and back material properties
-  FXRangef      range;                // Range box
-  FXuint	options;              // Drawing options
-  FXString	tip;
-protected:
-  FXGLShape();
-  virtual void drawshape(FXGLViewer*){}  // To be overloaded by derived class
-  void drawbox();
-  void drawhandles();
-public:
-  long onDNDDrop(FXObject*,FXSelector,void*);
-  long onDNDMotion(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-  long onCmdShadeOff(FXObject*,FXSelector,void*);
-  long onUpdShadeOff(FXObject*,FXSelector,void*);
-  long onCmdShadeOn(FXObject*,FXSelector,void*);
-  long onUpdShadeOn(FXObject*,FXSelector,void*);
-  long onCmdShadeSmooth(FXObject*,FXSelector,void*);
-  long onUpdShadeSmooth(FXObject*,FXSelector,void*);
-  long onCmdFrontMaterial(FXObject*,FXSelector,void*);
-  long onUpdFrontMaterial(FXObject*,FXSelector,void*);
-  long onCmdBackMaterial(FXObject*,FXSelector,void*);
-  long onUpdBackMaterial(FXObject*,FXSelector,void*);
-  long onCmdDrawingStyle(FXObject*,FXSelector,void*);
-  long onUpdDrawingStyle(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_SHADEOFF=FXGLObject::ID_LAST,
-    ID_SHADEON,
-    ID_SHADESMOOTH,
-    ID_TOGGLE_SIDED,
-    ID_TOGGLE_CULLING,
-    ID_STYLE_POINTS,
-    ID_STYLE_WIREFRAME,
-    ID_STYLE_SURFACE,
-    ID_STYLE_BOUNDINGBOX,
-    ID_FRONT_MATERIAL,
-    ID_BACK_MATERIAL,
-    ID_LAST
-    };
-public:
-
-  /// Construct with specified origin and options
-  FXGLShape(FXfloat x,FXfloat y,FXfloat z,FXuint opts);
-
-  /// Construct with specified origin, options and front and back materials
-  FXGLShape(FXfloat x,FXfloat y,FXfloat z,FXuint opts,const FXMaterial& front,const FXMaterial& back);
-
-  /// Copy constructor
-  FXGLShape(const FXGLShape& orig);
-
-  /// Called by the viewer to get bounds for this object
-  virtual void bounds(FXRangef& box);
-
-  /// Draw this object in a viewer
-  virtual void draw(FXGLViewer* viewer);
-
-  /// Draw this object for hit-testing purposes
-  virtual void hit(FXGLViewer* viewer);
-
-  /// Copy this object
-  virtual FXGLObject* copy();
-
-  /// Return true if this object can be dragged around
-  virtual FXbool canDrag() const;
-
-  /// Return true if this object can be deleted from the scene
-  virtual FXbool canDelete() const;
-
-  /// Drag this object from one position to another
-  virtual FXbool drag(FXGLViewer* viewer,FXint fx,FXint fy,FXint tx,FXint ty);
-
-  /// Set the tool tip message for this object
-  void setTipText(const FXString& text){ tip=text; }
-
-  /// Get the tool tip message for this object
-  const FXString& getTipText() const { return tip; }
-
-  /// Set the material for specified side (where side = 0 or 1)
-  void setMaterial(FXint side,const FXMaterial &mtl);
-
-  /// Get the material for specified side (where side = 0 or 1)
-  void getMaterial(FXint side,FXMaterial &mtl) const;
-
-  /// Save shape to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load shape from a stream
-  virtual void load(FXStream& store);
-  };
-
-}
-
-#endif
-
diff --git a/fox-includes/FXGLSphere.h b/fox-includes/FXGLSphere.h
deleted file mode 100755
index 98a6caf6..00000000
--- a/fox-includes/FXGLSphere.h
+++ /dev/null
@@ -1,86 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                   O p e n G L   S p h e r e   O b j e c t                     *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2002 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXGLSphere.h 809 2002-07-11 17:28:15Z lyle $                        *
-********************************************************************************/
-#ifndef FXGLSPHERE_H
-#define FXGLSPHERE_H
-
-#ifndef FXGLSHAPE_H
-#include "FXGLShape.h"
-#endif
-
-namespace FX {
-
-
-/// OpenGL Sphere Object
-class FXAPI FXGLSphere : public FXGLShape {
-  FXDECLARE(FXGLSphere)
-public:
-  FXfloat radius;   // Radius of sphere
-  FXint   slices;   // Longitudinal subdivision
-  FXint   stacks;   // Latitudinal subdivision
-protected:
-  FXGLSphere();
-  virtual void drawshape(FXGLViewer* viewer);
-public:
-  enum {
-    ID_LAST=FXGLShape::ID_LAST
-    };
-public:
-
-  /// Construct with specified origin and radius
-  FXGLSphere(FXfloat x,FXfloat y,FXfloat z,FXfloat r=1.0f);
-
-  /// Construct with specified origin, radius and material
-  FXGLSphere(FXfloat x,FXfloat y,FXfloat z,FXfloat r,const FXMaterial& mtl);
-
-  /// Copy constructor
-  FXGLSphere(const FXGLSphere& orig);
-
-  /// Copy this object
-  virtual FXGLObject* copy();
-
-  /// Change radius
-  void setRadius(FXfloat r){ radius=r; }
-  FXfloat getRadius() const { return radius; }
-
-  /// Change slices
-  void setSlices(FXint s){ slices=s; }
-  FXint getSlices() const { return slices; }
-
-  /// Change stacks
-  void setStacks(FXint s){ stacks=s; }
-  FXint getStacks() const { return stacks; }
-
-  /// Save to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from a stream
-  virtual void load(FXStream& store);
-
-  /// Destroy
-  virtual ~FXGLSphere();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXGLTriangleMesh.h b/fox-includes/FXGLTriangleMesh.h
deleted file mode 100755
index cea91d35..00000000
--- a/fox-includes/FXGLTriangleMesh.h
+++ /dev/null
@@ -1,114 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*             O p e n G L   T r i a n g l e   M e s h   O b j e c t             *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1999,2002 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXGLTriangleMesh.h 809 2002-07-11 17:28:15Z lyle $                  *
-********************************************************************************/
-#ifndef FXGLTRIANGLEMESH_H
-#define FXGLTRIANGLEMESH_H
-
-#ifndef FXGLSHAPE_H
-#include "FXGLShape.h"
-#endif
-
-namespace FX {
-
-
-/*
- * Arrays Formats
- *
- * vertex: x,y,z
- * normal: x,y,z
- * Color: r,g.b,a
- * texture: u,v
- */
-
-
-/// OpenGL Triangle Mesh Object
-class FXAPI FXGLTriangleMesh : public FXGLShape {
-  FXDECLARE(FXGLTriangleMesh)
-private:
-  FXfloat   *vertexBuffer;
-  FXfloat   *colorBuffer;
-  FXfloat   *normalBuffer;
-  FXfloat   *textureBuffer;
-  FXint      vertexNumber;
-protected:
-  FXGLTriangleMesh();
-  virtual void drawshape(FXGLViewer* viewer);
-  virtual void recomputerange();
-  virtual void generatenormals();
-public:
-
-  /// Construct triangle mesh with nv vertices, and optional normals, colors, and texture coordinates
-  FXGLTriangleMesh(FXfloat x,FXfloat y,FXfloat z,FXint nv,FXfloat *v,FXfloat *n=NULL,FXfloat *c=NULL,FXfloat *t=NULL);
-
-  /// Construct triangle mesh with nv vertices, and optional normals, colors, and texture coordinates, and surface material
-  FXGLTriangleMesh(FXfloat x,FXfloat y,FXfloat z,FXint nv,FXfloat *v,FXfloat *n,FXfloat *c,FXfloat *t,const FXMaterial& mtl);
-
-  /// Copy constructor
-  FXGLTriangleMesh(const FXGLTriangleMesh& orig);
-
-  /// Copy this object
-  virtual FXGLObject* copy();
-
-  /// Change number of vertices
-  void setVertexNumber(FXint nvertices){ vertexNumber=nvertices; }
-
-  /// Get number of vertices
-  FXint getVertexNumber() const { return vertexNumber; }
-
-  /// Set vertex buffer
-  void setVertexBuffer(FXfloat *vertices);
-
-  /// Get vertex buffer
-  FXfloat* getVertexBuffer() const { return vertexBuffer; }
-
-  /// Set color buffer
-  void setColorBuffer(FXfloat *colors){ colorBuffer=colors; }
-
-  /// Get color buffer
-  FXfloat* getColorBuffer() const { return colorBuffer; }
-
-  /// Set normals buffer
-  void setNormalBuffer(FXfloat *normals){ normalBuffer=normals; }
-
-  /// Get normals buffer
-  FXfloat* getNormalBuffer() const { return normalBuffer; }
-
-  /// Set texture coordinate buffer
-  void setTextureCoordBuffer(FXfloat *textures){ textureBuffer=textures; }
-
-  /// Get texture coordinate buffer
-  FXfloat* getTextureCoordBuffer() const { return textureBuffer; }
-
-  /// Save to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXGLTriangleMesh();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXGLViewer.h b/fox-includes/FXGLViewer.h
deleted file mode 100755
index 5853cec1..00000000
--- a/fox-includes/FXGLViewer.h
+++ /dev/null
@@ -1,556 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                      O p e n G L   V i e w e r   W i d g e t                  *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXGLViewer.h 2127 2005-08-07 20:21:35Z lyle $                        *
-********************************************************************************/
-#ifndef FXGLVIEWER_H
-#define FXGLVIEWER_H
-
-#ifndef FXGLCANVAS_H
-#include "FXGLCanvas.h"
-#endif
-
-namespace FX {
-
-
-class FXDCPrint;
-class FXGLObject;
-class FXGLVisual;
-
-
-// GL Viewer options
-enum {
-  VIEWER_LIGHTING = 0x00008000,    /// Lighting is on
-  VIEWER_FOG      = 0x00010000,    /// Fog mode on
-  VIEWER_DITHER   = 0x00020000     /// Dithering
-  };
-
-
-/*******************************  Viewer  Structs  *****************************/
-
-
-/// OpenGL Viewer Viewport
-struct FXViewport {
-  FXint      w,h;               // Viewport dimensions
-  FXdouble   left,right;        // World box
-  FXdouble   bottom,top;
-  FXdouble   hither,yon;
-  };
-
-
-// OpenGL Light Source
-struct FXAPI FXLight {
-  FXVec4f    ambient;           // Ambient light color
-  FXVec4f    diffuse;           // Diffuse light color
-  FXVec4f    specular;          // Specular light color
-  FXVec4f    position;          // Light position
-  FXVec3f    direction;         // Spot direction
-  FXfloat    exponent;          // Spotlight exponent
-  FXfloat    cutoff;            // Spotlight cutoff angle
-  FXfloat    c_attn;            // Constant attenuation factor
-  FXfloat    l_attn;            // Linear attenuation factor
-  FXfloat    q_attn;            // Quadratic attenuation factor
-  };
-
-
-// OpenGL Material Description
-struct FXAPI FXMaterial {
-  FXVec4f    ambient;           // Ambient material color
-  FXVec4f    diffuse;           // Diffuse material color
-  FXVec4f    specular;          // Specular material color
-  FXVec4f    emission;          // Emissive material color
-  FXfloat    shininess;         // Specular shininess
-  };
-
-
-// Feedback buffer sort routine
-typedef FXbool (*FXZSortFunc)(FXfloat*& buffer,FXint& used,FXint& size);
-
-
-/********************************  Viewer  Class  ******************************/
-
-
-/// OpenGL viewer widget
-class FXAPI FXGLViewer : public FXGLCanvas {
-  FXDECLARE(FXGLViewer)
-  friend class FXGLObject;
-protected:
-  FXViewport      wvt;              // Window viewport transform
-  FXMat4f         transform;        // Current transformation matrix
-  FXMat4f         itransform;       // Inverse of current transformation matrix
-  FXuint          projection;       // Projection mode
-  FXQuatf         rotation;         // Viewer orientation
-  FXdouble        fov;              // Field of view
-  FXdouble        zoom;             // Zoom factor
-  FXVec3f         center;           // Model center
-  FXVec3f         scale;            // Model scale
-  FXdouble        worldpx;          // Pixel size in world
-  FXdouble        modelpx;          // Pixel size in model
-  FXint           maxhits;          // Maximum number of hits
-  FXdouble        ax,ay;            // Quick view->world coordinate mapping
-  FXdouble        diameter;         // Size of model diameter ( always > 0)
-  FXdouble        distance;         // Distance of PRP to target
-  FXVec4f         background[2];    // Background colors
-  FXVec4f         ambient;          // Global ambient light
-  FXLight         light;            // Light source
-  FXMaterial      material;         // Base material properties
-  FXint           dial[3];          // Dial positions
-  FXString        help;             // Status help
-  FXString        tip;              // Tooltip for background
-  FXGLObject     *dropped;          // Object being dropped on
-  FXGLObject     *selection;        // Current object
-  FXZSortFunc     zsortfunc;        // Routine to sort feedback buffer
-  FXGLObject     *scene;            // What we're looking at
-  FXbool          doesturbo;        // Doing turbo mode
-  FXbool          turbomode;        // Turbo mode
-  FXuchar         mode;             // Mode the widget is in
-public:
-
-  // Common DND types
-  static FXDragType objectType;     // GL Object type
-
-protected:
-
-  // Mouse actions when in viewing window
-  enum {
-    HOVERING,                       // Hovering mouse w/o doing anything
-    PICKING,                        // Pick mode
-    ROTATING,                       // Rotating camera around target
-    POSTING,                        // Posting right-mouse menu
-    TRANSLATING,                    // Translating camera
-    ZOOMING,                        // Zooming
-    FOVING,                         // Change field-of-view
-    DRAGGING,                       // Dragging objects
-    TRUCKING,                       // Trucking camera
-    GYRATING,                       // Rotation of camera around eye
-    DO_LASSOSELECT,                 // Lasso select when mouse pressed
-    LASSOSELECT,                    // Anchor of lasso rectangle
-    DO_LASSOZOOM,                   // Zoom when mouse pressed
-    LASSOZOOM                       // Zoom rectangle
-    };
-
-protected:
-  FXGLViewer();
-  void glsetup();
-  virtual void updateProjection();
-  virtual void updateTransform();
-  FXVec3f spherePoint(FXint px,FXint py);
-  FXQuatf turn(FXint fx,FXint fy,FXint tx,FXint ty);
-  void drawWorld(FXViewport& wv);
-  void drawAnti(FXViewport& wv);
-  void drawLasso(FXint x0,FXint y0,FXint x1,FXint y1);
-  FXint selectHits(FXuint*& hits,FXint& nhits,FXint x,FXint y,FXint w,FXint h);
-  FXint renderFeedback(FXfloat *buffer,FXint x,FXint y,FXint w,FXint h,FXint maxbuffer);
-  void drawFeedback(FXDCPrint& pdc,const FXfloat* buffer,FXint used);
-  virtual FXGLObject* processHits(FXuint *pickbuffer,FXint nhits);
-  void setOp(FXuint o);
-private:
-  FXGLViewer(const FXGLViewer&);
-  FXGLViewer &operator=(const FXGLViewer&);
-  void initialize();
-public:
-
-  // Events
-  long onPaint(FXObject*,FXSelector,void*);
-  long onEnter(FXObject*,FXSelector,void*);
-  long onLeave(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onMouseWheel(FXObject*,FXSelector,void*);
-  long onChanged(FXObject*,FXSelector,void*);
-  long onPick(FXObject*,FXSelector,void*);
-  long onClicked(FXObject*,FXSelector,void*);
-  long onDoubleClicked(FXObject*,FXSelector,void*);
-  long onTripleClicked(FXObject*,FXSelector,void*);
-  long onLassoed(FXObject*,FXSelector,void*);
-  long onSelected(FXObject*,FXSelector,void*);
-  long onDeselected(FXObject*,FXSelector,void*);
-  long onInserted(FXObject*,FXSelector,void*);
-  long onDeleted(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onMiddleBtnPress(FXObject*,FXSelector,void*);
-  long onMiddleBtnRelease(FXObject*,FXSelector,void*);
-  long onRightBtnPress(FXObject*,FXSelector,void*);
-  long onRightBtnRelease(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onFocusIn(FXObject*,FXSelector,void*);
-  long onFocusOut(FXObject*,FXSelector,void*);
-  long onClipboardLost(FXObject*,FXSelector,void*);
-  long onClipboardGained(FXObject*,FXSelector,void*);
-  long onClipboardRequest(FXObject*,FXSelector,void*);
-
-  // Commands
-  long onCmdPerspective(FXObject*,FXSelector,void*);
-  long onUpdPerspective(FXObject*,FXSelector,void*);
-  long onCmdParallel(FXObject*,FXSelector,void*);
-  long onUpdParallel(FXObject*,FXSelector,void*);
-  long onCmdFront(FXObject*,FXSelector,void*);
-  long onUpdFront(FXObject*,FXSelector,void*);
-  long onCmdBack(FXObject*,FXSelector,void*);
-  long onUpdBack(FXObject*,FXSelector,void*);
-  long onCmdLeft(FXObject*,FXSelector,void*);
-  long onUpdLeft(FXObject*,FXSelector,void*);
-  long onCmdRight(FXObject*,FXSelector,void*);
-  long onUpdRight(FXObject*,FXSelector,void*);
-  long onCmdTop(FXObject*,FXSelector,void*);
-  long onUpdTop(FXObject*,FXSelector,void*);
-  long onCmdBottom(FXObject*,FXSelector,void*);
-  long onUpdBottom(FXObject*,FXSelector,void*);
-  long onCmdResetView(FXObject*,FXSelector,void*);
-  long onCmdFitView(FXObject*,FXSelector,void*);
-  long onDNDEnter(FXObject*,FXSelector,void*);
-  long onDNDLeave(FXObject*,FXSelector,void*);
-  long onDNDMotion(FXObject*,FXSelector,void*);
-  long onDNDDrop(FXObject*,FXSelector,void*);
-  long onTipTimer(FXObject*,FXSelector,void*);
-  long onCmdXYZDial(FXObject*,FXSelector,void*);
-  long onUpdXYZDial(FXObject*,FXSelector,void*);
-  long onCmdRollPitchYaw(FXObject*,FXSelector,void*);
-  long onUpdRollPitchYaw(FXObject*,FXSelector,void*);
-  long onCmdXYZScale(FXObject*,FXSelector,void*);
-  long onUpdXYZScale(FXObject*,FXSelector,void*);
-  long onUpdCurrent(FXObject*,FXSelector,void*);
-  long onCmdCutSel(FXObject*,FXSelector,void*);
-  long onCmdCopySel(FXObject*,FXSelector,void*);
-  long onCmdPasteSel(FXObject*,FXSelector,void*);
-  long onCmdDeleteSel(FXObject*,FXSelector,void*);
-  long onUpdDeleteSel(FXObject*,FXSelector,void*);
-  long onCmdBackColor(FXObject*,FXSelector,void*);
-  long onUpdBackColor(FXObject*,FXSelector,void*);
-  long onCmdGradientBackColor(FXObject*,FXSelector,void*);
-  long onUpdGradientBackColor(FXObject*,FXSelector,void*);
-  long onCmdAmbientColor(FXObject*,FXSelector,void*);
-  long onUpdAmbientColor(FXObject*,FXSelector,void*);
-  long onCmdLighting(FXObject*,FXSelector,void*);
-  long onUpdLighting(FXObject*,FXSelector,void*);
-  long onCmdFog(FXObject*,FXSelector,void*);
-  long onUpdFog(FXObject*,FXSelector,void*);
-  long onCmdDither(FXObject*,FXSelector,void*);
-  long onUpdDither(FXObject*,FXSelector,void*);
-  long onCmdFov(FXObject*,FXSelector,void*);
-  long onUpdFov(FXObject*,FXSelector,void*);
-  long onCmdZoom(FXObject*,FXSelector,void*);
-  long onUpdZoom(FXObject*,FXSelector,void*);
-  long onCmdLightAmbient(FXObject*,FXSelector,void*);
-  long onUpdLightAmbient(FXObject*,FXSelector,void*);
-  long onCmdLightDiffuse(FXObject*,FXSelector,void*);
-  long onUpdLightDiffuse(FXObject*,FXSelector,void*);
-  long onCmdLightSpecular(FXObject*,FXSelector,void*);
-  long onUpdLightSpecular(FXObject*,FXSelector,void*);
-  long onCmdTurbo(FXObject*,FXSelector,void*);
-  long onUpdTurbo(FXObject*,FXSelector,void*);
-  long onCmdPrintImage(FXObject*,FXSelector,void*);
-  long onCmdPrintVector(FXObject*,FXSelector,void*);
-  long onCmdLassoZoom(FXObject*,FXSelector,void*);
-  long onCmdLassoSelect(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-  virtual long onDefault(FXObject*,FXSelector,void*);
-
-public:
-
-  // Projection modes
-  enum {
-    PARALLEL,		  // Parallel projection
-    PERSPECTIVE		  // Perspective projection
-    };
-
-  // Messages
-  enum {
-    ID_PERSPECTIVE=FXGLCanvas::ID_LAST,
-    ID_PARALLEL,
-    ID_FRONT,
-    ID_BACK,
-    ID_LEFT,
-    ID_RIGHT,
-    ID_TOP,
-    ID_BOTTOM,
-    ID_RESETVIEW,
-    ID_FITVIEW,
-    ID_TOP_COLOR,
-    ID_BOTTOM_COLOR,
-    ID_BACK_COLOR,
-    ID_AMBIENT_COLOR,
-    ID_LIGHT_AMBIENT,
-    ID_LIGHT_DIFFUSE,
-    ID_LIGHT_SPECULAR,
-    ID_LIGHTING,
-    ID_TURBO,
-    ID_FOG,
-    ID_DITHER,
-    ID_SCALE_X,
-    ID_SCALE_Y,
-    ID_SCALE_Z,
-    ID_DIAL_X,
-    ID_DIAL_Y,
-    ID_DIAL_Z,
-    ID_ROLL,
-    ID_PITCH,
-    ID_YAW,
-    ID_FOV,
-    ID_ZOOM,
-    ID_CUT_SEL,
-    ID_COPY_SEL,
-    ID_PASTE_SEL,
-    ID_DELETE_SEL,
-    ID_PRINT_IMAGE,
-    ID_PRINT_VECTOR,
-    ID_LASSO_ZOOM,
-    ID_LASSO_SELECT,
-    ID_LAST
-    };
-
-public:
-
-  // Common DND type names
-  static const FXchar objectTypeName[];
-
-public:
-
-  /// Construct GL viewer widget
-  FXGLViewer(FXComposite* p,FXGLVisual *vis,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Construct GL viewer widget sharing display list with another GL viewer
-  FXGLViewer(FXComposite* p,FXGLVisual *vis,FXGLViewer* sharegroup,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Create all of the server-side resources for this window
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return size of pixel in world coordinates
-  FXdouble worldPix() const { return worldpx; }
-
-  /// Return size of pixel in model coordinates
-  FXdouble modelPix() const { return modelpx; }
-
-  /// Return a NULL-terminated list of all objects in the given rectangle, or NULL
-  FXGLObject** lasso(FXint x1,FXint y1,FXint x2,FXint y2);
-
-  /// Return a NULL-terminated list of all objects in the given rectangle, or NULL
-  virtual FXGLObject** select(FXint x,FXint y,FXint w,FXint h);
-
-  /// Perform a pick operation, returning the object at the given x,y position, or NULL
-  virtual FXGLObject* pick(FXint x,FXint y);
-
-  /// Change the model bounding box; this adjusts the viewer
-  virtual FXbool setBounds(const FXRangef& box);
-
-  /// Fit viewer to the given bounding box
-  FXbool fitToBounds(const FXRangef& box);
-
-  /// Return the viewer's viewport
-  void getViewport(FXViewport& v) const;
-
-  /// Translate eye-coordinate to screen coordinate
-  void eyeToScreen(FXint& sx,FXint& sy,FXVec3f e);
-
-  /// Translate screen coordinate to eye coordinate at the given depth
-  FXVec3f screenToEye(FXint sx,FXint sy,FXfloat eyez=0.0);
-
-  /// Translate screen coordinate to eye coordinate at the target point depth
-  FXVec3f screenToTarget(FXint sx,FXint sy);
-
-  /// Translate world coordinate to eye coordinate
-  FXVec3f worldToEye(FXVec3f w);
-
-  /// Translate world coordinate to eye coordinate depth
-  FXfloat worldToEyeZ(FXVec3f w);
-
-  /// Translate eye coordinate to eye coordinate
-  FXVec3f eyeToWorld(FXVec3f e);
-
-  /// Calculate world coordinate vector from screen movement
-  FXVec3f worldVector(FXint fx,FXint fy,FXint tx,FXint ty);
-
-  ///  Change default object material setting
-  void setMaterial(const FXMaterial &mtl);
-
-  /// Return default object material setting
-  void getMaterial(FXMaterial &mtl) const;
-
-  /// Change camera field of view angle (in degrees)
-  void setFieldOfView(FXdouble fv);
-
-  /// Return camera field of view angle
-  FXdouble getFieldOfView() const { return fov; }
-
-  /// Change camera zoom factor
-  void setZoom(FXdouble zm);
-
-  /// Return camera zoom factor
-  FXdouble getZoom() const { return zoom; }
-
-  /// Change target point distance
-  void setDistance(FXdouble ed);
-
-  /// Return target point distance
-  FXdouble getDistance() const { return distance; }
-
-  /// Change unequal model scaling factors
-  void setScale(FXVec3f s);
-
-  /// Return current scaling factors
-  const FXVec3f& getScale() const { return scale; }
-
-  /// Change camera orientation from quaternion
-  void setOrientation(FXQuatf rot);
-
-  /// Return current camera orientation quaternion
-  const FXQuatf& getOrientation() const { return rotation; }
-
-  /// Change object center (tranlation)
-  void setCenter(FXVec3f cntr);
-
-  /// Return object center
-  const FXVec3f& getCenter() const { return center; }
-
-  /// Translate object center
-  void translate(FXVec3f vec);
-
-  /// Return boresight vector
-  FXbool getBoreVector(FXint sx,FXint sy,FXVec3f& point,FXVec3f& dir);
-
-  /// Return eyesight vector
-  FXVec3f getEyeVector() const;
-
-  /// Return eye position
-  FXVec3f getEyePosition() const;
-
-  /// Change help text
-  void setHelpText(const FXString& text);
-
-  /// Return help text
-  const FXString& getHelpText() const { return help; }
-
-  /// Change tip text
-  void setTipText(const FXString&  text);
-
-  /// Return tip text
-  const FXString& getTipText() const { return tip; }
-
-  /// Return the current transformation matrix
-  const FXMat4f& getTransform() const { return transform; }
-
-  /// Return the inverse of the current transformation matrix
-  const FXMat4f& getInvTransform() const { return itransform; }
-
-  /// Change the scene, i.e. the object being displayed.
-  void setScene(FXGLObject* sc);
-
-  /// Return the current scene object
-  FXGLObject* getScene() const { return scene; }
-
-  /// Change selection
-  void setSelection(FXGLObject* sel);
-
-  /// Return selection
-  FXGLObject* getSelection() const { return selection; }
-
-  /// Change the projection mode, PERSPECTIVE or PARALLEL
-  void setProjection(FXuint proj);
-
-  /// Return the projection mode
-  FXuint getProjection() const { return projection; }
-
-  /// Change top or bottom or both background colors
-  void setBackgroundColor(const FXVec4f& clr,FXbool bottom=MAYBE);
-
-  /// Return top or bottom window background color.
-  const FXVec4f& getBackgroundColor(FXbool bottom=FALSE) const { return background[bottom]; }
-
-  /// Change global ambient light color
-  void setAmbientColor(const FXVec4f& clr);
-
-  /// Return global ambient light color
-  const FXVec4f& getAmbientColor() const { return ambient; }
-
-  /**
-  * Read the pixels off the screen as array of FXColor;
-  * this array can be directly passed to fxsaveBMP and other image
-  * output routines.
-  */
-  FXbool readPixels(FXColor*& buffer,FXint x,FXint y,FXint w,FXint h);
-
-  /**
-  * Read the feedback buffer containing the current scene, returning used
-  * and allocated size.
-  */
-  FXbool readFeedback(FXfloat*& buffer,FXint& used,FXint& size,FXint x,FXint y,FXint w,FXint h);
-
-  /**
-  * Change hidden-surface feedback buffer sorting algorithm.
-  * This can be used for move/draw printed output depth sorting.
-  */
-  void setZSortFunc(FXZSortFunc func){ zsortfunc=func; }
-
-  /// Return hidden surface sorting function.
-  FXZSortFunc getZSortFunc() const { return zsortfunc; }
-
-  /**
-  * Change the maximum hits, i.e. the maximum size of the pick buffer.
-  * When set to less than or equal to zero, picking is essentially turned off.
-  */
-  void setMaxHits(FXint maxh) { maxhits=maxh; }
-
-  /// Return maximum pickbuffer size
-  FXint getMaxHits() const { return maxhits; }
-
-  /**
-  * When drawing a GL object, if doesTurbo() is true, the object
-  * may choose to perform a reduced complexity drawing as the user is
-  * interactively manipulating; another update will be done later when
-  * the full complexity drawing can be performed again.
-  */
-  FXbool doesTurbo() const { return doesturbo; }
-
-  /// Return turbo mode setting
-  FXbool getTurboMode() const { return turbomode; }
-
-  /// Set turbo mode
-  void setTurboMode(FXbool turbo=TRUE);
-
-  /// Return light source settings
-  void getLight(FXLight& lite) const;
-
-  /// Change light source settings
-  void setLight(const FXLight& lite);
-
-  /// Save viewer to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load viewer from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXGLViewer();
-  };
-
-}
-
-#endif
-
diff --git a/fox-includes/FXGLVisual.h b/fox-includes/FXGLVisual.h
deleted file mode 100755
index 9fa76b39..00000000
--- a/fox-includes/FXGLVisual.h
+++ /dev/null
@@ -1,155 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                            V i s u a l   C l a s s                            *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1999,2004 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXGLVisual.h 1889 2004-05-26 03:13:01Z lyle $                        *
-********************************************************************************/
-#ifndef FXGLVISUAL_H
-#define FXGLVISUAL_H
-
-#ifndef FXVISUAL_H
-#include "FXVisual.h"
-#endif
-
-namespace FX {
-
-
-class FXFont;
-class FXWindow;
-class FXImage;
-class FXIcon;
-class FXBitmap;
-class FXDCWindow;
-class FXGLCanvas;
-
-
-/// Visual describes pixel format of a drawable
-class FXAPI FXGLVisual : public FXVisual {
-  FXDECLARE(FXGLVisual)
-  friend class FXWindow;
-  friend class FXImage;
-  friend class FXIcon;
-  friend class FXBitmap;
-  friend class FXDCWindow;
-  friend class FXGLCanvas;
-protected:
-  FXint        redSize;             // Desired #bits for red
-  FXint        greenSize;           // Desired #bits for green
-  FXint        blueSize;            // Desired #bits for blue
-  FXint        alphaSize;           // Desired #bits for alpha
-  FXint        depthSize;           // Desired #bits for Z
-  FXint        stencilSize;         // Desired #bits for stencil
-  FXint        accumRedSize;        // Desired #bits for accum red
-  FXint        accumGreenSize;      // Desired #bits for accum green
-  FXint        accumBlueSize;       // Desired #bits for accum blue
-  FXint        accumAlphaSize;      // Desired #bits for accum alpha
-protected:
-  FXGLVisual();
-private:
-  FXGLVisual(const FXGLVisual&);
-  FXGLVisual &operator=(const FXGLVisual&);
-public:
-
-  /// Construct default visual
-  FXGLVisual(FXApp* a,FXuint flags);
-
-  /**
-  * Test if OpenGL is possible, and what level is supported.
-  * Because of remote display capability, the display server may
-  * support a different level of OpenGL than the client; it may
-  * even support no OpenGL at all!  This function returns the lesser
-  * of the client support level and the display server support level.
-  */
-  static FXbool supported(FXApp* application,int& major,int& minor);
-
-  /// Create visual
-  virtual void create();
-
-  /// Detach visual
-  virtual void detach();
-
-  /// Destroy visual
-  virtual void destroy();
-
-  /// Get sizes for bit-planes
-  FXint getRedSize() const { return redSize; }
-  FXint getGreenSize() const { return greenSize; }
-  FXint getBlueSize() const { return blueSize; }
-  FXint getAlphaSize() const { return alphaSize; }
-  FXint getDepthSize() const { return depthSize; }
-  FXint getStencilSize() const { return stencilSize; }
-  FXint getAccumRedSize() const { return accumRedSize; }
-  FXint getAccumGreenSize() const { return accumGreenSize; }
-  FXint getAccumBlueSize() const { return accumBlueSize; }
-  FXint getAccumAlphaSize() const { return accumAlphaSize; }
-
-  /// Set sizes for bit-planes
-  void setRedSize(FXint rs){ redSize=rs; }
-  void setGreenSize(FXint gs){ greenSize=gs; }
-  void setBlueSize(FXint bs){ blueSize=bs; }
-  void setAlphaSize(FXint as){ alphaSize=as; }
-  void setDepthSize(FXint ds){ depthSize=ds; }
-  void setStencilSize(FXint ss){ stencilSize=ss; }
-  void setAccumRedSize(FXint rs){ accumRedSize=rs; }
-  void setAccumGreenSize(FXint gs){ accumGreenSize=gs; }
-  void setAccumBlueSize(FXint bs){ accumBlueSize=bs; }
-  void setAccumAlphaSize(FXint as){ accumAlphaSize=as; }
-
-  /// Get ACTUAL sizes for bit-planes
-  FXint getActualRedSize() const;
-  FXint getActualGreenSize() const;
-  FXint getActualBlueSize() const;
-  FXint getActualAlphaSize() const;
-  FXint getActualDepthSize() const;
-  FXint getActualStencilSize() const;
-  FXint getActualAccumRedSize() const;
-  FXint getActualAccumGreenSize() const;
-  FXint getActualAccumBlueSize() const;
-  FXint getActualAccumAlphaSize() const;
-
-  /// Is it double buffered?
-  FXbool isDoubleBuffer() const;
-
-  /// Is it stereo?
-  FXbool isStereo() const;
-
-  /// Is it hardware-accelerated?
-  FXbool isAccelerated() const;
-
-  /// Does it swap by copying instead of flipping buffers
-  FXbool isBufferSwapCopy() const;
-
-  /// Save visual info to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load visual info to a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXGLVisual();
-  };
-
-
-/// Create a display list of bitmaps from font glyphs in a font
-extern FXAPI void glUseFXFont(FXFont* font,int first,int count,int list);
-
-}
-
-#endif
diff --git a/fox-includes/FXGUISignal.h b/fox-includes/FXGUISignal.h
deleted file mode 100644
index 4a3d5ebf..00000000
--- a/fox-includes/FXGUISignal.h
+++ /dev/null
@@ -1,108 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        S i g n a l   G U I   T h r e a d                      *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2005 by Jeroen van der Zijp.   All Rights Reserved.             *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXGUISignal.h 2291 2005-12-05 03:37:36Z lyle $                        *
-********************************************************************************/
-#ifndef FXGUISIGNAL_H
-#define FXGUISIGNAL_H
-
-#ifndef FXOBJECT_H
-#include "FXObject.h"
-#endif
-
-namespace FX {
-
-class FXApp;
-
-
-/**
-* A GUI Signal is an object used by a worker thread to signal the
-* user interface thread of some event; it wakes up the user interface
-* thread from the blocking state and causes it to send the given message
-* to the GUI Signal object's target.
-*/
-class FXAPI FXGUISignal : public FXObject {
-  FXDECLARE(FXGUISignal)
-private:
-  FXApp     *app;       // Application
-protected:
-  FXObject  *target;    // Target object
-  void      *data;      // User data
-  FXSelector message;   // Message id
-private:
-#ifndef WIN32
-  FXInputHandle fd[2];
-#else
-  FXInputHandle event;
-#endif
-protected:
-  FXGUISignal();
-private:
-  FXGUISignal(const FXGUISignal&);
-  FXGUISignal& operator=(const FXGUISignal&);
-public:
-  enum{
-    ID_IO_READ=0,
-    ID_LAST
-    };
-public:
-  long onSignal(FXObject*,FXSelector,void*);
-public:
-
-  /// Constructor
-  FXGUISignal(FXApp* a,FXObject* tgt=NULL,FXSelector sel=0,void* ptr=NULL);
-
-  /// Get application
-  FXApp* getApp() const { return app; }
-
-  /// Set the message target object
-  void setTarget(FXObject *t){ target=t; }
-
-  /// Get the message target object, if any
-  FXObject* getTarget() const { return target; }
-
-  /// Set the message identifier
-  void setSelector(FXSelector sel){ message=sel; }
-
-  /// Get the message identifier
-  FXSelector getSelector() const { return message; }
-
-  /// Set user data pointer
-  void setData(void *ptr){ data=ptr; }
-
-  /// Get user data pointer
-  void* getData() const { return data; }
-
-  /**
-  * Signal the event; this API may be called by the worker thread
-  * to send a message to the user-interface thread.
-  */
-  void signal();
-
-  /// Destructor
-  virtual ~FXGUISignal();
-  };
-
-}
-
-#endif
-
-
diff --git a/fox-includes/FXGZFileStream.h b/fox-includes/FXGZFileStream.h
deleted file mode 100644
index 797f1580..00000000
--- a/fox-includes/FXGZFileStream.h
+++ /dev/null
@@ -1,126 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                     G Z F i l e S t r e a m   C l a s s e s                   *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2002,2005 by Sander Jansen.   All Rights Reserved.              *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXGZFileStream.h 2336 2006-02-04 15:20:33Z lyle $                     *
-********************************************************************************/
-#ifdef HAVE_ZLIB_H
-#ifndef FXGZFILESTREAM_H
-#define FXGZFILESTREAM_H
-
-#ifndef FXFILESTREAM_H
-#include "FXFileStream.h"
-#endif
-
-
-namespace FX {
-
-
-struct ZBlock;
-
-
-/// GZIP compressed stream
-class FXAPI FXGZFileStream : public FXFileStream {
-private:
-  ZBlock *z;
-  int     f;
-protected:
-  virtual FXuval writeBuffer(FXuval count);
-  virtual FXuval readBuffer(FXuval count);
-public:
-
-  /// Create GZIP compressed file stream
-  FXGZFileStream(const FXObject* cont=NULL);
-
-  /// Open file stream
-  bool open(const FXString& filename,FXStreamDirection save_or_load,FXuval size=8192);
-
-  /// Close file stream
-  virtual bool close();
-
-  /// Get position
-  FXlong position() const { return FXStream::position(); }
-
-  /// Move to position
-  virtual bool position(FXlong,FXWhence){ return FALSE; }
-
-  /// Save single items to stream
-  FXGZFileStream& operator<<(const FXuchar& v){ FXStream::operator<<(v); return *this; }
-  FXGZFileStream& operator<<(const FXchar& v){ FXStream::operator<<(v); return *this; }
-  FXGZFileStream& operator<<(const FXushort& v){ FXStream::operator<<(v); return *this; }
-  FXGZFileStream& operator<<(const FXshort& v){ FXStream::operator<<(v); return *this; }
-  FXGZFileStream& operator<<(const FXuint& v){ FXStream::operator<<(v); return *this; }
-  FXGZFileStream& operator<<(const FXint& v){ FXStream::operator<<(v); return *this; }
-  FXGZFileStream& operator<<(const FXfloat& v){ FXStream::operator<<(v); return *this; }
-  FXGZFileStream& operator<<(const FXdouble& v){ FXStream::operator<<(v); return *this; }
-  FXGZFileStream& operator<<(const FXlong& v){ FXStream::operator<<(v); return *this; }
-  FXGZFileStream& operator<<(const FXulong& v){ FXStream::operator<<(v); return *this; }
-
-  /// Save arrays of items to stream
-  FXGZFileStream& save(const FXuchar* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXGZFileStream& save(const FXchar* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXGZFileStream& save(const FXushort* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXGZFileStream& save(const FXshort* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXGZFileStream& save(const FXuint* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXGZFileStream& save(const FXint* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXGZFileStream& save(const FXfloat* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXGZFileStream& save(const FXdouble* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXGZFileStream& save(const FXlong* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXGZFileStream& save(const FXulong* p,FXuval n){ FXStream::save(p,n); return *this; }
-
-  /// Load single items from stream
-  FXGZFileStream& operator>>(FXuchar& v){ FXStream::operator>>(v); return *this; }
-  FXGZFileStream& operator>>(FXchar& v){ FXStream::operator>>(v); return *this; }
-  FXGZFileStream& operator>>(FXushort& v){ FXStream::operator>>(v); return *this; }
-  FXGZFileStream& operator>>(FXshort& v){ FXStream::operator>>(v); return *this; }
-  FXGZFileStream& operator>>(FXuint& v){ FXStream::operator>>(v); return *this; }
-  FXGZFileStream& operator>>(FXint& v){ FXStream::operator>>(v); return *this; }
-  FXGZFileStream& operator>>(FXfloat& v){ FXStream::operator>>(v); return *this; }
-  FXGZFileStream& operator>>(FXdouble& v){ FXStream::operator>>(v); return *this; }
-  FXGZFileStream& operator>>(FXlong& v){ FXStream::operator>>(v); return *this; }
-  FXGZFileStream& operator>>(FXulong& v){ FXStream::operator>>(v); return *this; }
-
-  /// Load arrays of items from stream
-  FXGZFileStream& load(FXuchar* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXGZFileStream& load(FXchar* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXGZFileStream& load(FXushort* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXGZFileStream& load(FXshort* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXGZFileStream& load(FXuint* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXGZFileStream& load(FXint* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXGZFileStream& load(FXfloat* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXGZFileStream& load(FXdouble* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXGZFileStream& load(FXlong* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXGZFileStream& load(FXulong* p,FXuval n){ FXStream::load(p,n); return *this; }
-
-  /// Save object
-  FXGZFileStream& saveObject(const FXObject* v){ FXStream::saveObject(v); return *this; }
-
-  /// Load object
-  FXGZFileStream& loadObject(FXObject*& v){ FXStream::loadObject(v); return *this; }
-
-  /// Clean up
-  virtual ~FXGZFileStream();
-  };
-
-}
-
-
-#endif
-#endif
diff --git a/fox-includes/FXGradientBar.h b/fox-includes/FXGradientBar.h
deleted file mode 100755
index 5b5a5230..00000000
--- a/fox-includes/FXGradientBar.h
+++ /dev/null
@@ -1,331 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                      G r a d i e n t B a r   W i d g e t                      *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2002,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXGradientBar.h 2127 2005-08-07 20:21:35Z lyle $                     *
-********************************************************************************/
-#ifndef FXGRADIENTBAR_H
-#define FXGRADIENTBAR_H
-
-#ifndef FXFRAME_H
-#include "FXFrame.h"
-#endif
-
-
-namespace FX {
-
-
-
-/// Gradient bar orientation
-enum {
-  GRADIENTBAR_HORIZONTAL      = 0,                          /// Gradient bar shown horizontally
-  GRADIENTBAR_VERTICAL        = 0x00008000,                 /// Gradient bar shown vertically
-  GRADIENTBAR_NO_CONTROLS     = 0,                          /// No controls shown
-  GRADIENTBAR_CONTROLS_TOP    = 0x00010000,                 /// Controls on top
-  GRADIENTBAR_CONTROLS_BOTTOM = 0x00020000,                 /// Controls on bottom
-  GRADIENTBAR_CONTROLS_LEFT   = GRADIENTBAR_CONTROLS_TOP,   /// Controls on left
-  GRADIENTBAR_CONTROLS_RIGHT  = GRADIENTBAR_CONTROLS_BOTTOM /// Controls on right
-  };
-
-
-/// Blend modes
-enum {
-  GRADIENT_BLEND_LINEAR,                /// Linear blend
-  GRADIENT_BLEND_POWER,                 /// Power law blend
-  GRADIENT_BLEND_SINE,                  /// Sine blend
-  GRADIENT_BLEND_INCREASING,            /// Quadratic increasing blend
-  GRADIENT_BLEND_DECREASING             /// Quadratic decreasing blend
-  };
-
-
-
-// Gradient segment
-struct FXGradient {
-  FXdouble lower;                     /// Lower value
-  FXdouble middle;                    /// Middle value
-  FXdouble upper;                     /// Upper value
-  FXColor  lowerColor;                /// Lower color
-  FXColor  upperColor;                /// Upper color
-  FXuchar  blend;                     /// Blend method
-  };
-
-
-class FXImage;
-
-
-/**
-* The gradient bar is a control that is used to edit color gradient,
-* such as used in texture mapping and shape filling.
-*/
-class FXAPI FXGradientBar : public FXFrame {
-  FXDECLARE(FXGradientBar)
-protected:
-  FXImage     *bar;                     // Image containing colors
-  FXGradient  *seg;                     // Segments
-  FXint        nsegs;                   // Number of segments
-  FXint        sellower;                // Lower selected segment
-  FXint        selupper;                // Upper selected segment
-  FXint        dropped;                 // Dropped segment
-  FXint        current;                 // Current segment
-  FXint        anchor;                  // Anchor segment
-  FXint        grip;                    // Grip being dragged, if any
-  FXint        where;                   // Where dropped in segment
-  FXString     tip;                     // Tooltip value
-  FXString     help;                    // Help value
-  FXColor      selectColor;             // Select color
-  FXint        offset;                  // Offset
-protected:
-  FXGradientBar();
-  void updatebar();
-  FXdouble getValue(FXint x,FXint y) const;
-  FXint getSegmentLowerPos(FXint sg) const;
-  FXint getSegmentUpperPos(FXint sg) const;
-  FXint getSegmentMiddlePos(FXint sg) const;
-  void drawUpArrow(FXDCWindow& dc,FXint x,FXint y,FXColor clr);
-  void drawDnArrow(FXDCWindow& dc,FXint x,FXint y,FXColor clr);
-  void drawRtArrow(FXDCWindow& dc,FXint x,FXint y,FXColor clr);
-  void drawLtArrow(FXDCWindow& dc,FXint x,FXint y,FXColor clr);
-  void drawBottomArrows(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawTopArrows(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawLeftArrows(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawRightArrows(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  static FXdouble blendlinear(FXdouble middle,FXdouble pos);
-  static FXdouble blendpower(FXdouble middle,FXdouble pos);
-  static FXdouble blendsine(FXdouble middle,FXdouble pos);
-  static FXdouble blendincreasing(FXdouble middle,FXdouble pos);
-  static FXdouble blenddecreasing(FXdouble middle,FXdouble pos);
-private:
-  FXGradientBar(const FXGradientBar&);
-  FXGradientBar &operator=(const FXGradientBar&);
-public:
-  enum {
-    GRIP_NONE,
-    GRIP_LOWER,
-    GRIP_SEG_LOWER,
-    GRIP_MIDDLE,
-    GRIP_SEG_UPPER,
-    GRIP_UPPER
-    };
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onDNDEnter(FXObject*,FXSelector,void*);
-  long onDNDLeave(FXObject*,FXSelector,void*);
-  long onDNDMotion(FXObject*,FXSelector,void*);
-  long onDNDDrop(FXObject*,FXSelector,void*);
-  long onCmdBlending(FXObject*,FXSelector,void*);
-  long onUpdBlending(FXObject*,FXSelector,void*);
-  long onUpdSegColor(FXObject*,FXSelector,void*);
-  long onCmdSegColor(FXObject*,FXSelector,void*);
-  long onUpdRecenter(FXObject*,FXSelector,void*);
-  long onCmdRecenter(FXObject*,FXSelector,void*);
-  long onUpdSplit(FXObject*,FXSelector,void*);
-  long onCmdSplit(FXObject*,FXSelector,void*);
-  long onUpdMerge(FXObject*,FXSelector,void*);
-  long onCmdMerge(FXObject*,FXSelector,void*);
-  long onUpdUniform(FXObject*,FXSelector,void*);
-  long onCmdUniform(FXObject*,FXSelector,void*);
-  long onCmdSetHelp(FXObject*,FXSelector,void*);
-  long onCmdGetHelp(FXObject*,FXSelector,void*);
-  long onCmdSetTip(FXObject*,FXSelector,void*);
-  long onCmdGetTip(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-public:
-  enum{
-    ID_LOWER_COLOR=FXFrame::ID_LAST,
-    ID_UPPER_COLOR,
-    ID_BLEND_LINEAR,
-    ID_BLEND_POWER,
-    ID_BLEND_SINE,
-    ID_BLEND_INCREASING,
-    ID_BLEND_DECREASING,
-    ID_RECENTER,
-    ID_SPLIT,
-    ID_MERGE,
-    ID_UNIFORM,
-    ID_LAST
-    };
-public:
-
-  /// Construct a gradient bar
-  FXGradientBar(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=FRAME_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /**
-   * Obtain segment containing location x, y.
-   * Returns -1 if no matching segment was found.
-   */
-  FXint getSegment(FXint x,FXint y) const;
-
-  /**
-   * Get the grip in segment sg which is closest to location (x, y),
-   * one of GRIP_LOWER, GRIP_SEG_LOWER, GRIP_MIDDLE, GRIP_SEG_UPPER,
-   * GRIP_UPPER or GRIP_NONE.
-   */
-  FXint getGrip(FXint sg,FXint x,FXint y) const;
-
-  /// Return the number of segments
-  FXint getNumSegments() const { return nsegs; }
-
-  /**
-   * Replace the current gradient segments.
-   * The gradient bar makes a copy of the input segments array.
-   */
-  void setGradients(const FXGradient *segments,FXint nsegments);
-
-  /**
-   * Return a copy of the gradient segments.
-   * The array of segments is allocated using FXMALLOC and should be freed
-   * by the caller using FXFREE.
-   */
-  void getGradients(FXGradient*& segments,FXint& nsegments) const;
-
-  /// Change current segment
-  void setCurrentSegment(FXint index,FXbool notify=FALSE);
-
-  /// Return current segment, or -1 if there is no current segment
-  FXint getCurrentSegment() const { return current; }
-
-  /// Change anchor segment
-  void setAnchorSegment(FXint index);
-
-  /// Return anchor segment, or -1 if there is no anchor segment
-  FXint getAnchorSegment() const { return anchor; }
-
-  /// Select segment(s)
-  FXbool selectSegments(FXint fm,FXint to,FXbool notify=FALSE);
-
-  /// Deselect all segments
-  FXbool deselectSegments(FXbool notify);
-
-  /// Returns TRUE if the specified segment is selected
-  FXbool isSegmentSelected(FXint s) const;
-
-  /// Set lower color of a segment
-  void setSegmentLowerColor(FXint s,FXColor clr,FXbool notify=FALSE);
-
-  /// Set upper color of a segment
-  void setSegmentUpperColor(FXint s,FXColor clr,FXbool notify=FALSE);
-
-  /// Get lower color of a segment
-  FXColor getSegmentLowerColor(FXint s) const;
-
-  /// Get upper color of a segment
-  FXColor getSegmentUpperColor(FXint s) const;
-
-  /// Move lower point of segment sg
-  void moveSegmentLower(FXint sg,FXdouble val,FXbool notify=FALSE);
-
-  /// Move middle point of segment sg
-  void moveSegmentMiddle(FXint sg,FXdouble val,FXbool notify=FALSE);
-
-  /// Move upper point of segment sg
-  void moveSegmentUpper(FXint sg,FXdouble val,FXbool notify=FALSE);
-
-  /// Move segments sglo to sghi to new position val
-  void moveSegments(FXint sglo,FXint sghi,FXdouble val,FXbool notify=FALSE);
-
-  /// Get lower value of segment sg
-  FXdouble getSegmentLower(FXint sg) const;
-
-  /// Get middle value of segment sg
-  FXdouble getSegmentMiddle(FXint sg) const;
-
-  /// Get upper value of segment sg
-  FXdouble getSegmentUpper(FXint sg) const;
-
-  /**
-   * Get gradient ramp.
-   * The ramp argument should be an array of size nramp, which will be
-   * filled with the appropriate color values.
-   */
-  void gradient(FXColor *ramp,FXint nramp);
-
-  /**
-   * Get blend mode of segment, one of GRADIENT_BLEND_LINEAR,
-   * GRADIENT_BLEND_POWER, GRADIENT_BLEND_SINE, GRADIENT_BLEND_INCREASING,
-   * or GRADIENT_BLEND_DECREASING.
-   */
-  FXuint getSegmentBlend(FXint s) const;
-
-  /// Split segment at the midpoint
-  void splitSegments(FXint sglo,FXint sghi,FXbool notify=FALSE);
-
-  /// Merge segments
-  void mergeSegments(FXint sglo,FXint sghi,FXbool notify=FALSE);
-
-  /// Make segments uniformly distributed
-  void uniformSegments(FXint sglo,FXint sghi,FXbool notify=FALSE);
-
-  /// Change blend mode of segment
-  void blendSegments(FXint sglo,FXint sghi,FXuint blend=GRADIENT_BLEND_LINEAR,FXbool notify=FALSE);
-
-  /// Get the gradient bar style
-  FXuint getBarStyle() const;
-
-  /// Change the gradient bar style
-  void setBarStyle(FXuint style);
-
-  /// Set color
-  void setSelectColor(FXColor clr);
-
-  /// Get color
-  FXColor getSelectColor() const { return selectColor; }
-
-  /// Set status line help text for this gradient bar
-  void setHelpText(const FXString& text){ help=text; }
-
-  /// Get status line help text for this gradient bar
-  const FXString& getHelpText() const { return help; }
-
-  /// Set tool tip message for this gradient bar
-  void setTipText(const FXString& text){ tip=text; }
-
-  /// Get tool tip message for this gradient bar
-  const FXString& getTipText() const { return tip; }
-
-  /// Save gradient bar to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load gradient bar from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXGradientBar();
-  };
-
-
-}
-
-#endif
diff --git a/fox-includes/FXGroupBox.h b/fox-includes/FXGroupBox.h
deleted file mode 100755
index 35d5de33..00000000
--- a/fox-includes/FXGroupBox.h
+++ /dev/null
@@ -1,125 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                G r o u p  B o x   W i n d o w   W i d g e t                   *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXGroupBox.h 2232 2005-11-09 03:18:19Z lyle $                        *
-********************************************************************************/
-#ifndef FXGROUPBOX_H
-#define FXGROUPBOX_H
-
-#ifndef FXPACKER_H
-#include "FXPacker.h"
-#endif
-
-namespace FX {
-
-
-// Group box options
-enum {
-  GROUPBOX_TITLE_LEFT   = 0,	        /// Title is left-justified
-  GROUPBOX_TITLE_CENTER = 0x00020000,	/// Title is centered
-  GROUPBOX_TITLE_RIGHT  = 0x00040000,	/// Title is right-justified
-  GROUPBOX_NORMAL       = GROUPBOX_TITLE_LEFT
-  };
-
-
-
-/**
-* A group box widget provides a nice raised or sunken border
-* around a group of widgets, providing a visual delineation.
-* Typically, a title is placed over the border to provide some
-* clarification.
-*/
-class FXAPI FXGroupBox : public FXPacker {
-  FXDECLARE(FXGroupBox)
-protected:
-  FXString  label;
-  FXFont   *font;
-  FXColor   textColor;
-protected:
-  FXGroupBox();
-private:
-  FXGroupBox(const FXGroupBox&);
-  FXGroupBox &operator=(const FXGroupBox&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetStringValue(FXObject*,FXSelector,void*);
-  long onCmdGetStringValue(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct group box layout manager
-  FXGroupBox(FXComposite* p,const FXString& text,FXuint opts=GROUPBOX_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_SPACING,FXint pr=DEFAULT_SPACING,FXint pt=DEFAULT_SPACING,FXint pb=DEFAULT_SPACING,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Enable the window
-  virtual void enable();
-
-  /// Disable the window
-  virtual void disable();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Change group box title text
-  void setText(const FXString& text);
-
-  /// Return current groupbox title text
-  FXString getText() const { return label; }
-
-  /// Change group box style
-  void setGroupBoxStyle(FXuint style);
-
-  /// Return current group box style
-  FXuint getGroupBoxStyle() const;
-
-  /// Change title font
-  void setFont(FXFont* fnt);
-
-  /// Return title font
-  FXFont* getFont() const { return font; }
-
-  /// Change title text color
-  void setTextColor(FXColor clr);
-
-  /// Return text color
-  FXColor getTextColor() const { return textColor; }
-
-  /// Save to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from a stream
-  virtual void load(FXStream& store);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXHash.h b/fox-includes/FXHash.h
deleted file mode 100755
index 7ce739b9..00000000
--- a/fox-includes/FXHash.h
+++ /dev/null
@@ -1,92 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       H a s h   T a b l e   C l a s s                         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2003,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXHash.h 2336 2006-02-04 15:20:33Z lyle $                            *
-********************************************************************************/
-#ifndef FXHASH_H
-#define FXHASH_H
-
-namespace FX {
-
-
-/**
-* A hash table for associating pointers to pointers.
-*/
-class FXAPI FXHash {
-private:
-  struct FXEntry {
-    void* key;
-    void* value;
-    };
-private:
-  FXEntry *table;       // Hash table
-  FXuint   total;       // Table size
-  FXuint   used;        // Number of used entries
-  FXuint   free;        // Number of free entries
-private:
-  FXHash(const FXHash&);
-  FXHash &operator=(const FXHash&);
-public:
-
-  /// Construct empty hash table
-  FXHash();
-
-  /// Resize the table to the given size.
-  void size(FXuint m);
-
-  /// Return the size of the table
-  FXint size() const { return total; }
-
-  /// Return number of items in table
-  FXuint no() const { return used; }
-
-  /// Insert key into the table
-  void* insert(void* key,void* value);
-
-  /// Replace key in table
-  void* replace(void* key,void* value);
-
-  /// Remove key from the table
-  void* remove(void* key);
-
-  /// Return value of key
-  void* find(void* key) const;
-
-  /// Return true if slot is empty
-  bool empty(FXint pos) const { return (table[pos].key==NULL)||(table[pos].key==(void*)-1L); }
-
-  /// Return key at position pos
-  void* key(FXint pos) const { return table[pos].key; }
-
-  /// Return data pointer at position pos
-  void* value(FXint pos) const { return table[pos].value; }
-
-  /// Clear hash table
-  void clear();
-
-  /// Destructor
-  virtual ~FXHash();
-  };
-
-
-}
-
-#endif
diff --git a/fox-includes/FXHeader.h b/fox-includes/FXHeader.h
deleted file mode 100755
index 19206b63..00000000
--- a/fox-includes/FXHeader.h
+++ /dev/null
@@ -1,402 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                          H e a d e r   W i d g e t                            *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXHeader.h 2343 2006-02-12 20:26:26Z lyle $                          *
-********************************************************************************/
-#ifndef FXHEADER_H
-#define FXHEADER_H
-
-#ifndef FXFRAME_H
-#include "FXFrame.h"
-#endif
-
-namespace FX {
-
-class FXIcon;
-class FXFont;
-class FXHeader;
-
-
-/// Header style options
-enum {
-  HEADER_BUTTON     = 0x00008000,     /// Button style can be clicked
-  HEADER_HORIZONTAL = 0,              /// Horizontal header control (default)
-  HEADER_VERTICAL   = 0x00010000,     /// Vertical header control
-  HEADER_TRACKING   = 0x00020000,     /// Tracks continuously while moving
-  HEADER_RESIZE     = 0x00040000,     /// Allow resizing sections
-  HEADER_NORMAL     = HEADER_HORIZONTAL|FRAME_NORMAL
-  };
-
-
-/// Header item
-class FXAPI FXHeaderItem : public FXObject {
-  FXDECLARE(FXHeaderItem)
-  friend class FXHeader;
-protected:
-  FXString  label;      // Text of item
-  FXIcon   *icon;       // Icon of item
-  void     *data;       // Item user data pointer
-  FXint     size;       // Item size
-  FXint     pos;        // Item position
-  FXuint    state;      // Item state flags
-private:
-  FXHeaderItem(const FXHeaderItem&);
-  FXHeaderItem& operator=(const FXHeaderItem&);
-protected:
-  FXHeaderItem(){}
-  virtual void draw(const FXHeader* header,FXDC& dc,FXint x,FXint y,FXint w,FXint h);
-public:
-  enum{
-    ARROW_NONE = 0,     /// No arrow
-    ARROW_UP   = 1,     /// Arrow pointing up
-    ARROW_DOWN = 2,     /// Arrow pointing down
-    PRESSED    = 4,     /// Pressed down
-    RIGHT      = 8,     /// Align on right
-    LEFT       = 16,    /// Align on left
-    CENTER_X   = 0,     /// Aling centered horizontally (default)
-    TOP        = 32,    /// Align on top
-    BOTTOM     = 64,    /// Align on bottom
-    CENTER_Y   = 0,     /// Aling centered vertically (default)
-    BEFORE     = 128,   /// Icon before the text
-    AFTER      = 256,   /// Icon after the text
-    ABOVE      = 512,   /// Icon above the text
-    BELOW      = 1024   /// Icon below the text
-    };
-public:
-
-  /// Construct new item with given text, icon, size, and user-data
-  FXHeaderItem(const FXString& text,FXIcon* ic=NULL,FXint s=0,void* ptr=NULL):label(text),icon(ic),data(ptr),size(s),pos(0),state(LEFT|BEFORE){}
-
-  /// Change item's text label
-  virtual void setText(const FXString& txt);
-
-  /// Return item's text label
-  const FXString& getText() const { return label; }
-
-  /// Change item's icon
-  virtual void setIcon(FXIcon* icn);
-
-  /// Return item's icon
-  FXIcon* getIcon() const { return icon; }
-
-  /// Change item's user data
-  void setData(void* ptr){ data=ptr; }
-
-  /// Get item's user data
-  void* getData() const { return data; }
-
-  /// Change size
-  void setSize(FXint s){ size=s; }
-
-  /// Obtain current size
-  FXint getSize() const { return size; }
-
-  /// Change position
-  void setPos(FXint p){ pos=p; }
-
-  /// Obtain current position
-  FXint getPos() const { return pos; }
-
-  /// Change sort direction (FALSE, TRUE, MAYBE)
-  void setArrowDir(FXbool dir=MAYBE);
-
-  /// Return sort direction (FALSE, TRUE, MAYBE)
-  FXbool getArrowDir() const;
-
-  /// Change content justification
-  void setJustify(FXuint justify=LEFT|CENTER_Y);
-
-  /// Return content justification
-  FXuint getJustify() const { return state&(RIGHT|LEFT|TOP|BOTTOM); }
-
-  /// Change icon position
-  void setIconPosition(FXuint mode=BEFORE);
-
-  /// Return icon position
-  FXuint getIconPosition() const { return state&(BEFORE|AFTER|ABOVE|BELOW); }
-
-  /// Change state to pressed
-  void setPressed(FXbool pressed);
-
-  /// Return pressed state
-  FXbool isPressed() const { return (state&PRESSED)!=0; }
-
-  /// Return the item's content width in the header
-  virtual FXint getWidth(const FXHeader* header) const;
-
-  /// Return the item's content height in the header
-  virtual FXint getHeight(const FXHeader* header) const;
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach from server-side resources
-  virtual void detach();
-
-  /// Destroy server-side resources
-  virtual void destroy();
-
-  /// Stream serialization
-  virtual void save(FXStream& store) const;
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXHeaderItem(){}
-  };
-
-
-typedef FXObjectListOf<FXHeaderItem> FXHeaderItemList;
-
-
-/**
-* Header control may be placed over a table or list to provide a resizable
-* captions above a number of columns.
-* Each caption comprises a label and an optional icon; in addition, an arrow
-* may be shown to indicate whether the items in that column are sorted, and
-* if so, whether they are sorted in increasing or decreasing order.
-* Each caption can be interactively resized.  During the resizing, if the
-* HEADER_TRACKING was specified, the header control sends a SEL_CHANGED message
-* to its target, with the message data set to the caption number being resized,
-* of the type FXint.
-* If the HEADER_TRACKING was not specified the SEL_CHANGED message is sent at
-* the end of the resizing operation.
-* Clicking on a caption causes a message of type SEL_COMMAND to be sent to the
-* target, with the message data set to the caption number being clicked.
-* A single click on a split causes a message of type SEL_CLICKED to be sent to the
-* target; a typical response to this message would be to adjust the size of
-* the split to fit the contents displayed underneath it.
-* The contents may be scrolled by calling setPosition().
-*/
-class FXAPI FXHeader : public FXFrame {
-  FXDECLARE(FXHeader)
-protected:
-  FXHeaderItemList items;	// Item list
-  FXColor          textColor;	// Text color
-  FXFont          *font;	// Text font
-  FXString         help;	// Help text
-  FXint            pos;		// Scroll position
-  FXint            active;	// Active button
-  FXint            activepos;	// Position of active item
-  FXint            activesize;	// Size of active item
-  FXint            offset;	// Offset where split grabbed
-protected:
-  FXHeader();
-  void drawSplit(FXint pos);
-  virtual FXHeaderItem *createItem(const FXString& text,FXIcon* icon,FXint size,void* ptr);
-private:
-  FXHeader(const FXHeader&);
-  FXHeader &operator=(const FXHeader&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onTipTimer(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct new header control
-  FXHeader(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=HEADER_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return number of items
-  FXint getNumItems() const { return items.no(); }
-
-  /// Return total size of all items
-  FXint getTotalSize() const;
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Set the current position
-  void setPosition(FXint pos);
-
-  /// Return the current position
-  FXint getPosition() const { return pos; }
-
-  /**
-  * Return item-index given coordinate offset, or -1 if coordinate
-  * is before first item in header, or nitems if coordinate is after
-  * last item in header.
-  */
-  FXint getItemAt(FXint coord) const;
-
-  /// Return item at given index
-  FXHeaderItem *getItem(FXint index) const;
-
-  /// Replace the item with a [possibly subclassed] item
-  FXint setItem(FXint index,FXHeaderItem* item,FXbool notify=FALSE);
-
-  /// Replace items text, icon, and user-data pointer
-  FXint setItem(FXint index,const FXString& text,FXIcon *icon=NULL,FXint size=0,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Fill header by appending items from array of strings
-  FXint fillItems(const FXchar** strings,FXIcon *icon=NULL,FXint size=0,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Fill header by appending items from newline separated strings
-  FXint fillItems(const FXString& strings,FXIcon *icon=NULL,FXint size=0,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Insert a new [possibly subclassed] item at the give index
-  FXint insertItem(FXint index,FXHeaderItem* item,FXbool notify=FALSE);
-
-  /// Insert item at index with given text, icon, and user-data pointer
-  FXint insertItem(FXint index,const FXString& text,FXIcon *icon=NULL,FXint size=0,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Append a [possibly subclassed] item to the list
-  FXint appendItem(FXHeaderItem* item,FXbool notify=FALSE);
-
-  /// Append new item with given text and optional icon, and user-data pointer
-  FXint appendItem(const FXString& text,FXIcon *icon=NULL,FXint size=0,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Prepend a [possibly subclassed] item to the list
-  FXint prependItem(FXHeaderItem* item,FXbool notify=FALSE);
-
-  /// Prepend new item with given text and optional icon, and user-data pointer
-  FXint prependItem(const FXString& text,FXIcon *icon=NULL,FXint size=0,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Extract item from list
-  FXHeaderItem* extractItem(FXint index,FXbool notify=FALSE);
-
-  /// Remove item at index
-  void removeItem(FXint index,FXbool notify=FALSE);
-
-  /// Remove all items
-  void clearItems(FXbool notify=FALSE);
-
-  /// Change text label for item at index
-  void setItemText(FXint index,const FXString& text);
-
-  /// Get text of item at index
-  FXString getItemText(FXint index) const;
-
-  /// Change icon of item at index
-  void setItemIcon(FXint index,FXIcon* icon);
-
-  /// Return icon of item at index
-  FXIcon* getItemIcon(FXint index) const;
-
-  /// Change size of item at index
-  void setItemSize(FXint index,FXint size);
-
-  /// Return size of item at index
-  FXint getItemSize(FXint index) const;
-
-  /// Compute offset from the left side of item at index
-  FXint getItemOffset(FXint index) const;
-
-  /// Change data of item at index
-  void setItemData(FXint index,void* ptr);
-
-  /// Return data of item at index
-  void* getItemData(FXint index) const;
-
-  /// Change sort direction (FALSE, TRUE, MAYBE)
-  void setArrowDir(FXint index,FXbool dir=MAYBE);
-
-  /// Return sort direction (FALSE, TRUE, MAYBE)
-  FXbool getArrowDir(FXint index) const;
-
-  /**
-  * Change item justification.  Horizontal justification is controlled by passing
-  * FXHeaderItem::RIGHT, FXHeaderItem::LEFT, or FXHeaderItem::CENTER_X.
-  * Vertical justification is controlled by FXHeaderItem::TOP, FXHeaderItem::BOTTOM,
-  * or FXHeaderItem::CENTER_Y.
-  * The default is a combination of FXHeaderItem::LEFT and FXHeaderItem::CENTER_Y.
-  */
-  void setItemJustify(FXint index,FXuint justify);
-
-  /// Return item justification
-  FXuint getItemJustify(FXint index) const;
-
-  /**
-  * Change relative position of icon and text of item.
-  * Passing FXHeaderItem::BEFORE or FXHeaderItem::AFTER places the icon
-  * before or after the text, and passing FXHeaderItem::ABOVE or
-  * FXHeaderItem::BELOW places it above or below the text, respectively.
-  * The default of FXHeaderItem::BEFORE places the icon in front of the text.
-  */
-  void setItemIconPosition(FXint index,FXuint mode);
-
-  /// Return relative icon and text position
-  FXuint getItemIconPosition(FXint index) const;
-
-  /// Changed button item's pressed state
-  void setItemPressed(FXint index,FXbool pressed=TRUE);
-
-  /// Return TRUE if button item is pressed in
-  FXbool isItemPressed(FXint index) const;
-
-  /// Scroll to make given item visible
-  void makeItemVisible(FXint index);
-
-  /// Repaint header at index
-  void updateItem(FXint index) const;
-
-  /// Change text font
-  void setFont(FXFont* fnt);
-
-  /// return text font
-  FXFont* getFont() const { return font; }
-
-  /// Return text color
-  FXColor getTextColor() const { return textColor; }
-
-  /// Change text color
-  void setTextColor(FXColor clr);
-
-  /// Set header style options
-  void setHeaderStyle(FXuint style);
-
-  /// Get header style options
-  FXuint getHeaderStyle() const;
-
-  /// Set the status line help text for this header
-  void setHelpText(const FXString& text);
-
-  /// Get the status line help text for this header
-  const FXString& getHelpText() const { return help; }
-
-  /// Save header to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load header from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXHeader();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXHorizontalFrame.h b/fox-includes/FXHorizontalFrame.h
deleted file mode 100755
index e898b011..00000000
--- a/fox-includes/FXHorizontalFrame.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*              H o r i z o n t a l   C o n t a i n e r   W i d g e t            *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2003 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXHorizontalFrame.h 1536 2003-05-14 21:41:00Z lyle $                 *
-********************************************************************************/
-#ifndef FXHORIZONTALFRAME_H
-#define FXHORIZONTALFRAME_H
-
-#ifndef FXPACKER_H
-#include "FXPacker.h"
-#endif
-
-namespace FX {
-
-
-/**
-* Horizontal frame layout manager widget is used to automatically
-* place child-windows horizontally from left-to-right, or right-to-left,
-* depending on the child window's layout hints.
-*/
-class FXAPI FXHorizontalFrame : public FXPacker {
-  FXDECLARE(FXHorizontalFrame)
-protected:
-  FXHorizontalFrame(){}
-private:
-  FXHorizontalFrame(const FXHorizontalFrame&);
-  FXHorizontalFrame &operator=(const FXHorizontalFrame&);
-public:
-
-  /// Construct a horizontal frame layout manager
-  FXHorizontalFrame(FXComposite *p,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_SPACING,FXint pr=DEFAULT_SPACING,FXint pt=DEFAULT_SPACING,FXint pb=DEFAULT_SPACING,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING);
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXICOIcon.h b/fox-includes/FXICOIcon.h
deleted file mode 100755
index b4b0f938..00000000
--- a/fox-includes/FXICOIcon.h
+++ /dev/null
@@ -1,88 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        I C O   I c o n   O b j e c t                          *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2001,2006 by Janusz Ganczarski.   All Rights Reserved.          *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXICOIcon.h 2343 2006-02-12 20:26:26Z lyle $                         *
-********************************************************************************/
-#ifndef FXICOICON_H
-#define FXICOICON_H
-
-#ifndef FXICON_H
-#include "FXIcon.h"
-#endif
-
-namespace FX {
-
-
-/// ICO (Microsoft icon format) icon
-class FXAPI FXICOIcon : public FXIcon {
-  FXDECLARE(FXICOIcon)
-protected:
-  FXICOIcon(){}
-private:
-  FXICOIcon(const FXICOIcon&);
-  FXICOIcon &operator=(const FXICOIcon&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct icon from memory stream formatted in Microsoft icon format
-  FXICOIcon(FXApp* a,const void *pix=NULL,FXColor clr=FXRGB(192,192,192),FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Save pixels into stream in Microsoft icon format format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in Microsoft icon format format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy icon
-  virtual ~FXICOIcon();
-  };
-
-
-#ifndef FXLOADICO
-#define FXLOADICO
-
-/**
-* Check if stream contains a ICO, return TRUE if so.
-*/
-extern FXAPI bool fxcheckICO(FXStream& store);
-
-
-/**
-* Load an ICO (Microsoft icon format) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadICO(FXStream& store,FXColor*& data,FXint& width,FXint& height,FXint& xspot,FXint& yspot);
-
-
-/**
-* Save an ICO (Microsoft icon format) file to a stream.
-* If no hot-spot given, save as an ICO instead of a CUR resource.
-*/
-extern FXAPI bool fxsaveICO(FXStream& store,const FXColor *data,FXint width,FXint height,FXint xspot=-1,FXint yspot=-1);
-
-#endif
-
-}
-
-#endif
diff --git a/fox-includes/FXICOImage.h b/fox-includes/FXICOImage.h
deleted file mode 100755
index 7361f52c..00000000
--- a/fox-includes/FXICOImage.h
+++ /dev/null
@@ -1,87 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                          I C O   I m a g e   O b j e c t                      *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2001,2006 by Janusz Ganczarski.   All Rights Reserved.          *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXICOImage.h 2343 2006-02-12 20:26:26Z lyle $                        *
-********************************************************************************/
-#ifndef FXICOIMAGE_H
-#define FXICOIMAGE_H
-
-#ifndef FXIMAGE_H
-#include "FXImage.h"
-#endif
-
-namespace FX {
-
-/// ICO (Microsoft icon format) graphics file
-class FXAPI FXICOImage : public FXImage {
-  FXDECLARE(FXICOImage)
-protected:
-  FXICOImage(){}
-private:
-  FXICOImage(const FXICOImage&);
-  FXICOImage &operator=(const FXICOImage&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct image from memory stream formatted in Microsoft icon format
-  FXICOImage(FXApp* a,const void *pix=NULL,FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Save pixels into stream in Microsoft icon format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in Microsoft icon format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy image
-  virtual ~FXICOImage();
-  };
-
-
-#ifndef FXLOADICO
-#define FXLOADICO
-
-/**
-* Check if stream contains a ICO, return TRUE if so.
-*/
-extern FXAPI bool fxcheckICO(FXStream& store);
-
-
-/**
-* Load an ICO (Microsoft icon format) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadICO(FXStream& store,FXColor*& data,FXint& width,FXint& height,FXint& xspot,FXint& yspot);
-
-
-/**
-* Save an ICO (Microsoft icon format) file to a stream.
-* If no hot-spot given, save as an ICO instead of a CUR resource.
-*/
-extern FXAPI bool fxsaveICO(FXStream& store,const FXColor *data,FXint width,FXint height,FXint xspot=-1,FXint yspot=-1);
-
-#endif
-
-}
-
-#endif
diff --git a/fox-includes/FXIFFIcon.h b/fox-includes/FXIFFIcon.h
deleted file mode 100644
index f97d40ef..00000000
--- a/fox-includes/FXIFFIcon.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        I F F   I c o n   O b j e c t                          *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2004,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXIFFIcon.h 2401 2006-04-27 00:46:49Z lyle $                          *
-********************************************************************************/
-#ifndef FXIFFICON_H
-#define FXIFFICON_H
-
-#ifndef FXICON_H
-#include "FXIcon.h"
-#endif
-
-namespace FX {
-
-
-/**
-* The IFF Icon provides support for the EA/Amiga Image File Format.
-*/
-class FXAPI FXIFFIcon : public FXIcon {
-  FXDECLARE(FXIFFIcon)
-protected:
-  FXIFFIcon(){}
-private:
-  FXIFFIcon(const FXIFFIcon&);
-  FXIFFIcon &operator=(const FXIFFIcon&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct an icon from memory stream formatted as IFF format
-  FXIFFIcon(FXApp* a,const void *pix=NULL,FXColor clr=FXRGB(192,192,192),FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Save pixels into stream in IFF format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in IFF format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy
-  virtual ~FXIFFIcon();
-  };
-
-
-
-#ifndef FXLOADIFF
-#define FXLOADIFF
-
-/**
-* Check if stream contains a IFF, return TRUE if so.
-*/
-extern FXAPI bool fxcheckIFF(FXStream& store);
-
-
-/**
-* Load an IFF (EA Image File Format) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadIFF(FXStream& store,FXColor*& data,FXint& width,FXint& height);
-
-
-#endif
-
-}
-
-#endif
diff --git a/fox-includes/FXIFFImage.h b/fox-includes/FXIFFImage.h
deleted file mode 100644
index ba80be26..00000000
--- a/fox-includes/FXIFFImage.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                         I F F   I m a g e   O b j e c t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2004,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXIFFImage.h 2401 2006-04-27 00:46:49Z lyle $                         *
-********************************************************************************/
-#ifndef FXIFFIMAGE_H
-#define FXIFFIMAGE_H
-
-#ifndef FXIMAGE_H
-#include "FXImage.h"
-#endif
-
-namespace FX {
-
-
-/**
-* The IFF Image provides support for the EA/Amiga Image File Format.
-*/
-class FXAPI FXIFFImage : public FXImage {
-  FXDECLARE(FXIFFImage)
-protected:
-  FXIFFImage(){}
-private:
-  FXIFFImage(const FXIFFImage&);
-  FXIFFImage &operator=(const FXIFFImage&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct an image from memory stream formatted as IFF format
-  FXIFFImage(FXApp* a,const void *pix=NULL,FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Save pixels into stream in IFF format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in IFF format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy
-  virtual ~FXIFFImage();
-  };
-
-
-
-#ifndef FXLOADIFF
-#define FXLOADIFF
-
-/**
-* Check if stream contains a IFF, return TRUE if so.
-*/
-extern FXAPI bool fxcheckIFF(FXStream& store);
-
-
-/**
-* Load an IFF (EA Image File Format) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadIFF(FXStream& store,FXColor*& data,FXint& width,FXint& height);
-
-
-#endif
-
-}
-
-#endif
diff --git a/fox-includes/FXIO.h b/fox-includes/FXIO.h
deleted file mode 100644
index c8332492..00000000
--- a/fox-includes/FXIO.h
+++ /dev/null
@@ -1,168 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        I / O   D e v i c e   C l a s s                        *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2005,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXIO.h 2344 2006-02-12 21:19:36Z lyle $                               *
-********************************************************************************/
-#ifndef FXIO_H
-#define FXIO_H
-
-
-
-namespace FX {
-
-
-/**
-* FXIO manipulates a handle to an abstract i/o device.
-* The various subclasses of FXIO perform i/o on files, sockets,
-* pipes, and possibly other devices.
-*/
-class FXAPI FXIO {
-protected:
-  FXInputHandle device;         // Device (file/pipe/socket/whatever)
-  FXuint        access;         // Access being performed
-private:
-  FXIO(const FXIO&);
-  FXIO &operator=(const FXIO&);
-public:
-
-  /// File modes
-  enum {
-
-    /// Permissions
-    OtherRead      = 0x00004,   /// Others have read permission
-    OtherWrite     = 0x00002,   /// Others have write permisson
-    OtherExec      = 0x00001,   /// Others have execute permission
-    OtherReadWrite = 0x00006,   /// Others have read and write permission
-    OtherFull      = 0x00007,   /// Others have full access
-
-    GroupRead      = 0x00020,   /// Group has read permission
-    GroupWrite     = 0x00010,   /// Group has write permission
-    GroupExec      = 0x00008,   /// Group has execute permission
-    GroupReadWrite = 0x00030,   /// Group has read and write permission
-    GroupFull      = 0x00038,   /// Group has full access
-
-    OwnerRead      = 0x00100,   /// Owner has read permission
-    OwnerWrite     = 0x00080,   /// Owner has write permission
-    OwnerExec      = 0x00040,   /// Owner has execute permission
-    OwnerReadWrite = 0x00180,   /// Owner has read and write permission
-    OwnerFull      = 0x001C0,   /// Owner has full access
-
-    /// Other flags
-    Hidden         = 0x00200,   /// Hidden file
-    Directory      = 0x00400,   /// Is directory
-    File           = 0x00800,   /// Is regular file
-    SymLink        = 0x01000,   /// Is symbolic link
-
-    /// Special mode bits
-    SetUser        = 0x02000,   /// Set user id
-    SetGroup       = 0x04000,   /// Set group id
-    Sticky         = 0x08000,   /// Sticky bit
-
-    /// Device special files
-    Character      = 0x10000,   /// Character device
-    Block          = 0x20000,   /// Block device
-    Socket         = 0x40000,   /// Socket device
-    Fifo           = 0x80000    /// Fifo device
-    };
-
-  /// Access modes
-  enum {
-
-    /// Basic access options
-    NoAccess    =  0,                           /// No access
-    ReadOnly    =  1,                           /// Open for reading
-    WriteOnly   =  2,                           /// Open for writing
-    ReadWrite   =  3,                           /// Open for read and write
-    Append      =  4,                           /// Open for append
-    Truncate    =  8,                           /// Truncate to zero when writing
-    Create      = 16,                           /// Create if it doesn't exist
-    Exclusive   = 32,                           /// Fail if trying to create a file which already exists
-    NonBlocking = 64,                           /// Non-blocking i/o
-
-    /// Convenience access options
-    Reading     = ReadOnly,                     /// Normal options for reading
-    Writing     = ReadWrite|Create|Truncate     /// Normal options for writing
-    };
-
-  /// Positioning modes
-  enum {
-    Begin   = 0,                /// Position from the begin (default)
-    Current = 1,                /// Position relative to current position
-    End     = 2                 /// Position from the end
-    };
-
-public:
-
-  /// Construct
-  FXIO();
-
-  /// Open device with access mode and handle
-  virtual bool open(FXInputHandle handle,FXuint mode);
-
-  /// Return true if open
-  virtual bool isOpen() const;
-
-  /// Return access mode
-  FXuint mode() const { return access; }
-
-  /// Return handle
-  FXInputHandle handle() const { return device; }
-
-  /// Attach existing device handle
-  virtual void attach(FXInputHandle handle,FXuint mode);
-
-  /// Detach device handle
-  virtual void detach();
-
-  /// Get current file position
-  virtual FXlong position() const;
-
-  /// Change file position, returning new position from start
-  virtual FXlong position(FXlong offset,FXuint from=FXIO::Begin);
-
-  /// Read block of bytes, returning number of bytes read
-  virtual FXival readBlock(void* data,FXival count);
-
-  /// Write block of bytes, returning number of bytes written
-  virtual FXival writeBlock(const void* data,FXival count);
-
-  /// Truncate file
-  virtual FXlong truncate(FXlong size);
-
-  /// Flush to disk
-  virtual bool flush();
-
-  /// Test if we're at the end
-  virtual bool eof();
-
-  /// Return size of i/o device
-  virtual FXlong size();
-
-  /// Close handle
-  virtual bool close();
-
-  /// Destroy and close
-  virtual ~FXIO();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXIcon.h b/fox-includes/FXIcon.h
deleted file mode 100755
index d76d9cb1..00000000
--- a/fox-includes/FXIcon.h
+++ /dev/null
@@ -1,126 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                               I c o n - O b j e c t                           *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXIcon.h 2127 2005-08-07 20:21:35Z lyle $                            *
-********************************************************************************/
-#ifndef FXICON_H
-#define FXICON_H
-
-#ifndef FXIMAGE_H
-#include "FXImage.h"
-#endif
-
-namespace FX {
-
-class FXDC;
-class FXDCWindow;
-class FXDrawable;
-class FXTopWindow;
-
-
-/**
-* An Icon is an image with two additional server-side resources: a shape
-* bitmap, which is used to mask those pixels where the background should
-* be preserved during the drawing, and a etch bitmap, which is used to
-* draw the icon when it is disabled.
-*/
-class FXAPI FXIcon : public FXImage {
-  FXDECLARE(FXIcon)
-  friend class FXDC;
-  friend class FXWindow;
-  friend class FXDCWindow;
-  friend class FXDrawable;
-  friend class FXTopWindow;
-protected:
-  FXID     shape;             // Shape pixmap
-  FXID     etch;              // Etch pixmap
-  FXColor  transp;            // Transparency color
-protected:
-  FXIcon(){}
-  FXColor guesstransp();
-private:
-  FXIcon(const FXIcon&);
-  FXIcon &operator=(const FXIcon&);
-public:
-
-  /**
-  * Create an icon with an initial pixel buffer pix, a transparent color clr,
-  * and options as in FXImage.  The transparent color is used to determine which
-  * pixel values are transparent, i.e. need to be masked out in the absence of
-  * a true alpha channel.
-  * If the flag IMAGE_OPAQUE is passed, the shape and etch bitmaps are generated
-  * as if the image is fully opaque, even if it has an alpha channel or transparancy
-  * color.  The flag IMAGE_ALPHACOLOR is used to force a specific alpha color instead
-  * of the alpha channel obtained from the image file.
-  * Specifying IMAGE_ALPHAGUESS causes Icon to obtain the alpha color from the background
-  * color of the image; it has the same effect as IMAGE_ALPHACOLOR in the sense that
-  * the icon will be transparent for those colors matching the alpha color.
-  */
-  FXIcon(FXApp* a,const FXColor *pix=NULL,FXColor clr=0,FXuint opts=0,FXint w=1,FXint h=1);
-
-  /**
-  * Create the server side pixmap, the shape bitmap, and the etch bitmap, then
-  * call render() to fill it with the pixel data from the client-side buffer.  After
-  * the server-side pixmap and bitmaps have been created, the client-side pixel
-  * buffer will be deleted unless IMAGE_KEEP has been specified. If the pixel buffer
-  * is not owned, i.e. the flag IMAGE_OWNED is not set, the pixel buffer will not
-  * be deleted; however the pixel buffer will be set to NULL.
-  */
-  virtual void create();
-
-  /**
-  * Detach the server side pixmap, shape bitmap, and etch bitmap from the Icon.
-  * Afterwards, the Icon is left as if it never had a server-side resources.
-  */
-  virtual void detach();
-
-  /**
-  * Destroy the server-side pixmap and the shape bitmap and etch bitmap.
-  * The client-side pixel buffer is not affected.
-  */
-  virtual void destroy();
-
-  /**
-  * Render the server-side pixmap, shape bitmap and etch bitmap for the icon
-  * from the client-side pixel buffer.
-  */
-  virtual void render();
-
-  /**
-  * Resize both client-side and server-side representations (if any) to the
-  * given width and height.  The new representations typically contain garbage
-  * after this operation and need to be re-filled.
-  */
-  virtual void resize(FXint w,FXint h);
-
-  /// Obtain transparency color
-  FXColor getTransparentColor() const { return transp; }
-
-  /// Change transparency color
-  void setTransparentColor(FXColor color){ transp=color; }
-
-  /// Destructor
-  virtual ~FXIcon();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXIconDict.h b/fox-includes/FXIconDict.h
deleted file mode 100644
index 1961822c..00000000
--- a/fox-includes/FXIconDict.h
+++ /dev/null
@@ -1,109 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                         I c o n   D i c t i o n a r y                         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXIconDict.h 2344 2006-02-12 21:19:36Z lyle $                         *
-********************************************************************************/
-#ifndef FXICONDICT_H
-#define FXICONDICT_H
-
-#ifndef FXDICT_H
-#include "FXDict.h"
-#endif
-
-namespace FX {
-
-
-class FXIconSource;
-
-
-/**
-* The Icon Dictionary manages a collection of icons.  The icons are referenced
-* by their file name.  When first encountering a new file name, the icon is
-* located by searching the icon search path for the icon file.  If found, the
-* services of the icon source object are used to load the icon from the file.
-* A custom icon source may be installed to furnish support for additonal
-* image file formats.
-* Once the icon is loaded, an association between the icon name and the icon
-* is entered into the icon dictionary.  Subsequent searches for an icon with
-* this name will be satisfied from the cached value.
-* The lifetype of the icons is managed by the icon dictionary, and thus all
-* icons will be deleted when the dictionary is deleted.
-*/
-class FXAPI FXIconDict : public FXDict {
-  FXDECLARE(FXIconDict)
-private:
-  FXIconSource *source; // Icon source
-  FXString      path;   // Where to search icons
-protected:
-  FXIconDict():source(NULL){}
-  virtual void *createData(const void*);
-  virtual void deleteData(void*);
-private:
-  FXIconDict(const FXIconDict&);
-  FXIconDict &operator=(const FXIconDict&);
-public:
-
-  /// Default icon search path
-  static const FXchar defaultIconPath[];
-
-public:
-
-  /**
-  * Construct icon dictionary, and set initial search path; also
-  * creates a default icon source object.
-  */
-  FXIconDict(FXApp* app,const FXString& p=defaultIconPath);
-
-  /// Change icon source
-  void setIconSource(FXIconSource *src){ source=src; }
-
-  /// Return icon source
-  FXIconSource* getIconSource() const { return source; }
-
-  /// Set icon search path
-  void setIconPath(const FXString& p){ path=p; }
-
-  /// Return current icon search path
-  const FXString& getIconPath() const { return path; }
-
-  /// Insert unique icon loaded from filename into dictionary
-  FXIcon* insert(const FXchar* name){ return (FXIcon*)FXDict::insert(name,name); }
-
-  /// Remove icon from dictionary
-  FXIcon* remove(const FXchar* name){ return (FXIcon*)FXDict::remove(name); }
-
-  /// Find icon by name
-  FXIcon* find(const FXchar* name){ return (FXIcon*)FXDict::find(name); }
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destroy the icon dict as well as the icon source
-  virtual ~FXIconDict();
-  };
-
-
-}
-
-#endif
diff --git a/fox-includes/FXIconList.h b/fox-includes/FXIconList.h
deleted file mode 100755
index fe0f90ec..00000000
--- a/fox-includes/FXIconList.h
+++ /dev/null
@@ -1,604 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                         I c o n   L i s t   W i d g e t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1999,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXIconList.h 2336 2006-02-04 15:20:33Z lyle $                        *
-********************************************************************************/
-#ifndef FXICONLIST_H
-#define FXICONLIST_H
-
-#ifndef FXSCROLLAREA_H
-#include "FXScrollArea.h"
-#endif
-
-namespace FX {
-
-
-/// Icon list styles
-enum {
-  ICONLIST_EXTENDEDSELECT = 0,                /// Extended selection mode
-  ICONLIST_SINGLESELECT   = 0x00100000,       /// At most one selected item
-  ICONLIST_BROWSESELECT   = 0x00200000,       /// Always exactly one selected item
-  ICONLIST_MULTIPLESELECT = 0x00300000,       /// Multiple selection mode
-  ICONLIST_AUTOSIZE       = 0x00400000,       /// Automatically size item spacing
-  ICONLIST_DETAILED       = 0,                /// List mode
-  ICONLIST_MINI_ICONS     = 0x00800000,       /// Mini Icon mode
-  ICONLIST_BIG_ICONS      = 0x01000000,       /// Big Icon mode
-  ICONLIST_ROWS           = 0,                /// Row-wise mode
-  ICONLIST_COLUMNS        = 0x02000000,       /// Column-wise mode
-  ICONLIST_NORMAL         = ICONLIST_EXTENDEDSELECT
-  };
-
-
-class FXIcon;
-class FXHeader;
-class FXFont;
-class FXIconList;
-class FXFileList;
-
-
-/// Icon item
-class FXAPI FXIconItem : public FXObject {
-  FXDECLARE(FXIconItem)
-  friend class FXIconList;
-  friend class FXFileList;
-protected:
-  FXString  label;
-  FXIcon   *bigIcon;
-  FXIcon   *miniIcon;
-  void     *data;
-  FXuint    state;
-private:
-  FXIconItem(const FXIconItem&);
-  FXIconItem& operator=(const FXIconItem&);
-protected:
-  FXIconItem():bigIcon(NULL),miniIcon(NULL),data(NULL),state(0){}
-  virtual void draw(const FXIconList* list,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const;
-  virtual FXint hitItem(const FXIconList* list,FXint rx,FXint ry,FXint rw=1,FXint rh=1) const;
-protected:
-  virtual void drawBigIcon(const FXIconList* list,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const;
-  virtual void drawMiniIcon(const FXIconList* list,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const;
-  virtual void drawDetails(const FXIconList* list,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const;
-public:
-  enum {
-    SELECTED      = 1,  /// Selected
-    FOCUS         = 2,  /// Focus
-    DISABLED      = 4,  /// Disabled
-    DRAGGABLE     = 8,  /// Draggable
-    BIGICONOWNED  = 16, /// Big icon owned by item
-    MINIICONOWNED = 32  /// Mini icon owned by item
-    };
-public:
-
-  /// Construct new item with given text, icons, and user-data
-  FXIconItem(const FXString& text,FXIcon* bi=NULL,FXIcon* mi=NULL,void* ptr=NULL):label(text),bigIcon(bi),miniIcon(mi),data(ptr),state(0){}
-
-  /// Change item's text label
-  virtual void setText(const FXString& txt);
-
-  /// Return item's text label
-  const FXString& getText() const { return label; }
-
-  /// Change item's big icon, deleting the old icon if it was owned
-  virtual void setBigIcon(FXIcon* icn,FXbool owned=FALSE);
-
-  /// Return item's big icon
-  FXIcon* getBigIcon() const { return bigIcon; }
-
-  /// Change item's mini icon, deleting the old icon if it was owned
-  virtual void setMiniIcon(FXIcon* icn,FXbool owned=FALSE);
-
-  /// Return item's mini icon
-  FXIcon* getMiniIcon() const { return miniIcon; }
-
-  /// Change item's user data
-  void setData(void* ptr){ data=ptr; }
-
-  /// Get item's user data
-  void* getData() const { return data; }
-
-  /// Make item draw as focused
-  virtual void setFocus(FXbool focus);
-
-  /// Return true if item has focus
-  FXbool hasFocus() const { return (state&FOCUS)!=0; }
-
-  /// Select item
-  virtual void setSelected(FXbool selected);
-
-  /// Return true if this item is selected
-  FXbool isSelected() const { return (state&SELECTED)!=0; }
-
-  /// Enable or disable item
-  virtual void setEnabled(FXbool enabled);
-
-  /// Return true if this item is enabled
-  FXbool isEnabled() const { return (state&DISABLED)==0; }
-
-  /// Make item draggable
-  virtual void setDraggable(FXbool draggable);
-
-  /// Return true if this item is draggable
-  FXbool isDraggable() const { return (state&DRAGGABLE)!=0; }
-
-  /// Return width of item as drawn in list
-  virtual FXint getWidth(const FXIconList* list) const;
-
-  /// Return height of item as drawn in list
-  virtual FXint getHeight(const FXIconList* list) const;
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Destroy server-side resources
-  virtual void destroy();
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destroy item and free icons if owned
-  virtual ~FXIconItem();
-  };
-
-
-/// Icon item collate function
-typedef FXint (*FXIconListSortFunc)(const FXIconItem*,const FXIconItem*);
-
-
-typedef FXObjectListOf<FXIconItem> FXIconItemList;
-
-
-/**
-* A Icon List Widget displays a list of items, each with a text and
-* optional icon.  Icon List can display its items in essentially three
-* different ways; in big-icon mode, the bigger of the two icons is used
-* for each item, and the text is placed underneath the icon. In mini-
-* icon mode, the icons are listed in rows and columns, with the smaller
-* icon preceding the text.  Finally, in detail mode the icons are listed
-* in a single column, and all fields of the text are shown under a
-* header control with one button for each subfield.
-* When an item's selected state changes, the icon list sends
-* a SEL_SELECTED or SEL_DESELECTED message.  A change of the current
-* item is signified by the SEL_CHANGED message.
-* The icon list sends SEL_COMMAND messages when the user clicks on an item,
-* and SEL_CLICKED, SEL_DOUBLECLICKED, and SEL_TRIPLECLICKED when the user
-* clicks once, twice, or thrice, respectively.
-* When items are added, replaced, or removed, the icon list sends messages
-* of the type SEL_INSERTED, SEL_REPLACED, or SEL_DELETED.
-* In each of these cases, the index to the item, if any, is passed in the
-* 3rd argument of the message.
-*/
-class FXAPI FXIconList : public FXScrollArea {
-  FXDECLARE(FXIconList)
-protected:
-  FXHeader          *header;            // Header control
-  FXIconItemList     items;		// Item list
-  FXint              nrows;             // Number of rows
-  FXint              ncols;             // Number of columns
-  FXint              anchor;            // Anchor item
-  FXint              current;           // Current item
-  FXint              extent;            // Extent item
-  FXint              cursor;            // Cursor item
-  FXint              viewable;          // Visible item
-  FXFont            *font;              // Font
-  FXIconListSortFunc sortfunc;          // Item sort function
-  FXColor            textColor;         // Text color
-  FXColor            selbackColor;      // Selected back color
-  FXColor            seltextColor;      // Selected text color
-  FXint              itemWidth;         // Item width
-  FXint              itemHeight;        // Item height
-  FXint              itemSpace;         // Space for item label
-  FXint              anchorx;           // Rectangular selection
-  FXint              anchory;
-  FXint              currentx;
-  FXint              currenty;
-  FXint              grabx;             // Grab point x
-  FXint              graby;             // Grab point y
-  FXString           lookup;            // Lookup string
-  FXString           help;              // Help text
-  FXbool             state;             // State of item
-protected:
-  FXIconList();
-  void recompute();
-  void getrowscols(FXint& nr,FXint& nc,FXint w,FXint h) const;
-  void drawLasso(FXint x0,FXint y0,FXint x1,FXint y1);
-  void lassoChanged(FXint ox,FXint oy,FXint ow,FXint oh,FXint nx,FXint ny,FXint nw,FXint nh,FXbool notify);
-  virtual void moveContents(FXint x,FXint y);
-  virtual FXIconItem *createItem(const FXString& text,FXIcon *big,FXIcon* mini,void* ptr);
-  static FXint compareSection(const FXchar *p,const FXchar* q,FXint s);
-  static FXint compareSectionCase(const FXchar *p,const FXchar* q,FXint s);
-private:
-  FXIconList(const FXIconList&);
-  FXIconList &operator=(const FXIconList&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onEnter(FXObject*,FXSelector,void*);
-  long onLeave(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onRightBtnPress(FXObject*,FXSelector,void*);
-  long onRightBtnRelease(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onTipTimer(FXObject*,FXSelector,void*);
-  long onCmdSelectAll(FXObject*,FXSelector,void*);
-  long onCmdDeselectAll(FXObject*,FXSelector,void*);
-  long onCmdSelectInverse(FXObject*,FXSelector,void*);
-  long onCmdArrangeByRows(FXObject*,FXSelector,void*);
-  long onUpdArrangeByRows(FXObject*,FXSelector,void*);
-  long onCmdArrangeByColumns(FXObject*,FXSelector,void*);
-  long onUpdArrangeByColumns(FXObject*,FXSelector,void*);
-  long onCmdShowDetails(FXObject*,FXSelector,void*);
-  long onUpdShowDetails(FXObject*,FXSelector,void*);
-  long onCmdShowBigIcons(FXObject*,FXSelector,void*);
-  long onUpdShowBigIcons(FXObject*,FXSelector,void*);
-  long onCmdShowMiniIcons(FXObject*,FXSelector,void*);
-  long onUpdShowMiniIcons(FXObject*,FXSelector,void*);
-  long onHeaderChanged(FXObject*,FXSelector,void*);
-  long onHeaderResize(FXObject*,FXSelector,void*);
-  long onFocusIn(FXObject*,FXSelector,void*);
-  long onFocusOut(FXObject*,FXSelector,void*);
-  long onClicked(FXObject*,FXSelector,void*);
-  long onDoubleClicked(FXObject*,FXSelector,void*);
-  long onTripleClicked(FXObject*,FXSelector,void*);
-  long onCommand(FXObject*,FXSelector,void*);
-  long onAutoScroll(FXObject*,FXSelector,void*);
-  long onLookupTimer(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-public:
-  static FXint ascending(const FXIconItem* a,const FXIconItem* b);
-  static FXint descending(const FXIconItem* a,const FXIconItem* b);
-  static FXint ascendingCase(const FXIconItem* a,const FXIconItem* b);
-  static FXint descendingCase(const FXIconItem* a,const FXIconItem* b);
-public:
-  enum {
-    ID_SHOW_DETAILS=FXScrollArea::ID_LAST,
-    ID_SHOW_MINI_ICONS,
-    ID_SHOW_BIG_ICONS,
-    ID_ARRANGE_BY_ROWS,
-    ID_ARRANGE_BY_COLUMNS,
-    ID_HEADER_CHANGE,
-    ID_LOOKUPTIMER,
-    ID_SELECT_ALL,
-    ID_DESELECT_ALL,
-    ID_SELECT_INVERSE,
-    ID_LAST
-    };
-public:
-
-  /// Construct icon list with no items in it initially
-  FXIconList(FXComposite *p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=ICONLIST_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Recalculate layout
-  virtual void recalc();
-
-  /// Perform layout
-  virtual void layout();
-
- /// Compute and return content width
-  virtual FXint getContentWidth();
-
-  /// Return content height
-  virtual FXint getContentHeight();
-
-  /// Icon list can receive focus
-  virtual bool canFocus() const;
-
-  /// Move the focus to this window
-  virtual void setFocus();
-
-  /// Remove the focus from this window
-  virtual void killFocus();
-
-  /// Return viewport size
-  virtual FXint getViewportHeight();
-
-  /// Resize this window to the specified width and height
-  virtual void resize(FXint w,FXint h);
-
-  /// Move and resize this window in the parent's coordinates
-  virtual void position(FXint x,FXint y,FXint w,FXint h);
-
-  /// Return number of items
-  FXint getNumItems() const { return items.no(); }
-
-  /// Return number of rows
-  FXint getNumRows() const { return nrows; }
-
-  /// Return number of columns
-  FXint getNumCols() const { return ncols; }
-
-  /// Return header control
-  FXHeader* getHeader() const { return header; }
-
-  /// Set headers from array of strings
-  void setHeaders(const FXchar** strings,FXint size=1);
-
-  /// Set headers from newline separated strings
-  void setHeaders(const FXString& strings,FXint size=1);
-
-  /// Append header with given text and optional icon
-  void appendHeader(const FXString& text,FXIcon *icon=NULL,FXint size=1);
-
-  /// Remove header at index
-  void removeHeader(FXint index);
-
-  /// Change text of header at index
-  void setHeaderText(FXint index,const FXString& text);
-
-  /// Return text of header at index
-  FXString getHeaderText(FXint index) const;
-
-  /// Change icon of header at index
-  void setHeaderIcon(FXint index,FXIcon *icon);
-
-  /// Return icon of header at index
-  FXIcon* getHeaderIcon(FXint index) const;
-
-  /// Change size of header at index
-  void setHeaderSize(FXint index,FXint size);
-
-  /// Return width of header at index
-  FXint getHeaderSize(FXint index) const;
-
-  /// Return number of headers
-  FXint getNumHeaders() const;
-
-  /// Return the item at the given index
-  FXIconItem *getItem(FXint index) const;
-
-  /// Replace the item with a [possibly subclassed] item
-  FXint setItem(FXint index,FXIconItem* item,FXbool notify=FALSE);
-
-  /// Replace items text, icons, and user-data pointer
-  FXint setItem(FXint index,const FXString& text,FXIcon *big=NULL,FXIcon* mini=NULL,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Fill list by appending items from array of strings
-  FXint fillItems(const FXchar** strings,FXIcon *big=NULL,FXIcon* mini=NULL,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Fill list by appending items from newline separated strings
-  FXint fillItems(const FXString& strings,FXIcon *big=NULL,FXIcon* mini=NULL,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Insert a new [possibly subclassed] item at the give index
-  FXint insertItem(FXint index,FXIconItem* item,FXbool notify=FALSE);
-
-  /// Insert item at index with given text, icons, and user-data pointer
-  FXint insertItem(FXint index,const FXString& text,FXIcon *big=NULL,FXIcon* mini=NULL,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Append a [possibly subclassed] item to the end of the list
-  FXint appendItem(FXIconItem* item,FXbool notify=FALSE);
-
-  /// Append new item with given text and optional icons, and user-data pointer
-  FXint appendItem(const FXString& text,FXIcon *big=NULL,FXIcon* mini=NULL,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Prepend a [possibly subclassed] item to the end of the list
-  FXint prependItem(FXIconItem* item,FXbool notify=FALSE);
-
-  /// Prepend new item with given text and optional icons, and user-data pointer
-  FXint prependItem(const FXString& text,FXIcon *big=NULL,FXIcon* mini=NULL,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Move item from oldindex to newindex
-  FXint moveItem(FXint newindex,FXint oldindex,FXbool notify=FALSE);
-
-  /// Extract item from list
-  FXIconItem* extractItem(FXint index,FXbool notify=FALSE);
-
-  /// Remove item from list
-  void removeItem(FXint index,FXbool notify=FALSE);
-
-  /// Remove all items from list
-  void clearItems(FXbool notify=FALSE);
-
-  /// Return item width
-  FXint getItemWidth() const { return itemWidth; }
-
-  /// Return item height
-  FXint getItemHeight() const { return itemHeight; }
-
-  /// Return index of item at x,y, or -1 if none
-  virtual FXint getItemAt(FXint x,FXint y) const;
-
-  /**
-  * Search items by name, beginning from item start.  If the start
-  * item is -1 the search will start at the first item in the list.
-  * Flags may be SEARCH_FORWARD or SEARCH_BACKWARD to control the
-  * search direction; this can be combined with SEARCH_NOWRAP or SEARCH_WRAP
-  * to control whether the search wraps at the start or end of the list.
-  * The option SEARCH_IGNORECASE causes a case-insensitive match.  Finally,
-  * passing SEARCH_PREFIX causes searching for a prefix of the item name.
-  * Return -1 if no matching item is found.
-  */
-  FXint findItem(const FXString& text,FXint start=-1,FXuint flags=SEARCH_FORWARD|SEARCH_WRAP) const;
-
-  /**
-  * Search items by associated user data, beginning from item start. If the
-  * start item is -1 the search will start at the first item in the list.
-  * Flags may be SEARCH_FORWARD or SEARCH_BACKWARD to control the
-  * search direction; this can be combined with SEARCH_NOWRAP or SEARCH_WRAP
-  * to control whether the search wraps at the start or end of the list.
-  */
-  FXint findItemByData(const void *ptr,FXint start=-1,FXuint flags=SEARCH_FORWARD|SEARCH_WRAP) const;
-
-  /// Scroll to make item at index visible
-  virtual void makeItemVisible(FXint index);
-
-  /// Change item text
-  void setItemText(FXint index,const FXString& text);
-
-  /// Return item text
-  FXString getItemText(FXint index) const;
-
-  /// Change item big icon
-  void setItemBigIcon(FXint index,FXIcon* icon,FXbool owned=FALSE);
-
-  /// Return big icon of item at index
-  FXIcon* getItemBigIcon(FXint index) const;
-
-  /// Change item mini icon
-  void setItemMiniIcon(FXint index,FXIcon* icon,FXbool owned=FALSE);
-
-  /// Return mini icon of item at index
-  FXIcon* getItemMiniIcon(FXint index) const;
-
-  /// Change item user-data pointer
-  void setItemData(FXint index,void* ptr);
-
-  /// Return item user-data pointer
-  void* getItemData(FXint index) const;
-
-  /// Return TRUE if item at index is selected
-  FXbool isItemSelected(FXint index) const;
-
-  /// Return TRUE if item at index is current
-  FXbool isItemCurrent(FXint index) const;
-
-  /// Return TRUE if item at index is visible
-  FXbool isItemVisible(FXint index) const;
-
-  /// Return TRUE if item at index is enabled
-  FXbool isItemEnabled(FXint index) const;
-
-  /// Return item hit code: 0 outside, 1 icon, 2 text
-  FXint hitItem(FXint index,FXint x,FXint y,FXint ww=1,FXint hh=1) const;
-
-  /// Repaint item at index
-  void updateItem(FXint index) const;
-
-  /// Enable item at index
-  virtual FXbool enableItem(FXint index);
-
-  /// Disable item at index
-  virtual FXbool disableItem(FXint index);
-
-  /// Select item at index
-  virtual FXbool selectItem(FXint index,FXbool notify=FALSE);
-
-  /// Deselect item at index
-  virtual FXbool deselectItem(FXint index,FXbool notify=FALSE);
-
-  /// Toggle item at index
-  virtual FXbool toggleItem(FXint index,FXbool notify=FALSE);
-
-  /// Select items in rectangle
-  virtual FXbool selectInRectangle(FXint x,FXint y,FXint w,FXint h,FXbool notify=FALSE);
-
-  /// Extend selection from anchor index to index
-  virtual FXbool extendSelection(FXint index,FXbool notify=FALSE);
-
-  /// Deselect all items
-  virtual FXbool killSelection(FXbool notify=FALSE);
-
-  /// Change current item index
-  virtual void setCurrentItem(FXint index,FXbool notify=FALSE);
-
-  /// Return current item index, or -1 if none
-  FXint getCurrentItem() const { return current; }
-
-  /// Change anchor item index
-  void setAnchorItem(FXint index);
-
-  /// Return anchor item index, or -1 if none
-  FXint getAnchorItem() const { return anchor; }
-
-  /// Return index of item under cursor, or -1 if none
-  FXint getCursorItem() const { return cursor; }
-
-  /// Sort items
-  void sortItems();
-
-  /// Return sort function
-  FXIconListSortFunc getSortFunc() const { return sortfunc; }
-
-  /// Change sort function
-  void setSortFunc(FXIconListSortFunc func){ sortfunc=func; }
-
-  /// Change text font
-  void setFont(FXFont* fnt);
-
-  /// Return text font
-  FXFont* getFont() const { return font; }
-
-  /// Return normal text color
-  FXColor getTextColor() const { return textColor; }
-
-  /// Change normal text color
-  void setTextColor(FXColor clr);
-
-  /// Return selected text background
-  FXColor getSelBackColor() const { return selbackColor; }
-
-  /// Change selected text background
-  void setSelBackColor(FXColor clr);
-
-  /// Return selected text color
-  FXColor getSelTextColor() const { return seltextColor; }
-
-  /// Change selected text color
-  void setSelTextColor(FXColor clr);
-
-  /// Change maximum item space for each item
-  void setItemSpace(FXint s);
-
-  /// Return maximum item space
-  FXint getItemSpace() const { return itemSpace; }
-
-  /// Get the current icon list style
-  FXuint getListStyle() const;
-
-  /// Set the current icon list style.
-  void setListStyle(FXuint style);
-
-  /// Set the status line help text for this widget
-  void setHelpText(const FXString& text);
-
-  /// Get the status line help text for this widget
-  const FXString& getHelpText() const { return help; }
-
-  /// Save list to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load list from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXIconList();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXIconSource.h b/fox-includes/FXIconSource.h
deleted file mode 100644
index d41abd0f..00000000
--- a/fox-includes/FXIconSource.h
+++ /dev/null
@@ -1,153 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                            I c o n   S o u r c e                              *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2005,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXIconSource.h 2344 2006-02-12 21:19:36Z lyle $                      *
-********************************************************************************/
-#ifndef FXICONSOURCE_H
-#define FXICONSOURCE_H
-
-#ifndef FXOBJECT_H
-#include "FXObject.h"
-#endif
-
-namespace FX {
-
-class FXApp;
-class FXIcon;
-class FXImage;
-
-/**
-* An icon source is a class that loads an icon of any type.
-* It exists purely for convenience, to make loading icons
-* simpler by concentrating the knowledge of the supported
-* icon formats in a single place.
-* Needless to say, this class is subclassable, allowing users
-* to add additional icon types and make them available to
-* all widgets which deal with icons.
-* Note, the icons are loaded, but NOT created (realized) yet;
-* this allows users to manipulate the pixel data prior to
-* realizing the icons.
-*/
-class FXAPI FXIconSource : public FXObject {
-  FXDECLARE(FXIconSource)
-protected:
-  FXApp *app;
-protected:
-  FXIconSource():app(NULL){}
-private:
-  FXIconSource(const FXIconSource&);
-  FXIconSource &operator=(const FXIconSource&);
-  FXImage *scaleToSize(FXImage *image,FXint size,FXint qual) const;
-public:
-
-  /// Construct an icon source
-  FXIconSource(FXApp* a);
-
-  /**
-  * Load an icon from the file filename. By default, the file extension is
-  * stripped and used as the icon type; if an explicit icon type is forced,
-  * then that type is used and the extension is ignored.
-  * For example, loadIcon("icon","gif") will try to load a CompuServe GIF
-  * file, since the filename does not give any clue as to the type of the
-  * icon.
-  */
-  virtual FXIcon *loadIconFile(const FXString& filename,const FXString& type=FXString::null) const;
-
-  /**
-  * Load an icon of a given type (e.g. "gif") from reswrapped data.
-  * Returns NULL if there's some error loading the icon.  [The optional
-  * parameter is actually mandatory at the time of this writing; future
-  * versions will attempt to inspect the first few bytes of the stream
-  * to divine the icon format if the parameter is omitted].
-  */
-  virtual FXIcon *loadIconData(const void *pixels,const FXString& type=FXString::null) const;
-
-  /**
-  * Load an icon of a given type (e.g. "gif") from an already open stream.
-  * Returns NULL if there's some error loading the icon.  [The optional
-  * parameter is actually mandatory at the time of this writing; future
-  * versions will attempt to inspect the first few bytes of the stream
-  * to divine the icon format if the parameter is omitted].
-  */
-  virtual FXIcon *loadIconStream(FXStream& store,const FXString& type=FXString::null) const;
-
-  /**
-  * Load an image from the file filename. By default, the file extension is
-  * stripped and used as the image type; if an explicit image type is forced,
-  * then that type is used and the extension is ignored.
-  * For example, loadImage("image","gif") will try to load a CompuServe GIF
-  * file, since the filename does not give any clue as to the type of the
-  * image.
-  */
-  virtual FXImage *loadImageFile(const FXString& filename,const FXString& type=FXString::null) const;
-
-  /**
-  * Load an image of a given type (e.g. "gif") from reswrapped data.
-  * Returns NULL if there's some error loading the icon.  [The optional
-  * parameter is actually mandatory at the time of this writing; future
-  * versions will attempt to inspect the first few bytes of the stream
-  * to divine the icon format if the parameter is omitted].
-  */
-  virtual FXImage *loadImageData(const void *pixels,const FXString& type=FXString::null) const;
-
-  /**
-  * Load an image of a given type (e.g. "gif") from an already open stream.
-  * Returns NULL if there's some error loading the image.  [The optional
-  * parameter is actually mandatory at the time of this writing; future
-  * versions will attempt to inspect the first few bytes of the stream
-  * to divine the image format if the parameter is omitted].
-  */
-  virtual FXImage *loadImageStream(FXStream& store,const FXString& type=FXString::null) const;
-
-
-  /// Load icon and scale it such that its dimensions does not exceed given size
-  virtual FXIcon *loadScaledIconFile(const FXString& filename,FXint size=32,FXint qual=0,const FXString& type=FXString::null) const;
-
-  /// Load icon and scale it such that its dimensions does not exceed given size
-  virtual FXIcon *loadScaledIconData(const void *pixels,FXint size=32,FXint qual=0,const FXString& type=FXString::null) const;
-
-  /// Load icon and scale it such that its dimensions does not exceed given size
-  virtual FXIcon *loadScaledIconStream(FXStream& store,FXint size=32,FXint qual=0,const FXString& type=FXString::null) const;
-
-  /// Load image and scale it such that its dimensions does not exceed given size
-  virtual FXImage *loadScaledImageFile(const FXString& filename,FXint size=32,FXint qual=0,const FXString& type=FXString::null) const;
-
-  /// Load image and scale it such that its dimensions does not exceed given size
-  virtual FXImage *loadScaledImageData(const void *pixels,FXint size=32,FXint qual=0,const FXString& type=FXString::null) const;
-
-  /// Load image and scale it such that its dimensions does not exceed given size
-  virtual FXImage *loadScaledImageStream(FXStream& store,FXint size=32,FXint qual=0,const FXString& type=FXString::null) const;
-
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destroy
-  virtual ~FXIconSource();
-  };
-
-
-}
-
-#endif
diff --git a/fox-includes/FXId.h b/fox-includes/FXId.h
deleted file mode 100755
index d6e34b6b..00000000
--- a/fox-includes/FXId.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                                  X - O b j e c t                              *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2004 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXId.h 1889 2004-05-26 03:13:01Z lyle $                              *
-********************************************************************************/
-#ifndef FXID_H
-#define FXID_H
-
-#ifndef FXOBJECT_H
-#include "FXObject.h"
-#endif
-
-namespace FX {
-
-class FXApp;
-
-
-/// Encapsulates server side resource
-class FXAPI FXId : public FXObject {
-  FXDECLARE_ABSTRACT(FXId)
-private:
-  FXApp *app;             // Back link to application object
-  void  *data;            // User data
-protected:
-  FXID   xid;
-private:
-  FXId(const FXId&);
-  FXId &operator=(const FXId&);
-protected:
-  FXId():app((FXApp*)-1L),data(NULL),xid(0){}
-  FXId(FXApp* a):app(a),data(NULL),xid(0){}
-public:
-
-  /// Get application
-  FXApp* getApp() const { return app; }
-
-  /// Get XID handle
-  FXID id() const { return xid; }
-
-  /// Create resource
-  virtual void create(){}
-
-  /// Detach resource
-  virtual void detach(){}
-
-  /// Destroy resource
-  virtual void destroy(){}
-
-  /// Set user data pointer
-  void setUserData(void *ptr){ data=ptr; }
-
-  /// Get user data pointer
-  void* getUserData() const { return data; }
-
-  /// Save object to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load object from stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXId(){app=(FXApp*)-1L;}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXImage.h b/fox-includes/FXImage.h
deleted file mode 100755
index ccca3402..00000000
--- a/fox-includes/FXImage.h
+++ /dev/null
@@ -1,270 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                             I m a g e    O b j e c t                          *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXImage.h 2336 2006-02-04 15:20:33Z lyle $                           *
-********************************************************************************/
-#ifndef FXIMAGE_H
-#define FXIMAGE_H
-
-#ifndef FXDRAWABLE_H
-#include "FXDrawable.h"
-#endif
-
-namespace FX {
-
-
-/// Image rendering hints
-enum {
-  IMAGE_KEEP       = 0x00000001,      /// Keep pixel data in client
-  IMAGE_OWNED      = 0x00000002,      /// Pixel data is owned by image
-  IMAGE_DITHER     = 0,               /// Dither image to look better
-  IMAGE_NEAREST    = 0x00000004,      /// Turn off dithering and map to nearest color
-  IMAGE_OPAQUE     = 0x00000008,      /// Force opaque background
-  IMAGE_ALPHACOLOR = 0x00000010,      /// Override transparancy color
-  IMAGE_SHMI       = 0x00000020,      /// Using shared memory image
-  IMAGE_SHMP       = 0x00000040,      /// Using shared memory pixmap
-  IMAGE_ALPHAGUESS = 0x00000080       /// Guess transparency color from corners
-  };
-
-
-class FXDC;
-class FXDCWindow;
-
-
-/**
-* An Image is a rectangular array of pixels.  It supports two representations
-* of these pixels: a client-side pixel buffer which is stored as an array of
-* FXColor, and a server-side pixmap which is stored in an organization directly
-* compatible with the screen, for fast drawing onto the device.
-* The server-side representation is not directly accessible from the current
-* process as it lives in the process of the X Server or GDI.
-*/
-class FXAPI FXImage : public FXDrawable {
-  FXDECLARE(FXImage)
-  friend class FXDC;
-  friend class FXDCWindow;
-protected:
-  FXColor *data;        // Pixel data
-  FXuint   options;     // Options
-private:
-#ifdef WIN32
-  virtual FXID GetDC() const;
-  virtual int ReleaseDC(FXID) const;
-#endif
-#ifndef WIN32
-  void render_true_32(void *xim,FXuchar *img);
-  void render_true_24(void *xim,FXuchar *img);
-  void render_true_16_fast(void *xim,FXuchar *img);
-  void render_true_16_dither(void *xim,FXuchar *img);
-  void render_true_8_fast(void *xim,FXuchar *img);
-  void render_true_8_dither(void *xim,FXuchar *img);
-  void render_true_N_fast(void *xim,FXuchar *img);
-  void render_true_N_dither(void *xim,FXuchar *img);
-  void render_index_4_fast(void *xim,FXuchar *img);
-  void render_index_4_dither(void *xim,FXuchar *img);
-  void render_index_8_fast(void *xim,FXuchar *img);
-  void render_index_8_dither(void *xim,FXuchar *img);
-  void render_index_N_fast(void *xim,FXuchar *img);
-  void render_index_N_dither(void *xim,FXuchar *img);
-  void render_gray_8_fast(void *xim,FXuchar *img);
-  void render_gray_8_dither(void *xim,FXuchar *img);
-  void render_gray_N_fast(void *xim,FXuchar *img);
-  void render_gray_N_dither(void *xim,FXuchar *img);
-  void render_mono_1_fast(void *xim,FXuchar *img);
-  void render_mono_1_dither(void *xim,FXuchar *img);
-#endif
-protected:
-  FXImage();
-private:
-  FXImage(const FXImage&);
-  FXImage &operator=(const FXImage&);
-public:
-
-  /**
-  * Create an image.  If a client-side pixel buffer has been specified,
-  * the image does not own the pixel buffer unless the IMAGE_OWNED flag is
-  * set.  If the IMAGE_OWNED flag is set but a NULL pixel buffer is
-  * passed, a pixel buffer will be automatically created and will be owned
-  * by the image. The flags IMAGE_SHMI and IMAGE_SHMP may be specified for
-  * large images to instruct render() to use shared memory to communicate
-  * with the server.
-  */
-  FXImage(FXApp* a,const FXColor *pix=NULL,FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Change options
-  void setOptions(FXuint opts);
-
-  /// To get to the option flags
-  FXuint getOptions() const { return options; }
-
-  /**
-  * Populate the image with new pixel data of the same size; it will assume
-  * ownership of the pixel data if image IMAGE_OWNED option is passed.
-  * The server-side representation of the image, if it exists, is not updated.
-  * This can be done by calling render().
-  */
-  virtual void setData(FXColor *pix,FXuint opts=0);
-
-  /**
-  * Populate the image with new pixel data of a new size; it will assume ownership
-  * of the pixel data if image IMAGE_OWNED option is passed.  The size of the server-
-  * side representation of the image, if it exists, is adjusted but the contents are
-  * not updated yet. This can be done by calling render().
-  */
-  virtual void setData(FXColor *pix,FXuint opts,FXint w,FXint h);
-
-  /// Return pointer to the pixel data of the image
-  FXColor* getData() const { return data; }
-
-  /// Get pixel at x,y
-  FXColor getPixel(FXint x,FXint y) const { return data[y*width+x]; }
-
-  /// Change pixel at x,y
-  void setPixel(FXint x,FXint y,FXColor color){ data[y*width+x]=color; }
-
-  /// Scan the image and return false if fully opaque
-  bool hasAlpha() const;
-
-  /**
-  * Create the server side pixmap, then call render() to fill it with the
-  * pixel data from the client-side buffer.  After the server-side image has
-  * been created, the client-side pixel buffer will be deleted unless
-  * IMAGE_KEEP has been specified.  If the pixel buffer is not owned, i.e.
-  * the flag IMAGE_OWNED is not set, the pixel buffer will not be deleted,
-  * however the pixel buffer will be set to NULL.
-  */
-  virtual void create();
-
-  /**
-  * Detach the server side pixmap from the Image.
-  * Afterwards, the Image is left as if it never had a server-side resources.
-  */
-  virtual void detach();
-
-  /**
-  * Destroy the server-side pixmap.
-  * The client-side pixel buffer is not affected.
-  */
-  virtual void destroy();
-
-  /**
-  * Retrieves pixels from the server-side image.  For example, to make
-  * screen snapshots, or to retrieve an image after it has been drawn
-  * into by various means.
-  */
-  virtual void restore();
-
-  /**
-  * Render the server-side representation of the image from client-side
-  * pixels.  Normally, IMAGE_DITHER is used which causes the server-side
-  * representation to be rendered using a 16x16 ordered dither if necessary;
-  * however if IMAGE_NEAREST is used a faster (but uglier-looking), nearest
-  * neighbor algorithm is used.
-  */
-  virtual void render();
-
-  /**
-  * Release the client-side pixels buffer, free it if it was owned.
-  * If it is not owned, the image just forgets about the buffer.
-  */
-  virtual void release();
-
-  /**
-  * Resize both client-side and server-side representations (if any) to the
-  * given width and height.  The new representations typically contain garbage
-  * after this operation and need to be re-filled.
-  */
-  virtual void resize(FXint w,FXint h);
-
-  /**
-  * Rescale pixels image to the specified width and height; this calls
-  * resize() to adjust the client and server side representations.
-  */
-  virtual void scale(FXint w,FXint h,FXint quality=0);
-
-  /// Mirror image horizontally and/or vertically
-  virtual void mirror(bool horizontal,bool vertical);
-
-  /**
-  * Rotate image by degrees ccw; this calls resize() to adjust the client
-  * and server side representations if necessary.
-  */
-  virtual void rotate(FXint degrees);
-
-  /**
-  * Crop image to given rectangle; this calls resize() to adjust the client
-  * and server side representations.  The new image may be smaller or larger
-  * than the old one; blank areas are filled with color. There must be at
-  * least one pixel of overlap between the old and the new image.
-  */
-  virtual void crop(FXint x,FXint y,FXint w,FXint h,FXColor color=0);
-
-  /// Fill image with uniform color
-  virtual void fill(FXColor color);
-
-  /// Fade image to uniform color
-  virtual void fade(FXColor color,FXint factor=255);
-
-  /**
-  * Shear image horizontally; the number of pixels is equal to the
-  * shear parameter times 256.  The area outside the image is filled
-  * with transparent black, unless another color is specified.
-  */
-  virtual void xshear(FXint shear,FXColor clr=0);
-
-  /**
-  * Shear image vertically; the number of pixels is equal to the
-  * shear parameter times 256.  The area outside the image is filled
-  * with transparent black, unless another color is specified.
-  */
-  virtual void yshear(FXint shear,FXColor clr=0);
-
-  /// Fill horizontal gradient
-  virtual void hgradient(FXColor left,FXColor right);
-
-  /// Fill vertical gradient
-  virtual void vgradient(FXColor top,FXColor bottom);
-
-  /// Fill with gradient
-  virtual void gradient(FXColor topleft,FXColor topright,FXColor bottomleft,FXColor bottomright);
-
-  /// Blend image over uniform color
-  virtual void blend(FXColor color);
-
-  /// Save object to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load object from stream
-  virtual void load(FXStream& store);
-
-  /// Save pixel data only
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixel data only
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destructor
-  virtual ~FXImage();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXImageFrame.h b/fox-includes/FXImageFrame.h
deleted file mode 100755
index 4405d7ca..00000000
--- a/fox-includes/FXImageFrame.h
+++ /dev/null
@@ -1,89 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       I m a g e   F r a m e   W i d g e t                     *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2001,2002 by H. J. Daniel III. All Rights Reserved.             *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXImageFrame.h 1166 2002-12-19 18:11:19Z lyle $                       *
-********************************************************************************/
-#ifndef FXIMAGEFRAME_H
-#define FXIMAGEFRAME_H
-
-#ifndef FXFRAME_H
-#include "FXFrame.h"
-#endif
-
-namespace FX {
-
-
-/**
-* The image frame is a simple frame widget displaying
-* an image; the image is not owned by the image frame so
-* it must be explicitly deleted elsewhere.
-*/
-class FXAPI FXImageFrame : public FXFrame {
-  FXDECLARE(FXImageFrame)
-protected:
-  FXImage* image;       // The image being displayed
-protected:
-  FXImageFrame();
-private:
-  FXImageFrame(const FXImageFrame&);
-  FXImageFrame &operator=(const FXImageFrame&);
-public:
-  long onPaint(FXObject*,FXSelector,void* ptr);
-public:
-
-  /// Construct image frame and pass it an image
-  FXImageFrame(FXComposite* p,FXImage *img,FXuint opts=FRAME_SUNKEN|FRAME_THICK,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=0,FXint pr=0,FXint pt=0,FXint pb=0);
-
-  /// Create window
-  virtual void create();
-
-  /// Get default width
-  virtual FXint getDefaultWidth();
-
-  /// Get default height
-  virtual FXint getDefaultHeight();
-
-  /// Change the image being displayed
-  void setImage(FXImage* img);
-
-  /// Return the current image
-  FXImage* getImage() const { return image; }
-
-  /// Set the current justification mode.
-  void setJustify(FXuint mode);
-
-  /// Get the current justification mode.
-  FXuint getJustify() const;
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destroy the widget, but do not destroy the image
-  virtual ~FXImageFrame();
-  };
-
-}
-
-
-#endif
diff --git a/fox-includes/FXImageView.h b/fox-includes/FXImageView.h
deleted file mode 100755
index 8d3826c2..00000000
--- a/fox-includes/FXImageView.h
+++ /dev/null
@@ -1,120 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       I m a g e   V i e w   W i d g e t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2000,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXImageView.h 2336 2006-02-04 15:20:33Z lyle $                       *
-********************************************************************************/
-#ifndef FXIMAGEVIEW_H
-#define FXIMAGEVIEW_H
-
-#ifndef FXSCROLLAREA_H
-#include "FXScrollArea.h"
-#endif
-
-namespace FX {
-
-
-class FXImage;
-
-
-/// Image alignment styles
-enum {
-  IMAGEVIEW_NORMAL    = 0,              /// Normal mode is centered
-  IMAGEVIEW_CENTER_X  = 0,              /// Centered horizontally
-  IMAGEVIEW_LEFT      = 0x00100000,     /// Left-aligned
-  IMAGEVIEW_RIGHT     = 0x00200000,     /// Right-aligned
-  IMAGEVIEW_CENTER_Y  = 0,              /// Centered vertically
-  IMAGEVIEW_TOP       = 0x00400000,     /// Top-aligned
-  IMAGEVIEW_BOTTOM    = 0x00800000      /// Bottom-aligned
-  };
-
-
-/**
-* The Image View widget display a scrollable view of an image.
-*/
-class FXAPI FXImageView : public FXScrollArea {
-  FXDECLARE(FXImageView)
-protected:
-  FXImage *image;         // Image to view
-  FXint    grabx;         // Grab point x
-  FXint    graby;         // Grab point y
-protected:
-  FXImageView();
-private:
-  FXImageView(const FXImageView&);
-  FXImageView &operator=(const FXImageView&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onRightBtnPress(FXObject*,FXSelector,void*);
-  long onRightBtnRelease(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_XYZ=FXScrollArea::ID_LAST,
-    ID_LAST
-    };
-public:
-
-  /// Construct a scroll window
-  FXImageView(FXComposite* p,FXImage* img=NULL,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Image view widget can receive focus
-  virtual bool canFocus() const;
-
-  /// Return the width of the contents
-  virtual FXint getContentWidth();
-
-  /// Return the height of the contents
-  virtual FXint getContentHeight();
-
-  /// Change image
-  void setImage(FXImage* img);
-
-  /// Return image
-  FXImage* getImage() const { return image; }
-
-  /// Set the current alignment.
-  void setAlignment(FXuint mode);
-
-  /// Get the current alignment.
-  FXuint getAlignment() const;
-
-  /// Save list to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load list from a stream
-  virtual void load(FXStream& store);
-
-  /// Destroy
-  virtual ~FXImageView();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXInputDialog.h b/fox-includes/FXInputDialog.h
deleted file mode 100755
index a1a7626f..00000000
--- a/fox-includes/FXInputDialog.h
+++ /dev/null
@@ -1,132 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                         I n p u t   D i a l o g   B o x                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2000,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXInputDialog.h 2261 2005-12-02 01:34:31Z lyle $                     *
-********************************************************************************/
-#ifndef FXINPUTDIALOG_H
-#define FXINPUTDIALOG_H
-
-#ifndef FXDIALOGBOX_H
-#include "FXDialogBox.h"
-#endif
-
-namespace FX {
-
-
-/// Input dialog options
-enum {
-  INPUTDIALOG_STRING   = 0,             /// Ask for a string
-  INPUTDIALOG_INTEGER  = 0x01000000,    /// Ask for an integer number
-  INPUTDIALOG_REAL     = 0x02000000,    /// Ask for a real number
-  INPUTDIALOG_PASSWORD = 0x04000000     /// Do not reveal key-in
-  };
-
-
-class FXTextField;
-
-
-/**
-* An Input Dialog is a simple dialog which is used
-* to obtain a text string, integer, or real number from the user.
-* A password mode allows the key-in to remain hidden.
-*/
-class FXAPI FXInputDialog : public FXDialogBox {
-  FXDECLARE(FXInputDialog)
-protected:
-  FXTextField *input;       // Text field widget
-  FXdouble     limlo;       // Lower limit
-  FXdouble     limhi;       // Upper limit
-protected:
-  FXInputDialog(){}
-private:
-  FXInputDialog(const FXInputDialog&);
-  FXInputDialog &operator=(const FXInputDialog&);
-  void initialize(const FXString& text,FXIcon* icon);
-public:
-  long onCmdAccept(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct input dialog box with given caption, icon, and prompt text
-  FXInputDialog(FXWindow* owner,const FXString& caption,const FXString& label,FXIcon* icon=NULL,FXuint opts=INPUTDIALOG_STRING,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Construct free floating input dialog box with given caption, icon, and prompt text
-  FXInputDialog(FXApp* app,const FXString& caption,const FXString& label,FXIcon* icon=NULL,FXuint opts=INPUTDIALOG_STRING,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Get input string
-  FXString getText() const;
-
-  /// Set input string
-  void setText(const FXString& text);
-
-  /// Change number of visible columns of text
-  void setNumColumns(FXint num);
-
-  /// Return number of visible columns of text
-  FXint getNumColumns() const;
-
-  /// Change limits
-  void setLimits(FXdouble lo,FXdouble hi){ limlo=lo; limhi=hi; }
-
-  /// Return limits
-  void getLimits(FXdouble& lo,FXdouble& hi){ lo=limlo; hi=limhi; }
-
-  /// Run modal invocation of the dialog
-  virtual FXuint execute(FXuint placement=PLACEMENT_CURSOR);
-
-  /**
-  * Prompt for a string, start with the initial value.
-  * Return TRUE if the new value is accepted, and false otherwise.
-  */
-  static FXbool getString(FXString& result,FXWindow* owner,const FXString& caption,const FXString& label,FXIcon* icon=NULL);
-
-  /**
-  * Prompt for a string, in free floating window.
-  */
-  static FXbool getString(FXString& result,FXApp* app,const FXString& caption,const FXString& label,FXIcon* icon=NULL);
-
-  /**
-  * Prompt for an integer number, start with the given initial value.
-  * Return TRUE if the new value is accepted, and false otherwise.
-  * The input is constrained between lo and hi.
-  */
-  static FXbool getInteger(FXint& result,FXWindow* owner,const FXString& caption,const FXString& label,FXIcon* icon=NULL,FXint lo=-2147483647,FXint hi=2147483647);
-
-  /**
-  * Prompt for a integer number, in free floating window.
-  */
-  static FXbool getInteger(FXint& result,FXApp* app,const FXString& caption,const FXString& label,FXIcon* icon=NULL,FXint lo=-2147483647,FXint hi=2147483647);
-
-  /**
-  * Prompt for an real number, start with the given initial value.
-  * Return TRUE if the new value is accepted, and false otherwise.
-  * The input is constrained between lo and hi.
-  */
-  static FXbool getReal(FXdouble& result,FXWindow* owner,const FXString& caption,const FXString& label,FXIcon* icon=NULL,FXdouble lo=-1.797693134862315e+308,FXdouble hi=1.797693134862315e+308);
-
-  /**
-  * Prompt for a real number, in free floating window.
-  */
-  static FXbool getReal(FXdouble& result,FXApp* app,const FXString& caption,const FXString& label,FXIcon* icon=NULL,FXdouble lo=-1.797693134862315e+308,FXdouble hi=1.797693134862315e+308);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXJPGIcon.h b/fox-includes/FXJPGIcon.h
deleted file mode 100755
index 831b523a..00000000
--- a/fox-includes/FXJPGIcon.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                         J P E G   I c o n   O b j e c t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2000,2006 by David Tyree.   All Rights Reserved.                *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXJPGIcon.h 2343 2006-02-12 20:26:26Z lyle $                         *
-********************************************************************************/
-#ifndef FXJPGICON_H
-#define FXJPGICON_H
-
-#ifndef FXICON_H
-#include "FXIcon.h"
-#endif
-
-namespace FX {
-
-
-/// JPEG Icon class
-class FXAPI FXJPGIcon : public FXIcon {
-  FXDECLARE(FXJPGIcon)
-protected:
-  FXint quality;
-protected:
-  FXJPGIcon(){}
-private:
-  FXJPGIcon(const FXJPGIcon&);
-  FXJPGIcon &operator=(const FXJPGIcon&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct an icon from memory stream formatted in JPEG format
-  FXJPGIcon(FXApp *a,const void *pix=NULL,FXColor clr=FXRGB(192,192,192),FXuint opts=0,FXint w=1,FXint h=1,FXint q=75);
-
-  /// True if format is supported
-  static const bool supported;
-
-  /// Set image quality to save with
-  void setQuality(FXint q){ quality=q; }
-
-  /// Get image quality setting
-  FXint getQuality() const { return quality; }
-
-  /// Save pixels into stream in JPEG format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in JPEG format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy
-  virtual ~FXJPGIcon();
-  };
-
-
-
-/**
-* Check if stream contains a JPG, return TRUE if so.
-*/
-extern FXAPI bool fxcheckJPG(FXStream& store);
-
-
-/**
-* Load an JPEG (Joint Photographics Experts Group) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadJPG(FXStream& store,FXColor*& data,FXint& width,FXint& height,FXint& quality);
-
-
-/**
-* Save an JPEG (Joint Photographics Experts Group) file to a stream.
-*/
-extern FXAPI bool fxsaveJPG(FXStream& store,const FXColor* data,FXint width,FXint height,FXint quality);
-
-}
-
-#endif
diff --git a/fox-includes/FXJPGImage.h b/fox-includes/FXJPGImage.h
deleted file mode 100755
index a8ffef6e..00000000
--- a/fox-includes/FXJPGImage.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                      J P E G   I m a g e   O b j e c t                        *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2000,2006 by David Tyree.   All Rights Reserved.                *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXJPGImage.h 2343 2006-02-12 20:26:26Z lyle $                        *
-********************************************************************************/
-#ifndef FXJPGIMAGE_H
-#define FXJPGIMAGE_H
-
-#ifndef FXIMAGE_H
-#include "FXImage.h"
-#endif
-
-namespace FX {
-
-
-/// JPEG Image class
-class FXAPI FXJPGImage : public FXImage {
-  FXDECLARE(FXJPGImage)
-protected:
-  FXint quality;
-protected:
-  FXJPGImage(){}
-private:
-  FXJPGImage(const FXJPGImage&);
-  FXJPGImage &operator=(const FXJPGImage&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct an image from memory stream formatted in JPEG format
-  FXJPGImage(FXApp *a,const void *pix=NULL,FXuint opts=0,FXint w=1,FXint h=1,FXint q=75);
-
-  /// True if format is supported
-  static const bool supported;
-
-  /// Set image quality to save with
-  void setQuality(FXint q){ quality=q; }
-
-  /// Get image quality setting
-  FXint getQuality() const { return quality; }
-
-  /// Save pixels into stream in JPEG format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Load pixels from stream in JPEG format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Destroy
-  virtual ~FXJPGImage();
-  };
-
-
-/**
-* Check if stream contains a JPG, return TRUE if so.
-*/
-extern FXAPI bool fxcheckJPG(FXStream& store);
-
-
-/**
-* Load an JPEG (Joint Photographics Experts Group) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadJPG(FXStream& store,FXColor*& data,FXint& width,FXint& height,FXint& quality);
-
-
-/**
-* Save an JPEG (Joint Photographics Experts Group) file to a stream.
-*/
-extern FXAPI bool fxsaveJPG(FXStream& store,const FXColor* data,FXint width,FXint height,FXint quality);
-
-}
-
-#endif
diff --git a/fox-includes/FXKOI8RCodec.h b/fox-includes/FXKOI8RCodec.h
deleted file mode 100644
index c378897a..00000000
--- a/fox-includes/FXKOI8RCodec.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#ifndef FXKOI8RCODEC_H
-#define FXKOI8RCODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-
-
-namespace FX {
-
-
-/// KOI8-R Codec
-class FXAPI FXKOI8RCodec : public FXTextCodec {
-  FXDECLARE(FXKOI8RCodec)
-public:
-  FXKOI8RCodec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXKOI8RCodec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXKnob.h b/fox-includes/FXKnob.h
deleted file mode 100644
index 2192e16f..00000000
--- a/fox-includes/FXKnob.h
+++ /dev/null
@@ -1,194 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                             K n o b   W i d g e t                             *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2005 by Leandro Nini.   All Rights Reserved.                    *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXKnob.h 2336 2006-02-04 15:20:33Z lyle $                             *
-********************************************************************************/
-#ifndef FXKNOB_H
-#define FXKNOB_H
-
-#ifndef FXFRAME_H
-#include "FXFrame.h"
-#endif
-
-namespace FX {
-
-
-/// Knob Control styles
-enum {
-  KNOB_NEEDLE    = 0,                           /// Use a needle as indicator
-  KNOB_DOT       = 0x00008000,                  /// Use a dot as indicator
-  KNOB_TICKS     = 0x00010000,                  /// Show ticks around the knob
-  KNOB_INDICATOR = 0x00020000,                  /// Show only the indicator (like a speedometer)
-  KNOB_NORMAL    = (KNOB_NEEDLE|KNOB_TICKS)     /// Normal knob looks
-  };
-
-
-
-/**
-* The knob widget is a valuator widget which provides simple linear value range.
-* While being moved, the knob sends SEL_CHANGED messages to its target;
-* at the end of the interaction, a final SEL_COMMAND message is sent.
-* The message data represents the current knob value, of type FXint.
-*/
-class FXAPI FXKnob : public FXFrame {
-  FXDECLARE(FXKnob)
-protected:
-  FXint    range[2];            // Reported data range
-  FXdouble limits[2];           // Starting and ending positions
-  FXColor  lineColor;           // Color of indicator needle
-  FXint    pos;                 // Reported data position
-  FXint    incr;                // Increment when auto-sliding
-  FXint    delta;               // Interval between ticks
-  FXString help;                // Help string
-  FXString tip;                 // Tip string
-protected:
-  FXKnob();
-  FXint calcValue(FXint x,FXint y);
-private:
-  FXKnob(const FXKnob&);
-  FXKnob &operator=(const FXKnob&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onMiddleBtnPress(FXObject*,FXSelector,void*);
-  long onMiddleBtnRelease(FXObject*,FXSelector,void*);
-  long onMouseWheel(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onFocusIn(FXObject*,FXSelector,void*);
-  long onFocusOut(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onAutoSlide(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-  long onCmdSetRealValue(FXObject*,FXSelector,void*);
-  long onCmdGetRealValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntRange(FXObject*,FXSelector,void*);
-  long onCmdGetIntRange(FXObject*,FXSelector,void*);
-  long onCmdSetRealRange(FXObject*,FXSelector,void*);
-  long onCmdGetRealRange(FXObject*,FXSelector,void*);
-  long onCmdSetHelp(FXObject*,FXSelector,void*);
-  long onCmdGetHelp(FXObject*,FXSelector,void*);
-  long onCmdSetTip(FXObject*,FXSelector,void*);
-  long onCmdGetTip(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-public:
-  enum{
-    ID_AUTOSLIDE=FXFrame::ID_LAST,
-    ID_LAST
-    };
-public:
-
-  /// Construct a knob widget
-  FXKnob(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=KNOB_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Returns true because a knob can receive focus
-  virtual bool canFocus() const;
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Enable the knob
-  virtual void enable();
-
-  /// Disable the knob
-  virtual void disable();
-
-  /// Change knob value
-  void setValue(FXint value,FXbool notify=FALSE);
-
-  /// Return knob value
-  FXint getValue() const { return pos; }
-
-  /// Change the knob's range
-  void setRange(FXint lo,FXint hi,FXbool notify=FALSE);
-
-  /// Get the knob's current range
-  void getRange(FXint& lo,FXint& hi) const { lo=range[0]; hi=range[1]; }
-
-  /**
-  * Change the knob's movement limits (start and ending angles)
-  * accept values in degrees from 0 (south) to 360.
-  */
-  void setLimits(FXint start,FXint end,FXbool notify=FALSE);
-
-  /// Get the knob's current limits
-  void getLimits(FXint& start,FXint& end);
-
-  /// Change the knob style
-  FXuint getKnobStyle() const;
-
-  /// Get the current knob style
-  void setKnobStyle(FXuint style);
-
-  /// Get the knob's auto-increment/decrement value
-  FXint getIncrement() const { return incr; }
-
-  /// Change the knob's auto-increment/decrement value
-  void setIncrement(FXint inc){ incr=inc; }
-
-  /// Change the delta between ticks
-  void setTickDelta(FXint dist);
-
-  /// Get delta between ticks
-  FXint getTickDelta() const { return delta; }
-
-  /// Change the indicator needle color
-  void setLineColor(FXColor clr);
-
-  /// Get the current indicator needle color
-  FXColor getLineColor() const { return lineColor; }
-
-  /// Set the help text to be displayed on the status line
-  void setHelpText(const FXString& text){ help=text; }
-
-  /// Get the current help text
-  const FXString& getHelpText() const { return help; }
-
-  /// Set the tip text to be displayed in the tooltip
-  void setTipText(const FXString& text){ tip=text; }
-
-  /// Get the current tooltip text value
-  const FXString& getTipText() const { return tip; }
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destroy the knob
-  virtual ~FXKnob();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXLabel.h b/fox-includes/FXLabel.h
deleted file mode 100755
index 9b4cded0..00000000
--- a/fox-includes/FXLabel.h
+++ /dev/null
@@ -1,186 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                            L a b e l   W i d g e t                            *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXLabel.h 2360 2006-03-29 04:10:56Z lyle $                           *
-********************************************************************************/
-#ifndef FXLABEL_H
-#define FXLABEL_H
-
-#ifndef FXFRAME_H
-#include "FXFrame.h"
-#endif
-
-namespace FX {
-
-
-/// Relationship options for icon-labels
-enum {
-  ICON_UNDER_TEXT      = 0,			      /// Icon appears under text
-  ICON_AFTER_TEXT      = 0x00080000,		      /// Icon appears after text (to its right)
-  ICON_BEFORE_TEXT     = 0x00100000,		      /// Icon appears before text (to its left)
-  ICON_ABOVE_TEXT      = 0x00200000,		      /// Icon appears above text
-  ICON_BELOW_TEXT      = 0x00400000,		      /// Icon appears below text
-  TEXT_OVER_ICON       = ICON_UNDER_TEXT,	      /// Same as ICON_UNDER_TEXT
-  TEXT_AFTER_ICON      = ICON_BEFORE_TEXT,	      /// Same as ICON_BEFORE_TEXT
-  TEXT_BEFORE_ICON     = ICON_AFTER_TEXT,	      /// Same as ICON_AFTER_TEXT
-  TEXT_ABOVE_ICON      = ICON_BELOW_TEXT,	      /// Same as ICON_BELOW_TEXT
-  TEXT_BELOW_ICON      = ICON_ABOVE_TEXT	      /// Same as ICON_ABOVE_TEXT
-  };
-
-
-/// Normal way to show label
-enum {
-  LABEL_NORMAL         = JUSTIFY_NORMAL|ICON_BEFORE_TEXT
-  };
-
-
-class FXIcon;
-class FXFont;
-
-
-/**
-* A label widget can be used to place a text and/or icon for
-* explanation purposes.  The text label may have an optional tooltip
-* and/or help string.  Icon and label are placed relative to the widget
-* using the justfication options, and relative to each other as determined
-* by the icon relationship options.  A large number of arrangements is
-* possible.
-*/
-class FXAPI FXLabel : public FXFrame {
-  FXDECLARE(FXLabel)
-protected:
-  FXString label;       // Text on the label
-  FXIcon*  icon;        // Icon on the label
-  FXFont*  font;        // Label font
-  FXHotKey hotkey;      // Hotkey
-  FXint    hotoff;      // Offset in string
-  FXColor  textColor;   // Text color
-  FXString tip;         // Tooltip
-  FXString help;        // Help message
-protected:
-  FXLabel();
-  FXint labelHeight(const FXString& text) const;
-  FXint labelWidth(const FXString& text) const;
-  void drawLabel(FXDCWindow& dc,const FXString& text,FXint hot,FXint tx,FXint ty,FXint tw,FXint th);
-  void just_x(FXint& tx,FXint& ix,FXint tw,FXint iw);
-  void just_y(FXint& ty,FXint& iy,FXint th,FXint ih);
-private:
-  FXLabel(const FXLabel&);
-  FXLabel &operator=(const FXLabel&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onHotKeyPress(FXObject*,FXSelector,void*);
-  long onHotKeyRelease(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetStringValue(FXObject*,FXSelector,void*);
-  long onCmdGetStringValue(FXObject*,FXSelector,void*);
-  long onCmdSetIconValue(FXObject*,FXSelector,void*);
-  long onCmdGetIconValue(FXObject*,FXSelector,void*);
-  long onCmdSetHelp(FXObject*,FXSelector,void*);
-  long onCmdGetHelp(FXObject*,FXSelector,void*);
-  long onCmdSetTip(FXObject*,FXSelector,void*);
-  long onCmdGetTip(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct label with given text and icon
-  FXLabel(FXComposite* p,const FXString& text,FXIcon* ic=0,FXuint opts=LABEL_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Enable the window
-  virtual void enable();
-
-  /// Disable the window
-  virtual void disable();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Set the text for this label
-  void setText(const FXString& text);
-
-  /// Get the text for this label
-  FXString getText() const { return label; }
-
-  /// Set the icon for this label
-  void setIcon(FXIcon* ic);
-
-  /// Get the icon for this label
-  FXIcon* getIcon() const { return icon; }
-
-  /// Set the text font
-  void setFont(FXFont *fnt);
-
-  /// Get the text font
-  FXFont* getFont() const { return font; }
-
-  /// Get the current text color
-  FXColor getTextColor() const { return textColor; }
-
-  /// Set the current text color
-  void setTextColor(FXColor clr);
-
-  /// Set the current text-justification mode.
-  void setJustify(FXuint mode);
-
-  /// Get the current text-justification mode.
-  FXuint getJustify() const;
-
-  /// Set the current icon position
-  void setIconPosition(FXuint mode);
-
-  /// Get the current icon position
-  FXuint getIconPosition() const;
-
-  /// Set the status line help text for this label
-  void setHelpText(const FXString& text){ help=text; }
-
-  /// Get the status line help text for this label
-  const FXString& getHelpText() const { return help; }
-
-  /// Set the tool tip message for this label
-  void setTipText(const FXString& text){ tip=text; }
-
-  /// Get the tool tip message for this label
-  const FXString& getTipText() const { return tip; }
-
-  /// Save label to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load label from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXLabel();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXList.h b/fox-includes/FXList.h
deleted file mode 100755
index 305e6258..00000000
--- a/fox-includes/FXList.h
+++ /dev/null
@@ -1,487 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                            L i s t   W i d g e t                              *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXList.h 2336 2006-02-04 15:20:33Z lyle $                            *
-********************************************************************************/
-#ifndef FXLIST_H
-#define FXLIST_H
-
-#ifndef FXSCROLLAREA_H
-#include "FXScrollArea.h"
-#endif
-
-namespace FX {
-
-
-/// List styles
-enum {
-  LIST_EXTENDEDSELECT    = 0,             /// Extended selection mode allows for drag-selection of ranges of items
-  LIST_SINGLESELECT      = 0x00100000,    /// Single selection mode allows up to one item to be selected
-  LIST_BROWSESELECT      = 0x00200000,    /// Browse selection mode enforces one single item to be selected at all times
-  LIST_MULTIPLESELECT    = 0x00300000,    /// Multiple selection mode is used for selection of individual items
-  LIST_AUTOSELECT        = 0x00400000,    /// Automatically select under cursor
-  LIST_NORMAL            = LIST_EXTENDEDSELECT
-  };
-
-
-class FXIcon;
-class FXFont;
-class FXList;
-
-
-/// List item
-class FXAPI FXListItem : public FXObject {
-  FXDECLARE(FXListItem)
-  friend class FXList;
-protected:
-  FXString  label;
-  FXIcon   *icon;
-  void     *data;
-  FXuint    state;
-  FXint     x,y;
-private:
-  FXListItem(const FXListItem&);
-  FXListItem& operator=(const FXListItem&);
-protected:
-  FXListItem():icon(NULL),data(NULL),state(0),x(0),y(0){}
-  virtual void draw(const FXList* list,FXDC& dc,FXint x,FXint y,FXint w,FXint h);
-  virtual FXint hitItem(const FXList* list,FXint x,FXint y) const;
-public:
-  enum {
-    SELECTED  = 1,      /// Selected
-    FOCUS     = 2,      /// Focus
-    DISABLED  = 4,      /// Disabled
-    DRAGGABLE = 8,      /// Draggable
-    ICONOWNED = 16      /// Icon owned by item
-    };
-public:
-
-  /// Construct new item with given text, icon, and user-data
-  FXListItem(const FXString& text,FXIcon* ic=NULL,void* ptr=NULL):label(text),icon(ic),data(ptr),state(0),x(0),y(0){}
-
-  /// Change item's text label
-  virtual void setText(const FXString& txt);
-
-  /// Return item's text label
-  const FXString& getText() const { return label; }
-
-  /// Change item's icon, deleting the old icon if it was owned
-  virtual void setIcon(FXIcon* icn,FXbool owned=FALSE);
-
-  /// Return item's icon
-  FXIcon* getIcon() const { return icon; }
-
-  /// Change item's user data
-  void setData(void* ptr){ data=ptr; }
-
-  /// Get item's user data
-  void* getData() const { return data; }
-
-  /// Make item draw as focused
-  virtual void setFocus(FXbool focus);
-
-  /// Return true if item has focus
-  FXbool hasFocus() const { return (state&FOCUS)!=0; }
-
-  /// Select item
-  virtual void setSelected(FXbool selected);
-
-  /// Return true if this item is selected
-  FXbool isSelected() const { return (state&SELECTED)!=0; }
-
-  /// Enable or disable item
-  virtual void setEnabled(FXbool enabled);
-
-  /// Return true if this item is enabled
-  FXbool isEnabled() const { return (state&DISABLED)==0; }
-
-  /// Make item draggable
-  virtual void setDraggable(FXbool draggable);
-
-  /// Return true if this item is draggable
-  FXbool isDraggable() const { return (state&DRAGGABLE)!=0; }
-
-  /// Return width of item as drawn in list
-  virtual FXint getWidth(const FXList* list) const;
-
-  /// Return height of item as drawn in list
-  virtual FXint getHeight(const FXList* list) const;
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Destroy server-side resources
-  virtual void destroy();
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destroy item and free icons if owned
-  virtual ~FXListItem();
-  };
-
-
-/// List item collate function
-typedef FXint (*FXListSortFunc)(const FXListItem*,const FXListItem*);
-
-
-typedef FXObjectListOf<FXListItem> FXListItemList;
-
-
-/**
-* A List Widget displays a list of items, each with a text and
-* optional icon.  When an item's selected state changes, the list sends
-* a SEL_SELECTED or SEL_DESELECTED message.  A change of the current
-* item is signified by the SEL_CHANGED message.
-* The list sends SEL_COMMAND messages when the user clicks on an item,
-* and SEL_CLICKED, SEL_DOUBLECLICKED, and SEL_TRIPLECLICKED when the user
-* clicks once, twice, or thrice, respectively.
-* When items are added, replaced, or removed, the list sends messages of
-* the type SEL_INSERTED, SEL_REPLACED, or SEL_DELETED.
-* In each of these cases, the index to the item, if any, is passed in the
-* 3rd argument of the message.
-*/
-class FXAPI FXList : public FXScrollArea {
-  FXDECLARE(FXList)
-protected:
-  FXListItemList items;             // Item list
-  FXint          anchor;            // Anchor item
-  FXint          current;           // Current item
-  FXint          extent;            // Extent item
-  FXint          cursor;            // Cursor item
-  FXint          viewable;          // Viewable item
-  FXFont        *font;              // Font
-  FXColor        textColor;         // Text color
-  FXColor        selbackColor;      // Selected back color
-  FXColor        seltextColor;      // Selected text color
-  FXint          listWidth;         // List width
-  FXint          listHeight;        // List height
-  FXint          visible;           // Number of rows high
-  FXString       help;              // Help text
-  FXListSortFunc sortfunc;          // Item sort function
-  FXint          grabx;             // Grab point x
-  FXint          graby;             // Grab point y
-  FXString       lookup;            // Lookup string
-  FXbool         state;             // State of item
-protected:
-  FXList();
-  void recompute();
-  virtual FXListItem *createItem(const FXString& text,FXIcon* icon,void* ptr);
-private:
-  FXList(const FXList&);
-  FXList &operator=(const FXList&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onEnter(FXObject*,FXSelector,void*);
-  long onLeave(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onRightBtnPress(FXObject*,FXSelector,void*);
-  long onRightBtnRelease(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onFocusIn(FXObject*,FXSelector,void*);
-  long onFocusOut(FXObject*,FXSelector,void*);
-  long onAutoScroll(FXObject*,FXSelector,void*);
-  long onClicked(FXObject*,FXSelector,void*);
-  long onDoubleClicked(FXObject*,FXSelector,void*);
-  long onTripleClicked(FXObject*,FXSelector,void*);
-  long onCommand(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onTipTimer(FXObject*,FXSelector,void*);
-  long onLookupTimer(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);public:
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-public:
-  static FXint ascending(const FXListItem* a,const FXListItem* b);
-  static FXint descending(const FXListItem* a,const FXListItem* b);
-  static FXint ascendingCase(const FXListItem* a,const FXListItem* b);
-  static FXint descendingCase(const FXListItem* a,const FXListItem* b);
-public:
-  enum {
-    ID_LOOKUPTIMER=FXScrollArea::ID_LAST,
-    ID_LAST
-    };
-public:
-
-  /// Construct a list with initially no items in it
-  FXList(FXComposite *p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=LIST_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Compute and return content width
-  virtual FXint getContentWidth();
-
-  /// Return content height
-  virtual FXint getContentHeight();
-
-  /// Recalculate layout
-  virtual void recalc();
-
-  /// List widget can receive focus
-  virtual bool canFocus() const;
-
-  /// Move the focus to this window
-  virtual void setFocus();
-
-  /// Remove the focus from this window
-  virtual void killFocus();
-
-  /// Return the number of items in the list
-  FXint getNumItems() const { return items.no(); }
-
-  /// Return number of visible items
-  FXint getNumVisible() const { return visible; }
-
-  /// Change the number of visible items
-  void setNumVisible(FXint nvis);
-
-  /// Return the item at the given index
-  FXListItem *getItem(FXint index) const;
-
-  /// Replace the item with a [possibly subclassed] item
-  FXint setItem(FXint index,FXListItem* item,FXbool notify=FALSE);
-
-  /// Replace items text, icon, and user-data pointer
-  FXint setItem(FXint index,const FXString& text,FXIcon *icon=NULL,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Fill list by appending items from array of strings
-  FXint fillItems(const FXchar** strings,FXIcon *icon=NULL,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Fill list by appending items from newline separated strings
-  FXint fillItems(const FXString& strings,FXIcon *icon=NULL,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Insert a new [possibly subclassed] item at the give index
-  FXint insertItem(FXint index,FXListItem* item,FXbool notify=FALSE);
-
-  /// Insert item at index with given text, icon, and user-data pointer
-  FXint insertItem(FXint index,const FXString& text,FXIcon *icon=NULL,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Append a [possibly subclassed] item to the list
-  FXint appendItem(FXListItem* item,FXbool notify=FALSE);
-
-  /// Append new item with given text and optional icon, and user-data pointer
-  FXint appendItem(const FXString& text,FXIcon *icon=NULL,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Prepend a [possibly subclassed] item to the list
-  FXint prependItem(FXListItem* item,FXbool notify=FALSE);
-
-  /// Prepend new item with given text and optional icon, and user-data pointer
-  FXint prependItem(const FXString& text,FXIcon *icon=NULL,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Move item from oldindex to newindex
-  FXint moveItem(FXint newindex,FXint oldindex,FXbool notify=FALSE);
-
-  /// Extract item from list
-  FXListItem* extractItem(FXint index,FXbool notify=FALSE);
-
-  /// Remove item from list
-  void removeItem(FXint index,FXbool notify=FALSE);
-
-  /// Remove all items from list
-  void clearItems(FXbool notify=FALSE);
-
-  /// Return item width
-  FXint getItemWidth(FXint index) const;
-
-  /// Return item height
-  FXint getItemHeight(FXint index) const;
-
-  /// Return index of item at x,y, if any
-  virtual FXint getItemAt(FXint x,FXint y) const;
-
-  /// Return item hit code: 0 no hit; 1 hit the icon; 2 hit the text
-  FXint hitItem(FXint index,FXint x,FXint y) const;
-
-  /**
-  * Search items by name, beginning from item start.  If the start
-  * item is -1 the search will start at the first item in the list.
-  * Flags may be SEARCH_FORWARD or SEARCH_BACKWARD to control the
-  * search direction; this can be combined with SEARCH_NOWRAP or SEARCH_WRAP
-  * to control whether the search wraps at the start or end of the list.
-  * The option SEARCH_IGNORECASE causes a case-insensitive match.  Finally,
-  * passing SEARCH_PREFIX causes searching for a prefix of the item name.
-  * Return -1 if no matching item is found.
-  */
-  FXint findItem(const FXString& text,FXint start=-1,FXuint flags=SEARCH_FORWARD|SEARCH_WRAP) const;
-
-  /**
-  * Search items by associated user data, beginning from item start. If the
-  * start item is -1 the search will start at the first item in the list.
-  * Flags may be SEARCH_FORWARD or SEARCH_BACKWARD to control the
-  * search direction; this can be combined with SEARCH_NOWRAP or SEARCH_WRAP
-  * to control whether the search wraps at the start or end of the list.
-  */
-  FXint findItemByData(const void *ptr,FXint start=-1,FXuint flags=SEARCH_FORWARD|SEARCH_WRAP) const;
-
-  /// Scroll to bring item into view
-  virtual void makeItemVisible(FXint index);
-
-  /// Change item text
-  void setItemText(FXint index,const FXString& text);
-
-  /// Return item text
-  FXString getItemText(FXint index) const;
-
-  /// Change item icon, deleting the old icon if it was owned
-  void setItemIcon(FXint index,FXIcon* icon,FXbool owned=FALSE);
-
-  /// Return item icon, if any
-  FXIcon* getItemIcon(FXint index) const;
-
-  /// Change item user-data pointer
-  void setItemData(FXint index,void* ptr);
-
-  /// Return item user-data pointer
-  void* getItemData(FXint index) const;
-
-  /// Return TRUE if item is selected
-  FXbool isItemSelected(FXint index) const;
-
-  /// Return TRUE if item is current
-  FXbool isItemCurrent(FXint index) const;
-
-  /// Return TRUE if item is visible
-  FXbool isItemVisible(FXint index) const;
-
-  /// Return TRUE if item is enabled
-  FXbool isItemEnabled(FXint index) const;
-
-  /// Repaint item
-  void updateItem(FXint index) const;
-
-  /// Enable item
-  virtual FXbool enableItem(FXint index);
-
-  /// Disable item
-  virtual FXbool disableItem(FXint index);
-
-  /// Select item
-  virtual FXbool selectItem(FXint index,FXbool notify=FALSE);
-
-  /// Deselect item
-  virtual FXbool deselectItem(FXint index,FXbool notify=FALSE);
-
-  /// Toggle item selection state
-  virtual FXbool toggleItem(FXint index,FXbool notify=FALSE);
-
-  /// Extend selection from anchor item to index
-  virtual FXbool extendSelection(FXint index,FXbool notify=FALSE);
-
-  /// Deselect all items
-  virtual FXbool killSelection(FXbool notify=FALSE);
-
-  /// Change current item
-  virtual void setCurrentItem(FXint index,FXbool notify=FALSE);
-
-  /// Return current item, if any
-  FXint getCurrentItem() const { return current; }
-
-  /// Change anchor item
-  void setAnchorItem(FXint index);
-
-  /// Return anchor item, if any
-  FXint getAnchorItem() const { return anchor; }
-
-  /// Get item under the cursor, if any
-  FXint getCursorItem() const { return cursor; }
-
-  /// Sort items using current sort function
-  void sortItems();
-
-  /// Return sort function
-  FXListSortFunc getSortFunc() const { return sortfunc; }
-
-  /// Change sort function
-  void setSortFunc(FXListSortFunc func){ sortfunc=func; }
-
-  /// Change text font
-  void setFont(FXFont* fnt);
-
-  /// Return text font
-  FXFont* getFont() const { return font; }
-
-  /// Return normal text color
-  FXColor getTextColor() const { return textColor; }
-
-  /// Change normal text color
-  void setTextColor(FXColor clr);
-
-  /// Return selected text background
-  FXColor getSelBackColor() const { return selbackColor; }
-
-  /// Change selected text background
-  void setSelBackColor(FXColor clr);
-
-  /// Return selected text color
-  FXColor getSelTextColor() const { return seltextColor; }
-
-  /// Change selected text color
-  void setSelTextColor(FXColor clr);
-
-  /// Return list style
-  FXuint getListStyle() const;
-
-  /// Change list style
-  void setListStyle(FXuint style);
-
-  /// Set the status line help text for this list
-  void setHelpText(const FXString& text);
-
-  /// Get the status line help text for this list
-  const FXString& getHelpText() const { return help; }
-
-  /// Save list to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load list from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXList();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXListBox.h b/fox-includes/FXListBox.h
deleted file mode 100755
index ced7e5b5..00000000
--- a/fox-includes/FXListBox.h
+++ /dev/null
@@ -1,270 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        L i s t   B o x   W i d g e t                          *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXListBox.h 2255 2005-11-30 13:55:50Z lyle $                         *
-********************************************************************************/
-#ifndef FXLISTBOX_H
-#define FXLISTBOX_H
-
-#ifndef FXPACKER_H
-#include "FXPacker.h"
-#endif
-
-namespace FX {
-
-
-/// List Box styles
-enum {
-  LISTBOX_NORMAL         = 0          // Normal style
-  };
-
-
-class FXButton;
-class FXMenuButton;
-class FXList;
-class FXPopup;
-
-
-/**
-* The List Box is a control to select one of a list of options.  It looks
-* similar to a Combo Box except that List Box yields integer numbers only.
-* When an option is selected, List Box will send an SEL_COMMAND with the
-* index of the opton.  While manipulating the list, it may send SEL_CHANGED
-* messages to indicate which option the cursor is hovering over.
-* The List Box is able to receive ID_GETINTVALUE and ID_SETINTVALUE which
-* will retrieve the current option or change the selected option.
-*/
-class FXAPI FXListBox : public FXPacker {
-  FXDECLARE(FXListBox)
-protected:
-  FXButton      *field;
-  FXMenuButton  *button;
-  FXList        *list;
-  FXPopup       *pane;
-protected:
-  FXListBox(){}
-private:
-  FXListBox(const FXListBox&);
-  FXListBox &operator=(const FXListBox&);
-public:
-  long onFocusUp(FXObject*,FXSelector,void*);
-  long onFocusDown(FXObject*,FXSelector,void*);
-  long onFocusSelf(FXObject*,FXSelector,void*);
-  long onMouseWheel(FXObject*,FXSelector,void*);
-  long onFieldButton(FXObject*,FXSelector,void*);
-  long onListUpdate(FXObject*,FXSelector,void*);
-  long onListClicked(FXObject*,FXSelector,void*);
-  long onListChanged(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_LIST=FXPacker::ID_LAST,
-    ID_FIELD,
-    ID_LAST
-    };
-public:
-
-  /// Constructor
-  FXListBox(FXComposite *p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=FRAME_SUNKEN|FRAME_THICK|LISTBOX_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Destroy server-side resources
-  virtual void destroy();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Enable drive box
-  virtual void enable();
-
-  /// Disable drive box
-  virtual void disable();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Return the number of items in the list
-  FXint getNumItems() const;
-
-  /// Return the number of visible items
-  FXint getNumVisible() const;
-
-  /// Set the number of visible items
-  void setNumVisible(FXint nvis);
-
-  /// Return true if current item
-  FXbool isItemCurrent(FXint index) const;
-
-  /// Set the current item (index is zero-based)
-  virtual void setCurrentItem(FXint index,FXbool notify=FALSE);
-
-  /// Get the current item's index
-  FXint getCurrentItem() const;
-
-  /// Return the item at the given index
-  FXString getItem(FXint index) const;
-
-  /// Replace the item at index
-  FXint setItem(FXint index,const FXString& text,FXIcon* icon=NULL,void* ptr=NULL);
-
-  /// Fill list box by appending items from array of strings
-  FXint fillItems(const FXchar** strings,FXIcon* icon=NULL,void* ptr=NULL);
-
-  /// Fill list box by appending items from newline separated strings
-  FXint fillItems(const FXString& strings,FXIcon* icon=NULL,void* ptr=NULL);
-
-  /// Insert a new item at index
-  FXint insertItem(FXint index,const FXString& text,FXIcon* icon=NULL,void* ptr=NULL);
-
-  /// Add an item to the end of the list
-  FXint appendItem(const FXString& text,FXIcon* icon=NULL,void* ptr=NULL);
-
-  /// Prepend an item to the list
-  FXint prependItem(const FXString& text,FXIcon* icon=NULL,void* ptr=NULL);
-
-  /// Move item from oldindex to newindex
-  FXint moveItem(FXint newindex,FXint oldindex);
-
-  /// Extract item from list
-  FXListItem* extractItem(FXint index);
-
-  /// Remove this item from the list
-  void removeItem(FXint index);
-
-  /// Remove all items from the list
-  void clearItems();
-
-  /**
-  * Search items by name, beginning from item start.  If the start
-  * item is -1 the search will start at the first item in the list.
-  * Flags may be SEARCH_FORWARD or SEARCH_BACKWARD to control the
-  * search direction; this can be combined with SEARCH_NOWRAP or SEARCH_WRAP
-  * to control whether the search wraps at the start or end of the list.
-  * The option SEARCH_IGNORECASE causes a case-insensitive match.  Finally,
-  * passing SEARCH_PREFIX causes searching for a prefix of the item name.
-  * Return -1 if no matching item is found.
-  */
-  FXint findItem(const FXString& text,FXint start=-1,FXuint flags=SEARCH_FORWARD|SEARCH_WRAP) const;
-
-  /**
-  * Search items by associated user data, beginning from item start. If the
-  * start item is -1 the search will start at the first item in the list.
-  * Flags may be SEARCH_FORWARD or SEARCH_BACKWARD to control the
-  * search direction; this can be combined with SEARCH_NOWRAP or SEARCH_WRAP
-  * to control whether the search wraps at the start or end of the list.
-  */
-  FXint findItemByData(const void *ptr,FXint start=-1,FXuint flags=SEARCH_FORWARD|SEARCH_WRAP) const;
-
-  /// Set text for specified item
-  void setItemText(FXint index,const FXString& text);
-
-  /// Get text for specified item
-  FXString getItemText(FXint index) const;
-
-  /// Change item icon, deleting old one if it was owned
-  void setItemIcon(FXint index,FXIcon* icon,FXbool owned=FALSE);
-
-  /// Return icon of item at index
-  FXIcon* getItemIcon(FXint index) const;
-
-  /// Set data pointer for specified item
-  void setItemData(FXint index,void* ptr) const;
-
-  /// Get data pointer for specified item
-  void* getItemData(FXint index) const;
-
-  /// Is the pane shown
-  FXbool isPaneShown() const;
-
-  /// Sort items using current sort function
-  void sortItems();
-
-  /// Set text font
-  void setFont(FXFont* fnt);
-
-  /// Get text font
-  FXFont* getFont() const;
-
-  /// Set window background color
-  virtual void setBackColor(FXColor clr);
-
-  /// Get background color
-  FXColor getBackColor() const;
-
-  /// Change text color
-  void setTextColor(FXColor clr);
-
-  /// Return text color
-  FXColor getTextColor() const;
-
-  /// Change selected background color
-  void setSelBackColor(FXColor clr);
-
-  /// Return selected background color
-  FXColor getSelBackColor() const;
-
-  /// Change selected text color
-  void setSelTextColor(FXColor clr);
-
-  /// Return selected text color
-  FXColor getSelTextColor() const;
-
-  /// Return sort function
-  FXListSortFunc getSortFunc() const;
-
-  /// Change sort function
-  void setSortFunc(FXListSortFunc func);
-
-  /// Set the combobox help text
-  void setHelpText(const FXString& txt);
-
-  /// Get the combobox help text
-  const FXString& getHelpText() const;
-
-  /// Set the tool tip message for this combobox
-  void setTipText(const FXString& txt);
-
-  /// Get the tool tip message for this combobox
-  const FXString& getTipText() const;
-
-  /// Save combobox to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load combobox from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXListBox();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXMDIButton.h b/fox-includes/FXMDIButton.h
deleted file mode 100755
index 402a8e2b..00000000
--- a/fox-includes/FXMDIButton.h
+++ /dev/null
@@ -1,150 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*             M u l t i p l e   D o c u m e n t   B u t t o n                   *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2003 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXMDIButton.h 1642 2003-07-09 22:56:42Z lyle $                       *
-********************************************************************************/
-#ifndef FXMDIBUTTON_H
-#define FXMDIBUTTON_H
-
-#ifndef FXBUTTON_H
-#include "FXButton.h"
-#endif
-
-namespace FX {
-
-class FXIcon;
-
-
-/// MDI Delete button
-class FXAPI FXMDIDeleteButton : public FXButton {
-  FXDECLARE(FXMDIDeleteButton)
-protected:
-  FXMDIDeleteButton(){}
-private:
-  FXMDIDeleteButton(const FXMDIDeleteButton&);
-  FXMDIDeleteButton &operator=(const FXMDIDeleteButton&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-public:
-  /// Constructor
-  FXMDIDeleteButton(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=FRAME_RAISED,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-  virtual FXint getDefaultWidth();
-  virtual FXint getDefaultHeight();
-  };
-
-
-/// MDI Restore button
-class FXAPI FXMDIRestoreButton : public FXButton {
-  FXDECLARE(FXMDIRestoreButton)
-protected:
-  FXMDIRestoreButton(){}
-private:
-  FXMDIRestoreButton(const FXMDIRestoreButton&);
-  FXMDIRestoreButton &operator=(const FXMDIRestoreButton&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-public:
-  /// Constructor
-  FXMDIRestoreButton(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=FRAME_RAISED,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-  virtual FXint getDefaultWidth();
-  virtual FXint getDefaultHeight();
-  };
-
-
-/// MDI Maximize button
-class FXAPI FXMDIMaximizeButton : public FXButton {
-  FXDECLARE(FXMDIMaximizeButton)
-protected:
-  FXMDIMaximizeButton(){}
-private:
-  FXMDIMaximizeButton(const FXMDIMaximizeButton&);
-  FXMDIMaximizeButton &operator=(const FXMDIMaximizeButton&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-public:
-  /// Constructor
-  FXMDIMaximizeButton(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=FRAME_RAISED,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-  virtual FXint getDefaultWidth();
-  virtual FXint getDefaultHeight();
-  };
-
-
-/// MDI Minimize button
-class FXAPI FXMDIMinimizeButton : public FXButton {
-  FXDECLARE(FXMDIMinimizeButton)
-protected:
-  FXMDIMinimizeButton(){}
-private:
-  FXMDIMinimizeButton(const FXMDIMinimizeButton&);
-  FXMDIMinimizeButton &operator=(const FXMDIMinimizeButton&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-public:
-  /// Constructor
-  FXMDIMinimizeButton(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=FRAME_RAISED,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-  virtual FXint getDefaultWidth();
-  virtual FXint getDefaultHeight();
-  };
-
-
-/// MDI Window button
-class FXAPI FXMDIWindowButton : public FXMenuButton {
-  FXDECLARE(FXMDIWindowButton)
-protected:
-  FXMDIWindowButton(){}
-private:
-  FXMDIWindowButton(const FXMDIWindowButton&);
-  FXMDIWindowButton &operator=(const FXMDIWindowButton&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-public:
-  /// Constructor
-  FXMDIWindowButton(FXComposite* p,FXPopup* pup,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-  virtual FXint getDefaultWidth();
-  virtual FXint getDefaultHeight();
-  };
-
-
-/// MDI Window Menu
-class FXAPI FXMDIMenu : public FXMenuPane {
-  FXDECLARE(FXMDIMenu)
-private:
-  FXIcon *closeicon;
-  FXIcon *maximizeicon;
-  FXIcon *minimizeicon;
-  FXIcon *restoreicon;
-protected:
-  FXMDIMenu(){}
-private:
-  FXMDIMenu(const FXMDIMenu&);
-  FXMDIMenu &operator=(const FXMDIMenu&);
-public:
-
-  /// Construct MDI menu
-  FXMDIMenu(FXWindow *owner,FXObject* tgt=NULL);
-
-  /// Destructor
-  virtual ~FXMDIMenu();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXMDIChild.h b/fox-includes/FXMDIChild.h
deleted file mode 100755
index 9812918a..00000000
--- a/fox-includes/FXMDIChild.h
+++ /dev/null
@@ -1,300 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*          M u l t i p l e   D o c u m e n t   C h i l d   W i n d o w          *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXMDIChild.h 2344 2006-02-12 21:19:36Z lyle $                        *
-********************************************************************************/
-#ifndef FXMDICHILD_H
-#define FXMDICHILD_H
-
-#ifndef FXCOMPOSITE_H
-#include "FXComposite.h"
-#endif
-
-namespace FX {
-
-
-class FXMDIClient;
-class FXMenuButton;
-class FXButton;
-class FXFont;
-
-
-/// MDI Child Window styles
-enum {
-  MDI_NORMAL    = 0,                /// Normal display mode
-  MDI_MAXIMIZED = 0x00001000,       /// Window appears maximized
-  MDI_MINIMIZED = 0x00002000,       /// Window is iconified or minimized
-  MDI_TRACKING  = 0x00004000        /// Track continuously during dragging
-  };
-
-
-
-/**
-* The MDI child window contains the application work area in a Multiple Document
-* Interface application.  GUI Controls are connected to the MDI child via delegation
-* through the MDI client, which forwards messages it receives to the active MDI child.
-* The MDI child itself tries to further delegate messages to its single content window,
-* and if not handled there, to its target object.
-* When the MDI child is maximized, it sends a SEL_MAXIMIZE message; when the MDI
-* child is minimized, it sends a SEL_MINIMIZE message.  When it is restored, it
-* sends a SEL_RESTORE message to its target.  The MDI child also notifies its
-* target when it becomes the active MDI child, via the SEL_SELECTED message.
-* The void* in the SEL_SELECTED message refers to the previously active MDI child,
-* if any.  When an MDI child ceases to be the active one, a SEL_DESELECTED message
-* is sent.  The void* in the SEL_DESELECTED message refers to the newly activated
-* MDI child, if any.  Thus, interception of SEL_SELECTED and SEL_DESELECTED allows
-* the target object to determine whether the user switched between MDI windows of
-* the same document (target) or between MDI windows belonging to the same document.
-* When the MDI child is closed, it sends a SEL_CLOSE message to its target.
-* The target has an opportunity to object to the closing; if the MDI child should
-* not be closed, it should return 1 (objection). If the MDI child should be closed,
-* the target can either just return 0 or simply not handle the SEL_CLOSE message.
-* The SEL_UPDATE message can be used to modify the MDI child's title (via
-* ID_SETSTRINGVALUE), and window icon (via ID_SETICONVALUE).
-*/
-class FXAPI FXMDIChild : public FXComposite {
-  FXDECLARE(FXMDIChild)
-protected:
-  FXString      title;                  // Window title
-  FXMenuButton *windowbtn;              // Window button
-  FXButton     *minimizebtn;            // Minimize button
-  FXButton     *restorebtn;             // Restore button
-  FXButton     *maximizebtn;            // Maximize buton
-  FXButton     *deletebtn;              // Close button
-  FXFont       *font;                   // Title font
-  FXColor       baseColor;              // Colors
-  FXColor       hiliteColor;
-  FXColor       shadowColor;
-  FXColor       borderColor;
-  FXColor       titleColor;
-  FXColor       titleBackColor;
-  FXint         iconPosX;               // Saved icon position
-  FXint         iconPosY;
-  FXint         iconWidth;
-  FXint         iconHeight;
-  FXint         normalPosX;             // Saved normal position
-  FXint         normalPosY;
-  FXint         normalWidth;
-  FXint         normalHeight;
-  FXint         spotx;                  // Grab-spot of mouse on window
-  FXint         spoty;
-  FXint         xoff;                   // Mouse offset to add
-  FXint         yoff;
-  FXint         newx;                   // New location of window
-  FXint         newy;
-  FXint         neww;
-  FXint         newh;
-  FXuchar       mode;                   // Dragging mode
-protected:
-  FXMDIChild();
-  void drawRubberBox(FXint x,FXint y,FXint w,FXint h);
-  void animateRectangles(FXint ox,FXint oy,FXint ow,FXint oh,FXint nx,FXint ny,FXint nw,FXint nh);
-  FXuchar where(FXint x,FXint y);
-  void changeCursor(FXint x,FXint y);
-  void revertCursor();
-protected:
-  enum {
-    DRAG_NONE        = 0,
-    DRAG_TOP         = 1,
-    DRAG_BOTTOM      = 2,
-    DRAG_LEFT        = 4,
-    DRAG_RIGHT       = 8,
-    DRAG_TOPLEFT     = (DRAG_TOP|DRAG_LEFT),
-    DRAG_TOPRIGHT    = (DRAG_TOP|DRAG_RIGHT),
-    DRAG_BOTTOMLEFT  = (DRAG_BOTTOM|DRAG_LEFT),
-    DRAG_BOTTOMRIGHT = (DRAG_BOTTOM|DRAG_RIGHT),
-    DRAG_INVERTED    = 16,
-    DRAG_TITLE       = 32
-    };
-private:
-  FXMDIChild(const FXMDIChild&);
-  FXMDIChild &operator=(const FXMDIChild&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onFocusSelf(FXObject*,FXSelector,void*);
-  long onFocusIn(FXObject*,FXSelector,void*);
-  long onFocusOut(FXObject*,FXSelector,void*);
-  long onRightBtnPress(FXObject*,FXSelector,void*);
-  long onRightBtnRelease(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onMiddleBtnPress(FXObject*,FXSelector,void*);
-  long onMiddleBtnRelease(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onSelected(FXObject*,FXSelector,void*);
-  long onDeselected(FXObject*,FXSelector,void*);
-  long onCmdClose(FXObject*,FXSelector,void*);
-  long onUpdClose(FXObject*,FXSelector,void*);
-  long onCmdRestore(FXObject*,FXSelector,void*);
-  long onUpdRestore(FXObject*,FXSelector,void*);
-  long onUpdMaximize(FXObject*,FXSelector,void*);
-  long onUpdMinimize(FXObject*,FXSelector,void*);
-  long onCmdMaximize(FXObject*,FXSelector,void*);
-  long onCmdMinimize(FXObject*,FXSelector,void*);
-  long onUpdWindow(FXObject*,FXSelector,void*);
-  long onUpdMenuRestore(FXObject*,FXSelector,void*);
-  long onUpdMenuMinimize(FXObject*,FXSelector,void*);
-  long onUpdMenuClose(FXObject*,FXSelector,void*);
-  long onUpdMenuWindow(FXObject*,FXSelector,void*);
-  long onCmdSetStringValue(FXObject*,FXSelector,void*);
-  long onCmdGetStringValue(FXObject*,FXSelector,void*);
-  long onCmdSetIconValue(FXObject*,FXSelector,void*);
-  long onCmdGetIconValue(FXObject*,FXSelector,void*);
-  virtual long onDefault(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct MDI Child window with given name and icon
-  FXMDIChild(FXMDIClient* p,const FXString& name,FXIcon* ic=NULL,FXPopup* pup=NULL,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Create window
-  virtual void create();
-
-  /// Detach window
-  virtual void detach();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return the default width of this window
-  virtual FXint getDefaultWidth();
-
-  /// Return the default height of this window
-  virtual FXint getDefaultHeight();
-
-  /// Move the focus to this window
-  virtual void setFocus();
-
-  /// MDI Child can receive focus
-  virtual bool canFocus() const;
-
-  /// Move this window to the specified position in the parent's coordinates
-  virtual void move(FXint x,FXint y);
-
-  /// Resize this window to the specified width and height
-  virtual void resize(FXint w,FXint h);
-
-  /// Move and resize this window in the parent's coordinates
-  virtual void position(FXint x,FXint y,FXint w,FXint h);
-
-  /// Change normal (restored) position
-  void setNormalX(FXint x){ normalPosX=x; }
-  void setNormalY(FXint y){ normalPosY=y; }
-  void setNormalWidth(FXint w){ normalWidth=w; }
-  void setNormalHeight(FXint h){ normalHeight=h; }
-
-  /// Return normal (restored) position
-  FXint getNormalX() const { return normalPosX; }
-  FXint getNormalY() const { return normalPosY; }
-  FXint getNormalWidth() const { return normalWidth; }
-  FXint getNormalHeight() const { return normalHeight; }
-
-  /// Change iconified position
-  void setIconX(FXint x){ iconPosX=x; }
-  void setIconY(FXint y){ iconPosY=y; }
-  void setIconWidth(FXint w){ iconWidth=w; }
-  void setIconHeight(FXint h){ iconHeight=h; }
-
-  /// Return iconified position
-  FXint getIconX() const { return iconPosX; }
-  FXint getIconY() const { return iconPosY; }
-  FXint getIconWidth() const { return iconWidth; }
-  FXint getIconHeight() const { return iconHeight; }
-
-  /// Return content window
-  FXWindow *contentWindow() const;
-
-  /// Change MDI Child's title
-  void setTitle(const FXString& name);
-
-  /// Get current title
-  FXString getTitle() const { return title; }
-
-  /// Get colors
-  FXColor getHiliteColor() const { return hiliteColor; }
-  FXColor getShadowColor() const { return shadowColor; }
-  FXColor getBaseColor() const { return baseColor; }
-  FXColor getBorderColor() const { return borderColor; }
-  FXColor getTitleColor () const { return titleColor; }
-  FXColor getTitleBackColor() const { return titleBackColor; }
-
-  /// Change colors
-  void setHiliteColor(FXColor clr);
-  void setShadowColor(FXColor clr);
-  void setBaseColor(FXColor clr);
-  void setBorderColor(FXColor clr);
-  void setTitleColor(FXColor clr);
-  void setTitleBackColor(FXColor clr);
-
-  /// Maximize MDI window, return TRUE if maximized
-  virtual FXbool maximize(FXbool notify=FALSE);
-
-  /// Minimize/iconify MDI window, return TRUE if minimized
-  virtual FXbool minimize(FXbool notify=FALSE);
-
-  /// Restore MDI window to normal, return TRUE if restored
-  virtual FXbool restore(FXbool notify=FALSE);
-
-  /// Close MDI window, return TRUE if actually closed
-  virtual FXbool close(FXbool notify=FALSE);
-
-  /// Return TRUE if maximized
-  FXbool isMaximized() const;
-
-  /// Return TRUE if minimized
-  FXbool isMinimized() const;
-
-  /// Get window icon
-  FXIcon *getIcon() const;
-
-  /// Set window icon
-  void setIcon(FXIcon* icon);
-
-  /// Get window menu
-  FXPopup* getMenu() const;
-
-  /// Set window menu
-  void setMenu(FXPopup* menu);
-
-  /// Set tracking instead of just outline
-  void setTracking(FXbool tracking=TRUE);
-
-  /// Return true if tracking
-  FXbool getTracking() const;
-
-  /// Set title font
-  void setFont(FXFont *fnt);
-
-  /// Get title font
-  FXFont* getFont() const { return font; }
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destroy
-  virtual ~FXMDIChild();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXMDIClient.h b/fox-includes/FXMDIClient.h
deleted file mode 100755
index 12c060fa..00000000
--- a/fox-includes/FXMDIClient.h
+++ /dev/null
@@ -1,187 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*         M u l t i p l e   D o c u m e n t   C l i e n t   W i n d o w         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXMDIClient.h 2127 2005-08-07 20:21:35Z lyle $                       *
-********************************************************************************/
-#ifndef FXMDICLIENT_H
-#define FXMDICLIENT_H
-
-#ifndef FXCOMPOSITE_H
-#include "FXComposite.h"
-#endif
-
-namespace FX {
-
-
-class FXMDIChild;
-
-
-/**
-* The MDI client window manages a number of MDI child windows in a multiple-document
-* interface (MDI) application. MDI child windows usually receive messages from the GUI controls
-* by delegation via the MDI client.  This is accomplished by making the MDI client window
-* the target for most GUI controls.  The MDI client filters out messages intented for itself,
-* and delegates the remaining messages to its currently active MDI child, if any.
-* If you use the auto-gray or auto-hide feature available in some GUI controls, these
-* controls can be automatically grayed out or hidden when there is no active MDI child.
-* When delegating messages via MDI client to MDI child windows of different types, care
-* should be taken that message ID's do not overlap, so that all message ID's only map to
-* the intented handlers no matter which MDI child window type is active.
-* The MDI client sends a SEL_CHANGED message to its target when the active MDI child is
-* switched, with the void* pointer refering to the new MDI child.
-* A MDI Window selection dialog can be brought up through the ID_MDI_OVER_X messages;
-* a menu button connected to the MDI client with the ID_MDI_OVER_X message will be
-* automatically grayed out if there are less than X MDI child windows.
-*/
-class FXAPI FXMDIClient : public FXComposite {
-  FXDECLARE(FXMDIClient)
-  friend class FXMDIChild;
-protected:
-  FXMDIChild *active;             // Active child
-  FXint       cascadex;           // Cascade offset X
-  FXint       cascadey;           // Cascade offset Y
-protected:
-  FXMDIClient();
-private:
-  FXMDIClient(const FXMDIClient&);
-  FXMDIClient &operator=(const FXMDIClient&);
-public:
-  long onCmdActivateNext(FXObject*,FXSelector,void*);
-  long onCmdActivatePrev(FXObject*,FXSelector,void*);
-  long onCmdTileHorizontal(FXObject*,FXSelector,void*);
-  long onCmdTileVertical(FXObject*,FXSelector,void*);
-  long onCmdCascade(FXObject*,FXSelector,void*);
-  long onUpdActivateNext(FXObject*,FXSelector,void*);
-  long onUpdActivatePrev(FXObject*,FXSelector,void*);
-  long onUpdTileVertical(FXObject*,FXSelector,void*);
-  long onUpdTileHorizontal(FXObject*,FXSelector,void*);
-  long onUpdCascade(FXObject*,FXSelector,void*);
-  long onUpdClose(FXObject*,FXSelector,void*);
-  long onUpdMenuClose(FXObject*,FXSelector,void*);
-  long onUpdRestore(FXObject*,FXSelector,void*);
-  long onUpdMenuRestore(FXObject*,FXSelector,void*);
-  long onUpdMinimize(FXObject*,FXSelector,void*);
-  long onUpdMenuMinimize(FXObject*,FXSelector,void*);
-  long onUpdMaximize(FXObject*,FXSelector,void*);
-  long onUpdMenuWindow(FXObject*,FXSelector,void*);
-  long onCmdWindowSelect(FXObject*,FXSelector,void*);
-  long onUpdWindowSelect(FXObject*,FXSelector,void*);
-  long onCmdOthersWindows(FXObject*,FXSelector,void*);
-  long onUpdOthersWindows(FXObject*,FXSelector,void*);
-  long onUpdAnyWindows(FXObject*,FXSelector,void*);
-  virtual long onDefault(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_MDI_ANY=65400,
-    ID_MDI_1,           // Select MDI child 1
-    ID_MDI_2,
-    ID_MDI_3,
-    ID_MDI_4,
-    ID_MDI_5,
-    ID_MDI_6,
-    ID_MDI_7,
-    ID_MDI_8,
-    ID_MDI_9,
-    ID_MDI_10,
-    ID_MDI_OVER_1,      // Sensitize MDI menu when 1 or more children
-    ID_MDI_OVER_2,
-    ID_MDI_OVER_3,
-    ID_MDI_OVER_4,
-    ID_MDI_OVER_5,
-    ID_MDI_OVER_6,
-    ID_MDI_OVER_7,
-    ID_MDI_OVER_8,
-    ID_MDI_OVER_9,
-    ID_MDI_OVER_10,
-    ID_LAST
-    };
-public:
-
-  /// Construct MDI Client window
-  FXMDIClient(FXComposite* p,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Perform layout
-  virtual void layout();
-
-  /**
-  * Pass message to all MDI windows, stopping when one of
-  * the MDI windows fails to handle the message.
-  */
-  long forallWindows(FXObject* sender,FXSelector sel,void* ptr);
-
-  /**
-  * Pass message once to all MDI windows with the same document,
-  * stopping when one of the MDI windows fails to handle the message.
-  */
-  long forallDocuments(FXObject* sender,FXSelector sel,void* ptr);
-
-  /**
-  * Pass message to all MDI Child windows whose target is document,
-  * stopping when one of the MDI windows fails to handle the message.
-  */
-  long forallDocWindows(FXObject* document,FXObject* sender,FXSelector sel,void* ptr);
-
-  /// Set active MDI Child
-  virtual FXbool setActiveChild(FXMDIChild* child=NULL,FXbool notify=TRUE);
-
-  /// Get current active child; may be NULL!
-  FXMDIChild* getActiveChild() const { return active; }
-
-  /// Cascade windows
-  virtual void cascade(FXbool notify=FALSE);
-
-  /// Layout horizontally
-  virtual void horizontal(FXbool notify=FALSE);
-
-  /// Layout vertically
-  virtual void vertical(FXbool notify=FALSE);
-
-  /// Change cascade offset X
-  void setCascadeX(FXint off){ cascadex=off; }
-
-  /// Change cascade offset Y
-  void setCascadeY(FXint off){ cascadey=off; }
-
-  /// Get cascade offset X
-  FXint getCascadeX() const { return cascadex; }
-
-  /// Get cascade offset Y
-  FXint getCascadeY() const { return cascadey; }
-
-  /// Save object to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load object from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXMDIClient();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXMainWindow.h b/fox-includes/FXMainWindow.h
deleted file mode 100755
index 479bb136..00000000
--- a/fox-includes/FXMainWindow.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                     M a i n   W i n d o w   W i d g e t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXMainWindow.h 2127 2005-08-07 20:21:35Z lyle $                      *
-********************************************************************************/
-#ifndef FXMAINWINDOW_H
-#define FXMAINWINDOW_H
-
-#ifndef FXTOPWINDOW_H
-#include "FXTopWindow.h"
-#endif
-
-namespace FX {
-
-
-/**
-* The Main Window is usually the central window of an application.  Applications
-* may have any number of main windows.
-* When a MainWindow is closed, it sends a SEL_CLOSE message to its target; the target
-* should return 0 if there is no objection against proceeding with the close, and
-* return 1 otherwise.
-* After the SEL_CLOSE message has been sent and no objection was raised, the main
-* window will delete itself.
-*/
-class FXAPI FXMainWindow : public FXTopWindow {
-  FXDECLARE(FXMainWindow)
-protected:
-  FXMainWindow(){}
-private:
-  FXMainWindow(const FXMainWindow&);
-  FXMainWindow &operator=(const FXMainWindow&);
-public:
-
-  /// Construct a main window
-  FXMainWindow(FXApp* a,const FXString& name,FXIcon *ic=NULL,FXIcon *mi=NULL,FXuint opts=DECOR_ALL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=0,FXint pr=0,FXint pt=0,FXint pb=0,FXint hs=0,FXint vs=0);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Destructor
-  virtual ~FXMainWindow();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXMat3d.h b/fox-includes/FXMat3d.h
deleted file mode 100755
index f9ffaa0b..00000000
--- a/fox-includes/FXMat3d.h
+++ /dev/null
@@ -1,154 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*            D o u b l e - P r e c i s i o n   3 x 3   M a t r i x              *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2003,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXMat3d.h 2344 2006-02-12 21:19:36Z lyle $                           *
-********************************************************************************/
-#ifndef FXMAT3D_H
-#define FXMAT3D_H
-
-
-namespace FX {
-
-
-class FXQuatd;
-
-
-/// Double-precision 3x3 matrix
-class FXAPI FXMat3d {
-protected:
-  FXVec3d m[3];
-public:
-
-  /// Default constructor
-  FXMat3d(){}
-
-  /// Initialize matrix from another matrix
-  FXMat3d(const FXMat3d& other);
-
-  /// Initialize matrix from scalar
-  FXMat3d(FXdouble w);
-
-  /// Initialize matrix from components
-  FXMat3d(FXdouble a00,FXdouble a01,FXdouble a02,
-          FXdouble a10,FXdouble a11,FXdouble a12,
-          FXdouble a20,FXdouble a21,FXdouble a22);
-
-  /// Initialize matrix from three vectors
-  FXMat3d(const FXVec3d& a,const FXVec3d& b,const FXVec3d& c);
-
-  /// Initialize matrix from quaternion
-  FXMat3d(const FXQuatd& quat);
-
-  /// Assignment
-  FXMat3d& operator=(const FXMat3d& other);
-  FXMat3d& operator=(FXdouble w);
-
-  /// Set value from another matrix
-  FXMat3d& set(const FXMat3d& other);
-
-  /// Set value from scalar
-  FXMat3d& set(FXdouble w);
-
-  /// Set value from components
-  FXMat3d& set(FXdouble a00,FXdouble a01,FXdouble a02,
-               FXdouble a10,FXdouble a11,FXdouble a12,
-               FXdouble a20,FXdouble a21,FXdouble a22);
-
-  /// Set value from three vectors
-  FXMat3d& set(const FXVec3d& a,const FXVec3d& b,const FXVec3d& c);
-
-  /// Set value from quaternion
-  FXMat3d& set(const FXQuatd& quat);
-
-  /// Assignment operators
-  FXMat3d& operator+=(const FXMat3d& w);
-  FXMat3d& operator-=(const FXMat3d& w);
-  FXMat3d& operator*=(FXdouble w);
-  FXMat3d& operator*=(const FXMat3d& w);
-  FXMat3d& operator/=(FXdouble w);
-
-  /// Indexing
-  FXVec3d& operator[](FXint i){return m[i];}
-  const FXVec3d& operator[](FXint i) const {return m[i];}
-
-  /// Conversion
-  operator FXdouble*(){return m[0];}
-  operator const FXdouble*() const {return m[0];}
-
-  /// Unary minus
-  FXMat3d operator-() const;
-
-  /// Matrix and matrix
-  FXMat3d operator+(const FXMat3d& w) const;
-  FXMat3d operator-(const FXMat3d& w) const;
-  FXMat3d operator*(const FXMat3d& w) const;
-
-  /// Multiply matrix and vector
-  FXVec3d operator*(const FXVec3d& v) const;
-  FXVec2d operator*(const FXVec2d& v) const;
-
-  /// Matrix and scalar
-  friend FXAPI FXMat3d operator*(FXdouble x,const FXMat3d& a);
-  friend FXAPI FXMat3d operator*(const FXMat3d& a,FXdouble x);
-  friend FXAPI FXMat3d operator/(const FXMat3d& a,FXdouble x);
-  friend FXAPI FXMat3d operator/(FXdouble x,const FXMat3d& a);
-
-  /// Set identity matrix
-  FXMat3d& eye();
-
-  /// Multiply by rotation of phi
-  FXMat3d& rot(FXdouble c,FXdouble s);
-  FXMat3d& rot(FXdouble phi);
-
-  /// Multiply by translation
-  FXMat3d& trans(FXdouble tx,FXdouble ty);
-
-  /// Multiply by scaling
-  FXMat3d& scale(FXdouble sx,FXdouble sy);
-  FXMat3d& scale(FXdouble s);
-
-  /// Determinant
-  FXdouble det() const;
-
-  /// Transpose
-  FXMat3d transpose() const;
-
-  /// Invert
-  FXMat3d invert() const;
-
-  /// Save to a stream
-  friend FXAPI FXStream& operator<<(FXStream& store,const FXMat3d& m);
-
-  /// Load from a stream
-  friend FXAPI FXStream& operator>>(FXStream& store,FXMat3d& m);
-  };
-
-extern FXAPI FXMat3d operator*(FXdouble x,const FXMat3d& a);
-extern FXAPI FXMat3d operator*(const FXMat3d& a,FXdouble x);
-extern FXAPI FXMat3d operator/(const FXMat3d& a,FXdouble x);
-extern FXAPI FXMat3d operator/(FXdouble x,const FXMat3d& a);
-
-extern FXAPI FXStream& operator<<(FXStream& store,const FXMat3d& m);
-extern FXAPI FXStream& operator>>(FXStream& store,FXMat3d& m);
-
-}
-
-#endif
diff --git a/fox-includes/FXMat3f.h b/fox-includes/FXMat3f.h
deleted file mode 100755
index d715c308..00000000
--- a/fox-includes/FXMat3f.h
+++ /dev/null
@@ -1,154 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*            S i n g l e - P r e c i s i o n   3 x 3   M a t r i x              *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2003,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXMat3f.h 2344 2006-02-12 21:19:36Z lyle $                           *
-********************************************************************************/
-#ifndef FXMAT3F_H
-#define FXMAT3F_H
-
-
-namespace FX {
-
-
-class FXQuatf;
-
-
-/// Single-precision 3x3 matrix
-class FXAPI FXMat3f {
-protected:
-  FXVec3f m[3];
-public:
-
-  /// Default constructor
-  FXMat3f(){}
-
-  /// Initialize matrix from another matrix
-  FXMat3f(const FXMat3f& other);
-
-  /// Initialize matrix from scalar
-  FXMat3f(FXfloat w);
-
-  /// Initialize matrix from components
-  FXMat3f(FXfloat a00,FXfloat a01,FXfloat a02,
-          FXfloat a10,FXfloat a11,FXfloat a12,
-          FXfloat a20,FXfloat a21,FXfloat a22);
-
-  /// Initialize matrix from three vectors
-  FXMat3f(const FXVec3f& a,const FXVec3f& b,const FXVec3f& c);
-
-  /// Initialize matrix from quaternion
-  FXMat3f(const FXQuatf& quat);
-
-  /// Assignment
-  FXMat3f& operator=(const FXMat3f& other);
-  FXMat3f& operator=(FXfloat w);
-
-  /// Set value from another matrix
-  FXMat3f& set(const FXMat3f& other);
-
-  /// Set value from scalar
-  FXMat3f& set(FXfloat w);
-
-  /// Set value from components
-  FXMat3f& set(FXfloat a00,FXfloat a01,FXfloat a02,
-               FXfloat a10,FXfloat a11,FXfloat a12,
-               FXfloat a20,FXfloat a21,FXfloat a22);
-
-  /// Set value from three vectors
-  FXMat3f& set(const FXVec3f& a,const FXVec3f& b,const FXVec3f& c);
-
-  /// Set value from quaternion
-  FXMat3f& set(const FXQuatf& quat);
-
-  /// Assignment operators
-  FXMat3f& operator+=(const FXMat3f& w);
-  FXMat3f& operator-=(const FXMat3f& w);
-  FXMat3f& operator*=(FXfloat w);
-  FXMat3f& operator*=(const FXMat3f& w);
-  FXMat3f& operator/=(FXfloat w);
-
-  /// Indexing
-  FXVec3f& operator[](FXint i){return m[i];}
-  const FXVec3f& operator[](FXint i) const {return m[i];}
-
-  /// Conversion
-  operator FXfloat*(){return m[0];}
-  operator const FXfloat*() const {return m[0];}
-
-  /// Unary minus
-  FXMat3f operator-() const;
-
-  /// Matrix and matrix
-  FXMat3f operator+(const FXMat3f& w) const;
-  FXMat3f operator-(const FXMat3f& w) const;
-  FXMat3f operator*(const FXMat3f& w) const;
-
-  /// Multiply matrix and vector
-  FXVec3f operator*(const FXVec3f& v) const;
-  FXVec2f operator*(const FXVec2f& v) const;
-
-  /// Matrix and scalar
-  friend FXAPI FXMat3f operator*(FXfloat x,const FXMat3f& a);
-  friend FXAPI FXMat3f operator*(const FXMat3f& a,FXfloat x);
-  friend FXAPI FXMat3f operator/(const FXMat3f& a,FXfloat x);
-  friend FXAPI FXMat3f operator/(FXfloat x,const FXMat3f& a);
-
-  /// Set identity matrix
-  FXMat3f& eye();
-
-  /// Multiply by rotation of phi
-  FXMat3f& rot(FXfloat c,FXfloat s);
-  FXMat3f& rot(FXfloat phi);
-
-  /// Multiply by translation
-  FXMat3f& trans(FXfloat tx,FXfloat ty);
-
-  /// Multiply by scaling
-  FXMat3f& scale(FXfloat sx,FXfloat sy);
-  FXMat3f& scale(FXfloat s);
-
-  /// Determinant
-  FXfloat det() const;
-
-  /// Transpose
-  FXMat3f transpose() const;
-
-  /// Invert
-  FXMat3f invert() const;
-
-  /// Save to a stream
-  friend FXAPI FXStream& operator<<(FXStream& store,const FXMat3f& m);
-
-  /// Load from a stream
-  friend FXAPI FXStream& operator>>(FXStream& store,FXMat3f& m);
-  };
-
-extern FXAPI FXMat3f operator*(FXfloat x,const FXMat3f& a);
-extern FXAPI FXMat3f operator*(const FXMat3f& a,FXfloat x);
-extern FXAPI FXMat3f operator/(const FXMat3f& a,FXfloat x);
-extern FXAPI FXMat3f operator/(FXfloat x,const FXMat3f& a);
-
-extern FXAPI FXStream& operator<<(FXStream& store,const FXMat3f& m);
-extern FXAPI FXStream& operator>>(FXStream& store,FXMat3f& m);
-
-}
-
-#endif
diff --git a/fox-includes/FXMat4d.h b/fox-includes/FXMat4d.h
deleted file mode 100755
index 1c60d628..00000000
--- a/fox-includes/FXMat4d.h
+++ /dev/null
@@ -1,169 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*            D o u b l e - P r e c i s i o n   4 x 4   M a t r i x              *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1994,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXMat4d.h 2344 2006-02-12 21:19:36Z lyle $                            *
-********************************************************************************/
-#ifndef FXMAT4D_H
-#define FXMAT4D_H
-
-
-namespace FX {
-
-
-/// Double-precision 4x4 matrix
-class FXAPI FXMat4d {
-protected:
-  FXVec4d m[4];
-public:
-  /// Constructors
-  FXMat4d(){}
-  FXMat4d(FXdouble w);
-  FXMat4d(FXdouble a00,FXdouble a01,FXdouble a02,FXdouble a03,
-          FXdouble a10,FXdouble a11,FXdouble a12,FXdouble a13,
-          FXdouble a20,FXdouble a21,FXdouble a22,FXdouble a23,
-          FXdouble a30,FXdouble a31,FXdouble a32,FXdouble a33);
-  FXMat4d(const FXVec4d& a,const FXVec4d& b,const FXVec4d& c,const FXVec4d& d);
-  FXMat4d(const FXMat4d& other);
-
-  /// Assignment
-  FXMat4d& operator=(const FXMat4d& other);
-  FXMat4d& operator=(FXdouble w);
-
-  /// Set value from another matrix
-  FXMat4d& set(const FXMat4d& other);
-
-  /// Set value from scalar
-  FXMat4d& set(FXdouble w);
-
-  /// Set value from components
-  FXMat4d& set(FXdouble a00,FXdouble a01,FXdouble a02,FXdouble a03,
-               FXdouble a10,FXdouble a11,FXdouble a12,FXdouble a13,
-               FXdouble a20,FXdouble a21,FXdouble a22,FXdouble a23,
-               FXdouble a30,FXdouble a31,FXdouble a32,FXdouble a33);
-
-  /// Set value from four vectors
-  FXMat4d& set(const FXVec4d& a,const FXVec4d& b,const FXVec4d& c,const FXVec4d& d);
-
-  /// Assignment operators
-  FXMat4d& operator+=(const FXMat4d& w);
-  FXMat4d& operator-=(const FXMat4d& w);
-  FXMat4d& operator*=(FXdouble w);
-  FXMat4d& operator*=(const FXMat4d& w);
-  FXMat4d& operator/=(FXdouble w);
-
-  /// Indexing
-  FXVec4d& operator[](FXint i){return m[i];}
-  const FXVec4d& operator[](FXint i) const {return m[i];}
-
-  /// Conversion
-  operator FXdouble*(){return m[0];}
-  operator const FXdouble*() const {return m[0];}
-
-  /// Unary minus
-  FXMat4d operator-() const;
-
-  /// Matrix and matrix
-  FXMat4d operator+(const FXMat4d& w) const;
-  FXMat4d operator-(const FXMat4d& w) const;
-  FXMat4d operator*(const FXMat4d& w) const;
-
-  /// Matrix and scalar
-  friend FXAPI FXMat4d operator*(FXdouble x,const FXMat4d& a);
-  friend FXAPI FXMat4d operator*(const FXMat4d& a,FXdouble x);
-  friend FXAPI FXMat4d operator/(const FXMat4d& a,FXdouble x);
-  friend FXAPI FXMat4d operator/(FXdouble x,const FXMat4d& a);
-
-  /// Multiply matrix and vector
-  FXVec4d operator*(const FXVec4d& v) const;
-  FXVec3d operator*(const FXVec3d& v) const;
-
-  /// Set identity matrix
-  FXMat4d& eye();
-
-  /// Orthographic projection
-  FXMat4d& ortho(FXdouble left,FXdouble right,FXdouble bottom,FXdouble top,FXdouble hither,FXdouble yon);
-
-  /// Perspective projection
-  FXMat4d& frustum(FXdouble left,FXdouble right,FXdouble bottom,FXdouble top,FXdouble hither,FXdouble yon);
-
-  /// Multiply by left-hand matrix
-  FXMat4d& left();
-
-  /// Multiply by rotation about unit-quaternion
-  FXMat4d& rot(const FXQuatd& q);
-
-  /// Multiply by rotation c,s about axis
-  FXMat4d& rot(const FXVec3d& v,FXdouble c,FXdouble s);
-
-  /// Multiply by rotation of phi about axis
-  FXMat4d& rot(const FXVec3d& v,FXdouble phi);
-
-  /// Multiply by x-rotation
-  FXMat4d& xrot(FXdouble c,FXdouble s);
-  FXMat4d& xrot(FXdouble phi);
-
-  /// Multiply by y-rotation
-  FXMat4d& yrot(FXdouble c,FXdouble s);
-  FXMat4d& yrot(FXdouble phi);
-
-  /// Multiply by z-rotation
-  FXMat4d& zrot(FXdouble c,FXdouble s);
-  FXMat4d& zrot(FXdouble phi);
-
-  /// Look at
-  FXMat4d& look(const FXVec3d& eye,const FXVec3d& cntr,const FXVec3d& vup);
-
-  /// Multiply by translation
-  FXMat4d& trans(FXdouble tx,FXdouble ty,FXdouble tz);
-  FXMat4d& trans(const FXVec3d& v);
-
-  /// Multiply by scaling
-  FXMat4d& scale(FXdouble sx,FXdouble sy,FXdouble sz);
-  FXMat4d& scale(FXdouble s);
-  FXMat4d& scale(const FXVec3d& v);
-
-  /// Determinant
-  FXdouble det() const;
-
-  /// Transpose
-  FXMat4d transpose() const;
-
-  /// Invert
-  FXMat4d invert() const;
-
-  /// Save to a stream
-  friend FXAPI FXStream& operator<<(FXStream& store,const FXMat4d& m);
-
-  /// Load from a stream
-  friend FXAPI FXStream& operator>>(FXStream& store,FXMat4d& m);
-  };
-
-extern FXAPI FXMat4d operator*(FXdouble x,const FXMat4d& a);
-extern FXAPI FXMat4d operator*(const FXMat4d& a,FXdouble x);
-extern FXAPI FXMat4d operator/(const FXMat4d& a,FXdouble x);
-extern FXAPI FXMat4d operator/(FXdouble x,const FXMat4d& a);
-
-extern FXAPI FXStream& operator<<(FXStream& store,const FXMat4d& m);
-extern FXAPI FXStream& operator>>(FXStream& store,FXMat4d& m);
-
-}
-
-#endif
diff --git a/fox-includes/FXMat4f.h b/fox-includes/FXMat4f.h
deleted file mode 100755
index b8652436..00000000
--- a/fox-includes/FXMat4f.h
+++ /dev/null
@@ -1,169 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*            S i n g l e - P r e c i s i o n   4 x 4   M a t r i x              *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1994,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXMat4f.h 2344 2006-02-12 21:19:36Z lyle $                            *
-********************************************************************************/
-#ifndef FXMAT4F_H
-#define FXMAT4F_H
-
-
-namespace FX {
-
-
-/// Single-precision 4x4 matrix
-class FXAPI FXMat4f {
-protected:
-  FXVec4f m[4];
-public:
-  /// Constructors
-  FXMat4f(){}
-  FXMat4f(FXfloat w);
-  FXMat4f(FXfloat a00,FXfloat a01,FXfloat a02,FXfloat a03,
-          FXfloat a10,FXfloat a11,FXfloat a12,FXfloat a13,
-          FXfloat a20,FXfloat a21,FXfloat a22,FXfloat a23,
-          FXfloat a30,FXfloat a31,FXfloat a32,FXfloat a33);
-  FXMat4f(const FXVec4f& a,const FXVec4f& b,const FXVec4f& c,const FXVec4f& d);
-  FXMat4f(const FXMat4f& other);
-
-  /// Assignment
-  FXMat4f& operator=(const FXMat4f& other);
-  FXMat4f& operator=(FXfloat w);
-
-  /// Set value from another matrix
-  FXMat4f& set(const FXMat4f& other);
-
-  /// Set value from scalar
-  FXMat4f& set(FXfloat w);
-
-  /// Set value from components
-  FXMat4f& set(FXfloat a00,FXfloat a01,FXfloat a02,FXfloat a03,
-               FXfloat a10,FXfloat a11,FXfloat a12,FXfloat a13,
-               FXfloat a20,FXfloat a21,FXfloat a22,FXfloat a23,
-               FXfloat a30,FXfloat a31,FXfloat a32,FXfloat a33);
-
-  /// Set value from four vectors
-  FXMat4f& set(const FXVec4f& a,const FXVec4f& b,const FXVec4f& c,const FXVec4f& d);
-
-  /// Assignment operators
-  FXMat4f& operator+=(const FXMat4f& w);
-  FXMat4f& operator-=(const FXMat4f& w);
-  FXMat4f& operator*=(FXfloat w);
-  FXMat4f& operator*=(const FXMat4f& w);
-  FXMat4f& operator/=(FXfloat w);
-
-  /// Indexing
-  FXVec4f& operator[](FXint i){return m[i];}
-  const FXVec4f& operator[](FXint i) const {return m[i];}
-
-  /// Conversion
-  operator FXfloat*(){return m[0];}
-  operator const FXfloat*() const {return m[0];}
-
-  /// Unary minus
-  FXMat4f operator-() const;
-
-  /// Matrix and matrix
-  FXMat4f operator+(const FXMat4f& w) const;
-  FXMat4f operator-(const FXMat4f& w) const;
-  FXMat4f operator*(const FXMat4f& w) const;
-
-  /// Other operators
-  friend FXAPI FXMat4f operator*(FXfloat x,const FXMat4f& a);
-  friend FXAPI FXMat4f operator*(const FXMat4f& a,FXfloat x);
-  friend FXAPI FXMat4f operator/(const FXMat4f& a,FXfloat x);
-  friend FXAPI FXMat4f operator/(FXfloat x,const FXMat4f& a);
-
-  /// Multiply matrix and vector
-  FXVec4f operator*(const FXVec4f& v) const;
-  FXVec3f operator*(const FXVec3f& v) const;
-
-  /// Set identity matrix
-  FXMat4f& eye();
-
-  /// Orthographic projection
-  FXMat4f& ortho(FXfloat left,FXfloat right,FXfloat bottom,FXfloat top,FXfloat hither,FXfloat yon);
-
-  /// Perspective projection
-  FXMat4f& frustum(FXfloat left,FXfloat right,FXfloat bottom,FXfloat top,FXfloat hither,FXfloat yon);
-
-  /// Multiply by left-hand matrix
-  FXMat4f& left();
-
-  /// Multiply by rotation about unit-quaternion
-  FXMat4f& rot(const FXQuatf& q);
-
-  /// Multiply by rotation c,s about axis
-  FXMat4f& rot(const FXVec3f& v,FXfloat c,FXfloat s);
-
-  /// Multiply by rotation of phi about axis
-  FXMat4f& rot(const FXVec3f& v,FXfloat phi);
-
-  /// Multiply by x-rotation
-  FXMat4f& xrot(FXfloat c,FXfloat s);
-  FXMat4f& xrot(FXfloat phi);
-
-  /// Multiply by y-rotation
-  FXMat4f& yrot(FXfloat c,FXfloat s);
-  FXMat4f& yrot(FXfloat phi);
-
-  /// Multiply by z-rotation
-  FXMat4f& zrot(FXfloat c,FXfloat s);
-  FXMat4f& zrot(FXfloat phi);
-
-  /// Look at
-  FXMat4f& look(const FXVec3f& eye,const FXVec3f& cntr,const FXVec3f& vup);
-
-  /// Multiply by translation
-  FXMat4f& trans(FXfloat tx,FXfloat ty,FXfloat tz);
-  FXMat4f& trans(const FXVec3f& v);
-
-  /// Multiply by scaling
-  FXMat4f& scale(FXfloat sx,FXfloat sy,FXfloat sz);
-  FXMat4f& scale(FXfloat s);
-  FXMat4f& scale(const FXVec3f& v);
-
-  /// Determinant
-  FXfloat det() const;
-
-  /// Transpose
-  FXMat4f transpose() const;
-
-  /// Invert
-  FXMat4f invert() const;
-
-  /// Save to a stream
-  friend FXAPI FXStream& operator<<(FXStream& store,const FXMat4f& m);
-
-  /// Load from a stream
-  friend FXAPI FXStream& operator>>(FXStream& store,FXMat4f& m);
-  };
-
-extern FXAPI FXMat4f operator*(FXfloat x,const FXMat4f& a);
-extern FXAPI FXMat4f operator*(const FXMat4f& a,FXfloat x);
-extern FXAPI FXMat4f operator/(const FXMat4f& a,FXfloat x);
-extern FXAPI FXMat4f operator/(FXfloat x,const FXMat4f& a);
-
-extern FXAPI FXStream& operator<<(FXStream& store,const FXMat4f& m);
-extern FXAPI FXStream& operator>>(FXStream& store,FXMat4f& m);
-
-}
-
-#endif
diff --git a/fox-includes/FXMatrix.h b/fox-includes/FXMatrix.h
deleted file mode 100755
index 09bc92a5..00000000
--- a/fox-includes/FXMatrix.h
+++ /dev/null
@@ -1,117 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                   M a t r i x   C o n t a i n e r   W i d g e t               *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2003 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXMatrix.h 1536 2003-05-14 21:41:00Z lyle $                          *
-********************************************************************************/
-#ifndef FXMATRIX_H
-#define FXMATRIX_H
-
-#ifndef FXPACKER_H
-#include "FXPacker.h"
-#endif
-
-namespace FX {
-
-
-/// Matrix packing options
-enum {
-  MATRIX_BY_ROWS        = 0,              /// Fixed number of rows, add columns as needed
-  MATRIX_BY_COLUMNS     = 0x00020000      /// Fixed number of columns, adding rows as needed
-  };
-
-
-
-/**
-* The Matrix layout manager automatically arranges its child windows
-* in rows and columns.  If the matrix style is MATRIX_BY_ROWS, then
-* the matrix will have the given number of rows and the number of columns
-* grows as more child windows are added; if the matrix style is MATRIX_BY_COLUMNS,
-* then the number of columns is fixed and the number of rows grows as more children
-* are added.
-* If all children in a row (column) have the LAYOUT_FILL_ROW (LAYOUT_FILL_COLUMN)
-* hint set, then the row (column) will be stretchable as the matrix layout manager
-* itself is resized.  If more than one row (column) is stretchable, the space is
-* apportioned to each stretchable row (column) proportionally.
-* Within each cell of the matrix, all other layout hints are observed.
-* For example, a child having LAYOUT_CENTER_Y and LAYOUT_FILL_X hints will
-* be centered in the Y-direction, while being stretched in the X-direction.
-* Empty cells can be obtained by simply placing a borderless FXFrame widget
-* as a space-holder.
-*/
-class FXAPI FXMatrix : public FXPacker {
-  FXDECLARE(FXMatrix)
-protected:
-  FXint  num;
-protected:
-  FXMatrix(){}
-private:
-  FXMatrix(const FXMatrix&);
-  FXMatrix &operator=(const FXMatrix&);
-public:
-  long onFocusUp(FXObject*,FXSelector,void*);
-  long onFocusDown(FXObject*,FXSelector,void*);
-  long onFocusLeft(FXObject*,FXSelector,void*);
-  long onFocusRight(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct a matrix layout manager with n rows or columns
-  FXMatrix(FXComposite *p,FXint n=1,FXuint opts=MATRIX_BY_ROWS,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_SPACING,FXint pr=DEFAULT_SPACING,FXint pt=DEFAULT_SPACING,FXint pb=DEFAULT_SPACING,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING);
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Obtain the child placed at a certain row and column
-  FXWindow* childAtRowCol(FXint r,FXint c) const;
-
-  /// Return the row in which the given child is placed
-  FXint rowOfChild(const FXWindow* child) const;
-
-  /// Return the column in which the given child is placed
-  FXint colOfChild(const FXWindow* child) const;
-
-  /// Change the matrix style
-  void setMatrixStyle(FXuint ph);
-
-  /// Return the current matrix style
-  FXuint getMatrixStyle() const;
-
-  /// Change the number of rows
-  void setNumRows(FXint nr);
-
-  /// Return the number of rows
-  FXint getNumRows() const;
-
-  /// Change the number of columns
-  void setNumColumns(FXint nc);
-
-  /// Return the number of columns
-  FXint getNumColumns() const;
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXMemMap.h b/fox-includes/FXMemMap.h
deleted file mode 100644
index 43476176..00000000
--- a/fox-includes/FXMemMap.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                      M e m o r y   M a p p e d   F i l e                      *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2004,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXMemMap.h 2136 2005-08-14 00:36:26Z lyle $                           *
-********************************************************************************/
-#ifndef FXMEMMAP_H
-#define FXMEMMAP_H
-
-namespace FX {
-
-
-/**
-* A Memory Map provides a view of a file as an array of memory;
-* this allows the file itself to be used as backing for the data
-* and very simplified file access results.
-* Moreover, mapped files may be shared by processes, resuling
-* in far less "real" memory being used than would otherwise be
-* the case.
-*/
-class FXAPI FXMemMap {
-private:
-  void*         mapbase;        // Memory base where it is mapped
-  long          maplength;      // Length of the map
-  long          mapoffset;      // Offset of the map
-  FXInputHandle handle;         // Handle for the map
-  FXInputHandle file;           // Handle for the file
-private:
-  FXMemMap(const FXMemMap&);
-  FXMemMap &operator=(const FXMemMap&);
-public:
-
-  /// Memory map access modes
-  enum {
-    NONE  = 0,          /// Map is inaccessible
-    READ  = 1,          /// Readable
-    WRITE = 2,          /// Writable
-    EXEC  = 4,          /// Executable (where supported)
-    TRUNC = 8           /// Truncate file to 0
-    };
-
-  /// Share mode
-  enum {
-    PRIV = 0,        /// Private
-    SHAR = 1         /// Shared
-    };
-
-public:
-
-  /// Construct a memory map
-  FXMemMap();
-
-  /// Map a view of the file; the offset must be a multiple of the page size
-  void* mapFile(const FXString& filename,long off=0,long len=-1L,FXuint access=READ,FXuint share=PRIV);
-
-  /// Unmap the view of the file
-  void* unmap();
-
-  /// Synchronize disk
-  void sync();
-
-  /// Return pointer to memory area
-  void* base() const { return mapbase; }
-
-  /// Obtain length of the map
-  long length() const { return maplength; }
-
-  /// Obtain offset of the map
-  long offset() const { return mapoffset; }
-
-  /// Destroy the map
-  ~FXMemMap();
-  };
-
-
-}
-
-#endif
diff --git a/fox-includes/FXMemoryStream.h b/fox-includes/FXMemoryStream.h
deleted file mode 100755
index 6ca0bc06..00000000
--- a/fox-includes/FXMemoryStream.h
+++ /dev/null
@@ -1,122 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                   M e m o r y   S t r e a m   C l a s s e s                   *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXMemoryStream.h 2344 2006-02-12 21:19:36Z lyle $                    *
-********************************************************************************/
-#ifndef FXMEMORYSTREAM_H
-#define FXMEMORYSTREAM_H
-
-#ifndef FXSTREAM_H
-#include "FXStream.h"
-#endif
-
-namespace FX {
-
-
-/// Memory Store Definition
-class FXAPI FXMemoryStream : public FXStream {
-protected:
-  virtual FXuval writeBuffer(FXuval count);
-  virtual FXuval readBuffer(FXuval count);
-public:
-
-  /// Create memory store
-  FXMemoryStream(const FXObject* cont=NULL);
-
-  /// Open file store
-  bool open(FXStreamDirection save_or_load,FXuchar* data);
-
-  /// Open memory store
-  bool open(FXStreamDirection save_or_load,FXuval size,FXuchar* data);
-
-  /// Take buffer away from stream
-  void takeBuffer(FXuchar*& data,FXuval& size);
-
-  /// Give buffer to stream
-  void giveBuffer(FXuchar *data,FXuval size);
-
-  /// Close memory store
-  virtual bool close();
-
-  /// Get position
-  FXlong position() const { return FXStream::position(); }
-
-  /// Move to position
-  virtual bool position(FXlong offset,FXWhence whence=FXFromStart);
-
-  /// Save single items to stream
-  FXMemoryStream& operator<<(const FXuchar& v){ FXStream::operator<<(v); return *this; }
-  FXMemoryStream& operator<<(const FXchar& v){ FXStream::operator<<(v); return *this; }
-  FXMemoryStream& operator<<(const FXushort& v){ FXStream::operator<<(v); return *this; }
-  FXMemoryStream& operator<<(const FXshort& v){ FXStream::operator<<(v); return *this; }
-  FXMemoryStream& operator<<(const FXuint& v){ FXStream::operator<<(v); return *this; }
-  FXMemoryStream& operator<<(const FXint& v){ FXStream::operator<<(v); return *this; }
-  FXMemoryStream& operator<<(const FXfloat& v){ FXStream::operator<<(v); return *this; }
-  FXMemoryStream& operator<<(const FXdouble& v){ FXStream::operator<<(v); return *this; }
-  FXMemoryStream& operator<<(const FXlong& v){ FXStream::operator<<(v); return *this; }
-  FXMemoryStream& operator<<(const FXulong& v){ FXStream::operator<<(v); return *this; }
-
-  /// Save arrays of items to stream
-  FXMemoryStream& save(const FXuchar* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXMemoryStream& save(const FXchar* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXMemoryStream& save(const FXushort* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXMemoryStream& save(const FXshort* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXMemoryStream& save(const FXuint* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXMemoryStream& save(const FXint* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXMemoryStream& save(const FXfloat* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXMemoryStream& save(const FXdouble* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXMemoryStream& save(const FXlong* p,FXuval n){ FXStream::save(p,n); return *this; }
-  FXMemoryStream& save(const FXulong* p,FXuval n){ FXStream::save(p,n); return *this; }
-
-  /// Load single items from stream
-  FXMemoryStream& operator>>(FXuchar& v){ FXStream::operator>>(v); return *this; }
-  FXMemoryStream& operator>>(FXchar& v){ FXStream::operator>>(v); return *this; }
-  FXMemoryStream& operator>>(FXushort& v){ FXStream::operator>>(v); return *this; }
-  FXMemoryStream& operator>>(FXshort& v){ FXStream::operator>>(v); return *this; }
-  FXMemoryStream& operator>>(FXuint& v){ FXStream::operator>>(v); return *this; }
-  FXMemoryStream& operator>>(FXint& v){ FXStream::operator>>(v); return *this; }
-  FXMemoryStream& operator>>(FXfloat& v){ FXStream::operator>>(v); return *this; }
-  FXMemoryStream& operator>>(FXdouble& v){ FXStream::operator>>(v); return *this; }
-  FXMemoryStream& operator>>(FXlong& v){ FXStream::operator>>(v); return *this; }
-  FXMemoryStream& operator>>(FXulong& v){ FXStream::operator>>(v); return *this; }
-
-  /// Load arrays of items from stream
-  FXMemoryStream& load(FXuchar* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXMemoryStream& load(FXchar* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXMemoryStream& load(FXushort* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXMemoryStream& load(FXshort* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXMemoryStream& load(FXuint* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXMemoryStream& load(FXint* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXMemoryStream& load(FXfloat* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXMemoryStream& load(FXdouble* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXMemoryStream& load(FXlong* p,FXuval n){ FXStream::load(p,n); return *this; }
-  FXMemoryStream& load(FXulong* p,FXuval n){ FXStream::load(p,n); return *this; }
-
-  /// Save object
-  FXMemoryStream& saveObject(const FXObject* v){ FXStream::saveObject(v); return *this; }
-
-  /// Load object
-  FXMemoryStream& loadObject(FXObject*& v){ FXStream::loadObject(v); return *this; }
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXMenuBar.h b/fox-includes/FXMenuBar.h
deleted file mode 100755
index d6183fc6..00000000
--- a/fox-includes/FXMenuBar.h
+++ /dev/null
@@ -1,73 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                             M e n u B a r   W i d g e t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXMenuBar.h 2343 2006-02-12 20:26:26Z lyle $                         *
-********************************************************************************/
-#ifndef FXMENUBAR_H
-#define FXMENUBAR_H
-
-#ifndef FXTOOLBAR_H
-#include "FXToolBar.h"
-#endif
-
-namespace FX {
-
-
-/// Menu bar
-class FXAPI FXMenuBar : public FXToolBar {
-  FXDECLARE(FXMenuBar)
-protected:
-  FXMenuBar(){}
-private:
-  FXMenuBar(const FXMenuBar&);
-  FXMenuBar &operator=(const FXMenuBar&);
-public:
-  long onFocusLeft(FXObject*,FXSelector,void*);
-  long onFocusRight(FXObject*,FXSelector,void*);
-  long onEnter(FXObject*,FXSelector,void*);
-  long onLeave(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onButtonPress(FXObject*,FXSelector,void*);
-  long onButtonRelease(FXObject*,FXSelector,void*);
-  long onCmdUnpost(FXObject*,FXSelector,void*);
-public:
-
-  /**
-  * Construct a floatable menubar
-  * Normally, the menubar is docked under window p.
-  * When floated, the menubar can be docked under window q, which is
-  * typically an FXToolbarShell window.
-  */
-  FXMenuBar(FXComposite* p,FXComposite* q,FXuint opts=LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=3,FXint pr=3,FXint pt=2,FXint pb=2,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING);
-
-  /**
-  * Construct a non-floatable menubar.
-  * The menubar can not be undocked.
-  */
-  FXMenuBar(FXComposite* p,FXuint opts,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=3,FXint pr=3,FXint pt=2,FXint pb=2,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING);
-
-  /// Returns true if specified coordinate (in parent's coordinate system) is in menubar
-  virtual bool contains(FXint parentx,FXint parenty) const;
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXMenuButton.h b/fox-includes/FXMenuButton.h
deleted file mode 100755
index a87d78a5..00000000
--- a/fox-includes/FXMenuButton.h
+++ /dev/null
@@ -1,175 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        M e n u B u t t o n   W i d g e t                      *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXMenuButton.h 2344 2006-02-12 21:19:36Z lyle $                      *
-********************************************************************************/
-#ifndef FXMENUBUTTON_H
-#define FXMENUBUTTON_H
-
-#ifndef FXLABEL_H
-#include "FXLabel.h"
-#endif
-
-namespace FX {
-
-
-class FXPopup;
-
-
-// Menu button options
-enum {
-  MENUBUTTON_AUTOGRAY      = 0x00800000,                                      /// Automatically gray out when no target
-  MENUBUTTON_AUTOHIDE      = 0x01000000,                                      /// Automatically hide when no target
-  MENUBUTTON_TOOLBAR       = 0x02000000,                                      /// Toolbar style
-  MENUBUTTON_DOWN          = 0,                                               /// Popup window appears below menu button
-  MENUBUTTON_UP            = 0x04000000,                                      /// Popup window appears above menu button
-  MENUBUTTON_LEFT          = 0x08000000,                                      /// Popup window to the left of the menu button
-  MENUBUTTON_RIGHT         = MENUBUTTON_LEFT|MENUBUTTON_UP,                   /// Popup window to the right of the menu button
-  MENUBUTTON_NOARROWS      = 0x10000000,                                      /// Do not show arrows
-  MENUBUTTON_ATTACH_LEFT   = 0,                                               /// Popup attaches to the left side of the menu button
-  MENUBUTTON_ATTACH_TOP    = MENUBUTTON_ATTACH_LEFT,                          /// Popup attaches to the top of the menu button
-  MENUBUTTON_ATTACH_RIGHT  = 0x20000000,                                      /// Popup attaches to the right side of the menu button
-  MENUBUTTON_ATTACH_BOTTOM = MENUBUTTON_ATTACH_RIGHT,                         /// Popup attaches to the bottom of the menu button
-  MENUBUTTON_ATTACH_CENTER = 0x40000000,                                      /// Popup attaches to the center of the menu button
-  MENUBUTTON_ATTACH_BOTH   = MENUBUTTON_ATTACH_CENTER|MENUBUTTON_ATTACH_RIGHT /// Popup attaches to both sides of the menu button
-  };
-
-
-
-/**
-* A menu button posts a popup menu when clicked.
-* There are many ways to control the placement where the popup will appear;
-* first, the popup may be placed on either of the four sides relative to the
-* menu button; this is controlled by the flags MENUBUTTON_DOWN, etc.
-* Next, there are several attachment modes; the popup's left/bottom edge may
-* attach to the menu button's left/top edge, or the popup's right/top edge may
-* attach to the menu button's right/bottom edge, or both.
-* Also, the popup may apear centered relative to the menu button.
-* Finally, a small offset may be specified to displace the location of the
-* popup by a few pixels so as to account for borders and so on.
-* Normally, the menu button shows an arrow pointing to the direction where
-* the popup is set to appear; this can be turned off by passing the option
-* MENUBUTTON_NOARROWS.
-*/
-class FXAPI FXMenuButton : public FXLabel {
-  FXDECLARE(FXMenuButton)
-protected:
-  FXPopup *pane;                  // Pane to pop up
-  FXint    offsetx;               // Shift attachment point x
-  FXint    offsety;               // Shift attachment point y
-  FXbool   state;                 // Pane was popped
-protected:
-  FXMenuButton();
-private:
-  FXMenuButton(const FXMenuButton&);
-  FXMenuButton &operator=(const FXMenuButton&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onUpdate(FXObject*,FXSelector,void*);
-  long onEnter(FXObject*,FXSelector,void*);
-  long onLeave(FXObject*,FXSelector,void*);
-  long onFocusIn(FXObject*,FXSelector,void*);
-  long onFocusOut(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onHotKeyPress(FXObject*,FXSelector,void*);
-  long onHotKeyRelease(FXObject*,FXSelector,void*);
-  long onCmdPost(FXObject*,FXSelector,void*);
-  long onCmdUnpost(FXObject*,FXSelector,void*);
-public:
-
-  /// Constructor
-  FXMenuButton(FXComposite* p,const FXString& text,FXIcon* ic=NULL,FXPopup* pup=NULL,FXuint opts=JUSTIFY_NORMAL|ICON_BEFORE_TEXT|MENUBUTTON_DOWN,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Returns true because a menu button can receive focus
-  virtual bool canFocus() const;
-
-  /// Remove the focus from this window
-  virtual void killFocus();
-
-  /// Return true if window logically contains the given point
-  virtual bool contains(FXint parentx,FXint parenty) const;
-
-  /// Change the popup menu
-  void setMenu(FXPopup *pup);
-
-  /// Return current popup menu
-  FXPopup* getMenu() const { return pane; }
-
-  /// Set X offset where menu pops up relative to button
-  void setXOffset(FXint offx){ offsetx=offx; }
-
-  /// Return current X offset
-  FXint getXOffset() const { return offsetx; }
-
-  /// Set Y offset where menu pops up relative to button
-  void setYOffset(FXint offy){ offsety=offy; }
-
-  /// Return current Y offset
-  FXint getYOffset() const { return offsety; }
-
-  /// Change menu button style
-  void setButtonStyle(FXuint style);
-
-  /// Get menu button style
-  FXuint getButtonStyle() const;
-
-  /// Change popup style
-  void setPopupStyle(FXuint style);
-
-  /// Get popup style
-  FXuint getPopupStyle() const;
-
-  /// Change attachment
-  void setAttachment(FXuint att);
-
-  /// Get attachment
-  FXuint getAttachment() const;
-
-  /// Save menu button to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load menu button from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXMenuButton();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXMenuCaption.h b/fox-includes/FXMenuCaption.h
deleted file mode 100755
index 2ec3a399..00000000
--- a/fox-includes/FXMenuCaption.h
+++ /dev/null
@@ -1,183 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                         M e n u C a p t i o n   W i d g e t                   *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXMenuCaption.h 2344 2006-02-12 21:19:36Z lyle $                     *
-********************************************************************************/
-#ifndef FXMENUCAPTION_H
-#define FXMENUCAPTION_H
-
-#ifndef FXWINDOW_H
-#include "FXWindow.h"
-#endif
-
-namespace FX {
-
-
-/// Menu Caption options
-enum {
-  MENU_AUTOGRAY = 0x00008000,   /// Automatically gray out when not updated
-  MENU_AUTOHIDE = 0x00010000    /// Automatically hide button when not updated
-  };
-
-
-class FXIcon;
-class FXFont;
-
-
-/**
-* The menu caption is a widget which can be used as a caption
-* above a number of menu commands in a menu.
-*/
-class FXAPI FXMenuCaption : public FXWindow {
-  FXDECLARE(FXMenuCaption)
-protected:
-  FXString     label;
-  FXString     help;
-  FXString     tip;
-  FXIcon      *icon;
-  FXFont      *font;
-  FXint        hotoff;
-  FXHotKey     hotkey;
-  FXColor      textColor;
-  FXColor      selbackColor;
-  FXColor      seltextColor;
-  FXColor      hiliteColor;
-  FXColor      shadowColor;
-protected:
-  FXMenuCaption();
-private:
-  FXMenuCaption(const FXMenuCaption&);
-  FXMenuCaption &operator=(const FXMenuCaption&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onUpdate(FXObject*,FXSelector,void*);
-  long onCmdGetStringValue(FXObject*,FXSelector,void*);
-  long onCmdSetStringValue(FXObject*,FXSelector,void*);
-  long onCmdSetIconValue(FXObject*,FXSelector,void*);
-  long onCmdGetIconValue(FXObject*,FXSelector,void*);
-  long onCmdSetHelp(FXObject*,FXSelector,void*);
-  long onCmdGetHelp(FXObject*,FXSelector,void*);
-  long onCmdSetTip(FXObject*,FXSelector,void*);
-  long onCmdGetTip(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct a menu caption
-  FXMenuCaption(FXComposite* p,const FXString& text,FXIcon* ic=NULL,FXuint opts=0);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Enable the menu
-  virtual void enable();
-
-  /// Disable the menu
-  virtual void disable();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Set the text for this menu
-  void setText(const FXString& text);
-
-  /// Get the text for this menu
-  FXString getText() const { return label; }
-
-  /// Set the icon for this menu
-  void setIcon(FXIcon* ic);
-
-  /// Get the icon for this menu
-  FXIcon* getIcon() const { return icon; }
-
-  /// Set the text font
-  void setFont(FXFont* fnt);
-
-  /// Return the text font
-  FXFont* getFont() const { return font; }
-
-  /// Set menu caption style
-  void setMenuStyle(FXuint style);
-
-  /// Get menu caption style
-  FXuint getMenuStyle() const;
-
-  /// Return the current text color
-  void setTextColor(FXColor clr);
-
-  /// Get the current text color
-  FXColor getTextColor() const { return textColor; }
-
-  /// Return the selection background color
-  void setSelBackColor(FXColor clr);
-
-  /// Return the selection background color
-  FXColor getSelBackColor() const { return selbackColor; }
-
-  /// Return the selection text color
-  void setSelTextColor(FXColor clr);
-
-  /// Return the selection text color
-  FXColor getSelTextColor() const { return seltextColor; }
-
-  /// Change highlight color
-  void setHiliteColor(FXColor clr);
-
-  /// Get highlight color
-  FXColor getHiliteColor() const { return hiliteColor; }
-
-  /// Change shadow color
-  void setShadowColor(FXColor clr);
-
-  /// Get shadow color
-  FXColor getShadowColor() const { return shadowColor; }
-
-  /// Set the status line help text for this menu
-  void setHelpText(const FXString& text);
-
-  /// Get the status line help text for this menu
-  const FXString& getHelpText() const { return help; }
-
-  /// Set the tool tip message for this menu
-  void setTipText(const FXString& text){ tip=text; }
-
-  /// Get the tool tip message for this menu
-  const FXString& getTipText() const { return tip; }
-
-  /// Save menu to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load menu from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXMenuCaption();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXMenuCascade.h b/fox-includes/FXMenuCascade.h
deleted file mode 100755
index 032c05cc..00000000
--- a/fox-includes/FXMenuCascade.h
+++ /dev/null
@@ -1,112 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        M e n u C a s c a d e   W i d g e t                    *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXMenuCascade.h 2344 2006-02-12 21:19:36Z lyle $                     *
-********************************************************************************/
-#ifndef FXMENUCASCADE_H
-#define FXMENUCASCADE_H
-
-#ifndef FXMENUCAPTION_H
-#include "FXMenuCaption.h"
-#endif
-
-namespace FX {
-
-
-class FXPopup;
-
-
-/**
-* The cascade menu widget is used to bring up a sub menu from a
-* pull down menu.
-*/
-class FXAPI FXMenuCascade : public FXMenuCaption {
-  FXDECLARE(FXMenuCascade)
-protected:
-  FXPopup *pane;
-protected:
-  FXMenuCascade();
-  void drawTriangle(FXDCWindow& dc,FXint l,FXint t,FXint r,FXint b);
-private:
-  FXMenuCascade(const FXMenuCascade&);
-  FXMenuCascade &operator=(const FXMenuCascade&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onEnter(FXObject*,FXSelector,void*);
-  long onLeave(FXObject*,FXSelector,void*);
-  long onButtonPress(FXObject*,FXSelector,void*);
-  long onButtonRelease(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onHotKeyPress(FXObject*,FXSelector,void*);
-  long onHotKeyRelease(FXObject*,FXSelector,void*);
-  long onCmdPost(FXObject*,FXSelector,void*);
-  long onCmdUnpost(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_MENUTIMER=FXMenuCaption::ID_LAST,
-    ID_LAST
-    };
-public:
-
-  /// Construct a menu cascade responsible for the given popup menu
-  FXMenuCascade(FXComposite* p,const FXString& text,FXIcon* ic=NULL,FXPopup* pup=NULL,FXuint opts=0);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Destroy server-side resources
-  virtual void destroy();
-
-  /// Yes it can receive the focus
-  virtual bool canFocus() const;
-
-  /// Move the focus to this window
-  virtual void setFocus();
-
-  /// Remove the focus from this window
-  virtual void killFocus();
-
-  /// Set popup menu to pop up
-  void setMenu(FXPopup *pup){ pane = pup; }
-
-  /// Return popup menu
-  FXPopup* getMenu() const { return pane; }
-
-  /// True if this menu or is popup logically contains the mouse
-  virtual bool contains(FXint parentx,FXint parenty) const;
-
-  /// Save menu to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load menu from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXMenuCascade();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXMenuCheck.h b/fox-includes/FXMenuCheck.h
deleted file mode 100755
index aaf8a4b0..00000000
--- a/fox-includes/FXMenuCheck.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                          M e n u C h e c k   W i d g e t                      *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2002,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXMenuCheck.h 2264 2005-12-02 01:45:28Z lyle $                       *
-********************************************************************************/
-#ifndef FXMENUCHECK_H
-#define FXMENUCHECK_H
-
-#ifndef FXMENUCOMMAND_H
-#include "FXMenuCommand.h"
-#endif
-
-namespace FX {
-
-
-/**
-* The menu check widget is used to change a state in the
-* application from a menu.  Menu checks may reflect
-* the state of the application by graying out, becoming hidden,
-* or by a check mark.
-* When activated, a menu check sends a SEL_COMMAND to its target;
-* the void* argument of the message contains the new state.
-*/
-class FXAPI FXMenuCheck : public FXMenuCommand {
-  FXDECLARE(FXMenuCheck)
-protected:
-  FXuchar check;        // State of menu
-  FXColor boxColor;     // Box color
-protected:
-  FXMenuCheck();
-private:
-  FXMenuCheck(const FXMenuCheck&);
-  FXMenuCheck &operator=(const FXMenuCheck&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onButtonPress(FXObject*,FXSelector,void*);
-  long onButtonRelease(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onHotKeyPress(FXObject*,FXSelector,void*);
-  long onHotKeyRelease(FXObject*,FXSelector,void*);
-  long onCheck(FXObject*,FXSelector,void*);
-  long onUncheck(FXObject*,FXSelector,void*);
-  long onUnknown(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-  long onCmdAccel(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct a menu check
-  FXMenuCheck(FXComposite* p,const FXString& text,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=0);
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Set check state (TRUE, FALSE or MAYBE)
-  void setCheck(FXbool s=TRUE);
-
-  /// Get check state (TRUE, FALSE or MAYBE)
-  FXbool getCheck() const { return check; }
-
-  /// Get the box background color
-  FXColor getBoxColor() const { return boxColor; }
-
-  /// Set the box background color
-  void setBoxColor(FXColor clr);
-
-  /// Save menu to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load menu from a stream
-  virtual void load(FXStream& store);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXMenuCommand.h b/fox-includes/FXMenuCommand.h
deleted file mode 100755
index d14e5a31..00000000
--- a/fox-includes/FXMenuCommand.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       M e n u C o m m a n d   W i d g e t                     *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXMenuCommand.h 2343 2006-02-12 20:26:26Z lyle $                     *
-********************************************************************************/
-#ifndef FXMENUCOMMAND_H
-#define FXMENUCOMMAND_H
-
-#ifndef FXMENUCAPTION_H
-#include "FXMenuCaption.h"
-#endif
-
-namespace FX {
-
-
-/**
-* The menu command widget is used to invoke a command in the
-* application from a menu.  Menu commands may reflect
-* the state of the application by graying out, or becoming hidden.
-* When activated, a menu command sends a SEL_COMMAND to its target.
-*/
-class FXAPI FXMenuCommand : public FXMenuCaption {
-  FXDECLARE(FXMenuCommand)
-protected:
-  FXString     accel;       // Accelerator string
-  FXHotKey     acckey;      // Accelerator key
-protected:
-  FXMenuCommand();
-private:
-  FXMenuCommand(const FXMenuCommand&);
-  FXMenuCommand &operator=(const FXMenuCommand&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onEnter(FXObject*,FXSelector,void*);
-  long onLeave(FXObject*,FXSelector,void*);
-  long onButtonPress(FXObject*,FXSelector,void*);
-  long onButtonRelease(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onHotKeyPress(FXObject*,FXSelector,void*);
-  long onHotKeyRelease(FXObject*,FXSelector,void*);
-  long onCmdAccel(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct a menu command
-  FXMenuCommand(FXComposite* p,const FXString& text,FXIcon* ic=NULL,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=0);
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Yes it can receive the focus
-  virtual bool canFocus() const;
-
-  /// Move the focus to this window
-  virtual void setFocus();
-
-  /// Remove the focus from this window
-  virtual void killFocus();
-
-  /// Set accelerator text
-  void setAccelText(const FXString& text);
-
-  /// Return accelarator text
-  FXString getAccelText() const { return accel; }
-
-  /// Save menu to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load menu from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXMenuCommand();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXMenuPane.h b/fox-includes/FXMenuPane.h
deleted file mode 100755
index c56cf373..00000000
--- a/fox-includes/FXMenuPane.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        M e n u   P a n e   W i d g e t                        *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXMenuPane.h 2344 2006-02-12 21:19:36Z lyle $                        *
-********************************************************************************/
-#ifndef FXMENUPANE_H
-#define FXMENUPANE_H
-
-#ifndef FXPOPUP_H
-#include "FXPopup.h"
-#endif
-
-namespace FX {
-
-/// Popup menu pane
-class FXAPI FXMenuPane : public FXPopup {
-  FXDECLARE(FXMenuPane)
-protected:
-  FXMenuPane(){}
-private:
-  FXMenuPane(const FXMenuPane&);
-  FXMenuPane &operator=(const FXMenuPane&);
-public:
-
-  /// Construct menu pane
-  FXMenuPane(FXWindow* owner,FXuint opts=0);
-
-  /// Return true if popup contains this point
-  virtual bool contains(FXint parentx,FXint parenty) const;
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXMenuRadio.h b/fox-includes/FXMenuRadio.h
deleted file mode 100755
index ce2de225..00000000
--- a/fox-includes/FXMenuRadio.h
+++ /dev/null
@@ -1,102 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                         M e n u R a d i o   W i d g e t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2002,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXMenuRadio.h 2266 2005-12-02 01:49:09Z lyle $                       *
-********************************************************************************/
-#ifndef FXMENURADIO_H
-#define FXMENURADIO_H
-
-#ifndef FXMENUCOMMAND_H
-#include "FXMenuCommand.h"
-#endif
-
-namespace FX {
-
-
-/**
-* The menu radio widget is used to invoke a command in the
-* application from a menu.  Menu commands may reflect
-* the state of the application by graying out, becoming hidden,
-* or by a bullit.
-* When activated, a menu radio sends a SEL_COMMAND to its target;
-* the void* argument of the message contains the new state.
-* A collection of menu radio widgets which belong to each other
-* is supposed to be updated by a common SEL_UPDATE handler to
-* properly maintain the state between them.
-*/
-class FXAPI FXMenuRadio : public FXMenuCommand {
-  FXDECLARE(FXMenuRadio)
-protected:
-  FXuchar check;        // State of menu
-  FXColor radioColor;   // Color of the radio
-protected:
-  FXMenuRadio();
-private:
-  FXMenuRadio(const FXMenuRadio&);
-  FXMenuRadio &operator=(const FXMenuRadio&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onButtonPress(FXObject*,FXSelector,void*);
-  long onButtonRelease(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onHotKeyPress(FXObject*,FXSelector,void*);
-  long onHotKeyRelease(FXObject*,FXSelector,void*);
-  long onCheck(FXObject*,FXSelector,void*);
-  long onUncheck(FXObject*,FXSelector,void*);
-  long onUnknown(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-  long onCmdAccel(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct a menu radio
-  FXMenuRadio(FXComposite* p,const FXString& text,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=0);
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Set radio button state (TRUE, FALSE or MAYBE)
-  void setCheck(FXbool s=TRUE);
-
-  /// Get radio button state (TRUE, FALSE or MAYBE)
-  FXbool getCheck() const { return check; }
-
-  /// Get the radio background color
-  FXColor getRadioColor() const { return radioColor; }
-
-  /// Set the radio background color
-  void setRadioColor(FXColor clr);
-
-  /// Save menu to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load menu from a stream
-  virtual void load(FXStream& store);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXMenuSeparator.h b/fox-includes/FXMenuSeparator.h
deleted file mode 100755
index c7c87697..00000000
--- a/fox-includes/FXMenuSeparator.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                    M e n u   S e p a r a t o r   W i d g e t                  *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2002 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXMenuSeparator.h 809 2002-07-11 17:28:15Z lyle $                   *
-********************************************************************************/
-#ifndef FXMENUSEPARATOR_H
-#define FXMENUSEPARATOR_H
-
-#ifndef FXWINDOW_H
-#include "FXWindow.h"
-#endif
-
-namespace FX {
-
-
-/**
-* The menu separator is a simple decorative groove
-* used to delineate items in a popup menu.
-*/
-class FXAPI FXMenuSeparator : public FXWindow {
-  FXDECLARE(FXMenuSeparator)
-protected:
-  FXColor hiliteColor;
-  FXColor shadowColor;
-protected:
-  FXMenuSeparator();
-private:
-  FXMenuSeparator(const FXMenuSeparator&);
-  FXMenuSeparator &operator=(const FXMenuSeparator&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct a menu separator
-  FXMenuSeparator(FXComposite* p,FXuint opts=0);
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Change highlight color
-  void setHiliteColor(FXColor clr);
-
-  /// Get highlight color
-  FXColor getHiliteColor() const { return hiliteColor; }
-
-  /// Change shadow color
-  void setShadowColor(FXColor clr);
-
-  /// Get shadow color
-  FXColor getShadowColor() const { return shadowColor; }
-
-  /// Save menu to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load menu from a stream
-  virtual void load(FXStream& store);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXMenuTitle.h b/fox-includes/FXMenuTitle.h
deleted file mode 100755
index 19e35eda..00000000
--- a/fox-includes/FXMenuTitle.h
+++ /dev/null
@@ -1,113 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                      M e n u   T i t l e   W i d g e t                        *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXMenuTitle.h 2344 2006-02-12 21:19:36Z lyle $                       *
-********************************************************************************/
-#ifndef FXMENUTITLE_H
-#define FXMENUTITLE_H
-
-#ifndef FXMENUCAPTION_H
-#include "FXMenuCaption.h"
-#endif
-
-namespace FX {
-
-
-class FXPopup;
-
-
-/**
-* A menu title is a child of a menu bar which is responsible
-* for popping up a pulldown menu.
-*/
-class FXAPI FXMenuTitle : public FXMenuCaption {
-  FXDECLARE(FXMenuTitle)
-protected:
-  FXPopup *pane;        // Pane to pop up
-protected:
-  FXMenuTitle(){}
-private:
-  FXMenuTitle(const FXMenuTitle&);
-  FXMenuTitle &operator=(const FXMenuTitle&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onEnter(FXObject*,FXSelector,void*);
-  long onLeave(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onHotKeyPress(FXObject*,FXSelector,void*);
-  long onHotKeyRelease(FXObject*,FXSelector,void*);
-  long onFocusUp(FXObject*,FXSelector,void*);
-  long onFocusDown(FXObject*,FXSelector,void*);
-  long onFocusIn(FXObject*,FXSelector,void*);
-  long onFocusOut(FXObject*,FXSelector,void*);
-  long onCmdPost(FXObject*,FXSelector,void*);
-  long onCmdUnpost(FXObject*,FXSelector,void*);
-public:
-
-  /// Constructor
-  FXMenuTitle(FXComposite* p,const FXString& text,FXIcon* ic=NULL,FXPopup* pup=NULL,FXuint opts=0);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Yes it can receive the focus
-  virtual bool canFocus() const;
-
-  /// Move the focus to this window
-  virtual void setFocus();
-
-  /// Remove the focus from this window
-  virtual void killFocus();
-
-  /// Set popup menu to pop up
-  void setMenu(FXPopup *menu);
-
-  /// Return popup menu
-  FXPopup* getMenu() const { return pane; }
-
-  /// True if this menu or is popup logically contains the mouse
-  virtual bool contains(FXint parentx,FXint parenty) const;
-
-  /// Save menu to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load menu from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXMenuTitle();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXMessageBox.h b/fox-includes/FXMessageBox.h
deleted file mode 100755
index ec4f79ac..00000000
--- a/fox-includes/FXMessageBox.h
+++ /dev/null
@@ -1,148 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                         M e s s a g e   B o x e s                             *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXMessageBox.h 2267 2005-12-02 01:50:35Z lyle $                      *
-********************************************************************************/
-#ifndef FXMESSAGEBOX_H
-#define FXMESSAGEBOX_H
-
-#ifndef FXDIALOGBOX_H
-#include "FXDialogBox.h"
-#endif
-
-namespace FX {
-
-
-// Message box buttons
-enum {
-  MBOX_OK                   = 0x10000000, /// Message box has a only an OK button
-  MBOX_OK_CANCEL            = 0x20000000, /// Message box has OK and CANCEL buttons
-  MBOX_YES_NO               = 0x30000000, /// Message box has YES and NO buttons
-  MBOX_YES_NO_CANCEL        = 0x40000000, /// Message box has YES, NO, and CANCEL buttons
-  MBOX_QUIT_CANCEL          = 0x50000000, /// Message box has QUIT and CANCEL buttons
-  MBOX_QUIT_SAVE_CANCEL     = 0x60000000, /// Message box has QUIT, SAVE, and CANCEL buttons
-  MBOX_SKIP_SKIPALL_CANCEL  = 0x70000000, /// Message box has SKIP, SKIP ALL, and CANCEL buttons
-  MBOX_SAVE_CANCEL_DONTSAVE = 0x80000000  /// Message box has DON'T SAVE,CANCEL and SAVE buttons
-  };
-
-
-// Return values
-enum {
-  MBOX_CLICKED_YES      = 1,            /// The YES button was clicked
-  MBOX_CLICKED_NO       = 2,            /// The NO button was clicked
-  MBOX_CLICKED_OK       = 3,            /// The OK button was clicked
-  MBOX_CLICKED_CANCEL   = 4,            /// The CANCEL button was clicked
-  MBOX_CLICKED_QUIT     = 5,            /// The QUIT button was clicked
-  MBOX_CLICKED_SAVE     = 6,            /// The SAVE button was clicked
-  MBOX_CLICKED_SKIP     = 7,            /// The SKIP button was clicked
-  MBOX_CLICKED_SKIPALL  = 8             /// The SKIP ALL button was clicked
-  };
-
-
-/**
-* A Message Box is a convenience class which provides a dialog for
-* very simple common yes/no type interactions with the user.
-* The message box has an optional icon, a title string, and the question
-* which is presented to the user.  It also has up to three buttons which
-* furnish standard responses to the question.
-* Message boxes are usually ran modally: the question must be answered
-* before the program may continue.
-*/
-class FXAPI FXMessageBox : public FXDialogBox {
-  FXDECLARE(FXMessageBox)
-protected:
-  FXMessageBox(){}
-private:
-  FXMessageBox(const FXMessageBox&);
-  FXMessageBox &operator=(const FXMessageBox&);
-  void initialize(const FXString& text,FXIcon* ic,FXuint whichbuttons);
-public:
-  long onCmdClicked(FXObject*,FXSelector,void*);
-  long onCmdCancel(FXObject*,FXSelector,void*);
-public:
-  enum{
-    ID_CLICKED_YES=FXDialogBox::ID_LAST,
-    ID_CLICKED_NO,
-    ID_CLICKED_OK,
-    ID_CLICKED_CANCEL,
-    ID_CLICKED_QUIT,
-    ID_CLICKED_SAVE,
-    ID_CLICKED_SKIP,
-    ID_CLICKED_SKIPALL,
-    ID_LAST
-    };
-public:
-
-  /// Construct message box with given caption, icon, and message text
-  FXMessageBox(FXWindow* owner,const FXString& caption,const FXString& text,FXIcon* ic=NULL,FXuint opts=0,FXint x=0,FXint y=0);
-
-  /// Construct free floating message box with given caption, icon, and message text
-  FXMessageBox(FXApp* app,const FXString& caption,const FXString& text,FXIcon* ic=NULL,FXuint opts=0,FXint x=0,FXint y=0);
-
-  /**
-  * Show a modal error message.
-  * The text message may contain printf-tyle formatting commands.
-  */
-  static FXuint error(FXWindow* owner,FXuint opts,const char* caption,const char* message,...) FX_PRINTF(4,5) ;
-
-  /**
-  * Show modal error message, in free floating window.
-  */
-  static FXuint error(FXApp* app,FXuint opts,const char* caption,const char* message,...) FX_PRINTF(4,5) ;
-
-  /**
-  * Show a modal warning message
-  * The text message may contain printf-tyle formatting commands.
-  */
-  static FXuint warning(FXWindow* owner,FXuint opts,const char* caption,const char* message,...) FX_PRINTF(4,5) ;
-
-  /**
-  * Show modal warning message, in free floating window.
-  */
-  static FXuint warning(FXApp* app,FXuint opts,const char* caption,const char* message,...) FX_PRINTF(4,5) ;
-
-  /**
-  * Show a modal question dialog
-  * The text message may contain printf-tyle formatting commands.
-  */
-  static FXuint question(FXWindow* owner,FXuint opts,const char* caption,const char* message,...) FX_PRINTF(4,5) ;
-
-  /**
-  * Show modal question message, in free floating window.
-  */
-  static FXuint question(FXApp* app,FXuint opts,const char* caption,const char* message,...) FX_PRINTF(4,5) ;
-
-  /**
-  * Show a modal information dialog
-  * The text message may contain printf-tyle formatting commands.
-  */
-  static FXuint information(FXWindow* owner,FXuint opts,const char* caption,const char* message,...) FX_PRINTF(4,5) ;
-
-  /**
-  * Show modal information message, in free floating window.
-  */
-  static FXuint information(FXApp* app,FXuint opts,const char* caption,const char* message,...) FX_PRINTF(4,5) ;
-
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXObject.h b/fox-includes/FXObject.h
deleted file mode 100755
index 8279aaec..00000000
--- a/fox-includes/FXObject.h
+++ /dev/null
@@ -1,194 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                         T o p l e v el   O b j e c t                          *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXObject.h 2268 2005-12-02 01:52:22Z lyle $                          *
-********************************************************************************/
-#ifndef FXOBJECT_H
-#define FXOBJECT_H
-
-
-namespace FX {
-
-/// Minimum and maximum message id
-enum {
-  MINKEY = 0,
-  MAXKEY = 65535
-  };
-
-
-/// Minimum and maximum message type
-enum {
-  MINTYPE = 0,
-  MAXTYPE = 65535
-  };
-
-
-/// Association key
-typedef FXuint FXSelector;
-
-
-class FXObject;
-
-
-/// Describes a FOX object
-class FXAPI FXMetaClass {
-private:
-  const FXchar              *className;
-  FXObject*                (*manufacture)();
-  const FXMetaClass         *baseClass;
-  const void                *assoc;
-  FXuint                     nassocs;
-  FXuint                     assocsz;
-private:
-  static const FXMetaClass **metaClassTable;
-  static FXuint              nmetaClassTable;
-  static FXuint              nmetaClasses;
-private:
-  static void resize(FXuint n);
-public:
-  FXMetaClass(const FXchar* name,FXObject *(fac)(),const FXMetaClass* base,const void* ass,FXuint nass,FXuint assz);
-
-  /// Check if metaclass is subclass of some other metaclass
-  bool isSubClassOf(const FXMetaClass* metaclass) const;
-
-  /// Make instance of some object
-  FXObject* makeInstance() const;
-
-  /// Ask class name
-  const FXchar* getClassName() const { return className; }
-
-  /// Ask base class
-  const FXMetaClass* getBaseClass() const { return baseClass; }
-
-  /// Find metaclass object
-  static const FXMetaClass* getMetaClassFromName(const FXchar* name);
-
-  /// Search message map
-  const void* search(FXSelector key) const;
-
- ~FXMetaClass();
-  };
-
-
-/// Macro to set up class declaration
-#define FXDECLARE(classname) \
-  public: \
-   struct FXMapEntry { FX::FXSelector keylo; FX::FXSelector keyhi; long (classname::* func)(FX::FXObject*,FX::FXSelector,void*); }; \
-   static const FX::FXMetaClass metaClass; \
-   static FX::FXObject* manufacture(); \
-   virtual long handle(FX::FXObject* sender,FX::FXSelector sel,void* ptr); \
-   virtual const FX::FXMetaClass* getMetaClass() const { return &metaClass; } \
-   friend FX::FXStream& operator<<(FX::FXStream& store,const classname* obj){return store.saveObject((FX::FXObjectPtr)(obj));} \
-   friend FX::FXStream& operator>>(FX::FXStream& store,classname*& obj){return store.loadObject((FX::FXObjectPtr&)(obj));} \
-  private:
-
-
-/// Macro to set up class implementation
-#define FXIMPLEMENT(classname,baseclassname,mapping,nmappings) \
-  FX::FXObject* classname::manufacture(){return new classname;} \
-  const FX::FXMetaClass classname::metaClass(#classname,classname::manufacture,&baseclassname::metaClass,mapping,nmappings,sizeof(classname::FXMapEntry)); \
-  long classname::handle(FX::FXObject* sender,FX::FXSelector sel,void* ptr){ \
-    const FXMapEntry* me=(const FXMapEntry*)metaClass.search(sel); \
-    return me ? (this->* me->func)(sender,sel,ptr) : baseclassname::handle(sender,sel,ptr); \
-    }
-
-
-/// Macro to set up abstract class declaration
-#define FXDECLARE_ABSTRACT(classname) \
-  public: \
-   struct FXMapEntry { FX::FXSelector keylo; FX::FXSelector keyhi; long (classname::* func)(FX::FXObject*,FX::FXSelector,void*); }; \
-   static const FX::FXMetaClass metaClass; \
-   virtual long handle(FX::FXObject* sender,FX::FXSelector sel,void* ptr); \
-   virtual const FX::FXMetaClass* getMetaClass() const { return &metaClass; } \
-   friend FX::FXStream& operator<<(FX::FXStream& store,const classname* obj){return store.saveObject((FX::FXObjectPtr)(obj));} \
-   friend FX::FXStream& operator>>(FX::FXStream& store,classname*& obj){return store.loadObject((FX::FXObjectPtr&)(obj));} \
-  private:
-
-
-/// Macro to set up abstract class implementation
-#define FXIMPLEMENT_ABSTRACT(classname,baseclassname,mapping,nmappings) \
-  const FX::FXMetaClass classname::metaClass(#classname,NULL,&baseclassname::metaClass,mapping,nmappings,sizeof(classname::FXMapEntry)); \
-  long classname::handle(FX::FXObject* sender,FX::FXSelector sel,void* ptr){ \
-    const FXMapEntry* me=(const FXMapEntry*)metaClass.search(sel); \
-    return me ? (this->* me->func)(sender,sel,ptr) : baseclassname::handle(sender,sel,ptr); \
-    }
-
-
-/// MetaClass of a class
-#define FXMETACLASS(classname) (&classname::metaClass)
-
-
-/// Set up map type
-#define FXDEFMAP(classname) static const classname::FXMapEntry
-
-/// Define range of function types
-#define FXMAPTYPES(typelo,typehi,func) {MKUINT(MINKEY,typelo),MKUINT(MAXKEY,typehi),&func}
-
-/// Define range of function types
-#define FXMAPTYPE(type,func) {MKUINT(MINKEY,type),MKUINT(MAXKEY,type),&func}
-
-/// Define range of functions
-#define FXMAPFUNCS(type,keylo,keyhi,func) {MKUINT(keylo,type),MKUINT(keyhi,type),&func}
-
-/// Define one function
-#define FXMAPFUNC(type,key,func) {MKUINT(key,type),MKUINT(key,type),&func}
-
-
-/**
-* Object is the base class for all objects in FOX; in order to receive
-* messages from the user interface, your class must derive from Object.
-* The Object class also provides serialization facilities, with which
-* you can save and restore the object's state.  If you've subclassed
-* from Object, you can save your subclasses' state by overloading the
-* save() and load() functions and use the stream API to serialize its
-* member data.
-*/
-class FXAPI FXObject {
-  FXDECLARE(FXObject)
-public:
-
-  /// Called for unhandled messages
-  virtual long onDefault(FXObject*,FXSelector,void*);
-
-public:
-
-  /// Get class name of some object
-  const FXchar* getClassName() const;
-
-  /// Check if object is member of metaclass
-  bool isMemberOf(const FXMetaClass* metaclass) const;
-
-  /// Try handle message safely
-  virtual long tryHandle(FXObject* sender,FXSelector sel,void* ptr);
-
-  /// Save object to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load object from stream
-  virtual void load(FXStream& store);
-
-  /// Virtual destructor
-  virtual ~FXObject();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXObjectList.h b/fox-includes/FXObjectList.h
deleted file mode 100755
index 1e8d4631..00000000
--- a/fox-includes/FXObjectList.h
+++ /dev/null
@@ -1,165 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                            O b j e c t   L i s t                              *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXObjectList.h 2344 2006-02-12 21:19:36Z lyle $                      *
-********************************************************************************/
-#ifndef FXOBJECTLIST_H
-#define FXOBJECTLIST_H
-
-#ifndef FXOBJECT_H
-#include "FXObject.h"
-#endif
-
-namespace FX {
-
-/// List of pointers to objects
-class FXAPI FXObjectList {
-protected:
-  FXObject **ptr;
-public:
-
-  /// Default constructor
-  FXObjectList();
-
-  /// Copy constructor
-  FXObjectList(const FXObjectList& orig);
-
-  /// Construct and init with single object
-  FXObjectList(FXObject* object);
-
-  /// Construct and init with list of objects
-  FXObjectList(FXObject** objects,FXint n);
-
-  /// Assignment operator
-  FXObjectList& operator=(const FXObjectList& orig);
-
-  /// Return number of objects
-  FXint no() const { return *((FXint*)(ptr-1)); }
-
-  /// Set number of objects
-  void no(FXint num);
-
-  /// Indexing operator
-  FXObject*& operator[](FXint i){ return ptr[i]; }
-  FXObject* const& operator[](FXint i) const { return ptr[i]; }
-
-  /// Indexing operator
-  FXObject*& at(FXint i){ return ptr[i]; }
-  FXObject* const& at(FXint i) const { return ptr[i]; }
-
-  /// Access to content array
-  FXObject** data() const { return ptr; }
-
-  /// Assign object p to list
-  FXObjectList& assign(FXObject* object);
-
-  /// Assign n objects to list
-  FXObjectList& assign(FXObject** objects,FXint n);
-
-  /// Assign objects to list
-  FXObjectList& assign(FXObjectList& objects);
-
-  /// Insert object at certain position
-  FXObjectList& insert(FXint pos,FXObject* object);
-
-  /// Insert n objects at specified position
-  FXObjectList& insert(FXint pos,FXObject** objects,FXint n);
-
-  /// Insert objects at specified position
-  FXObjectList& insert(FXint pos,FXObjectList& objects);
-
-  /// Prepend object
-  FXObjectList& prepend(FXObject* object);
-
-  /// Prepend n objects
-  FXObjectList& prepend(FXObject** objects,FXint n);
-
-  /// Prepend objects
-  FXObjectList& prepend(FXObjectList& objects);
-
-  /// Append object
-  FXObjectList& append(FXObject* object);
-
-  /// Append n objects
-  FXObjectList& append(FXObject** objects,FXint n);
-
-  /// Append objects
-  FXObjectList& append(FXObjectList& objects);
-
-  /// Replace object at position by given object
-  FXObjectList& replace(FXint pos,FXObject* object);
-
-  /// Replaces the m objects at pos with n objects
-  FXObjectList& replace(FXint pos,FXint m,FXObject** objects,FXint n);
-
-  /// Replace the m objects at pos with objects
-  FXObjectList& replace(FXint pos,FXint m,FXObjectList& objects);
-
-  /// Remove object at pos
-  FXObjectList& erase(FXint pos);
-
-  /// Remove n objects at pos
-  FXObjectList& erase(FXint pos,FXint n);
-
-  /// Remove object
-  FXObjectList& remove(const FXObject* object);
-
-  /// Find object in list, searching forward; return position or -1
-  FXint find(const FXObject *object,FXint pos=0) const;
-
-  /// Find object in list, searching backward; return position or -1
-  FXint rfind(const FXObject *object,FXint pos=2147483647) const;
-
-  /// Remove all objects
-  FXObjectList& clear();
-
-  /// Save to a stream
-  void save(FXStream& store) const;
-
-  /// Load from a stream
-  void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXObjectList();
-  };
-
-
-/// Specialize list to pointers to TYPE
-template<class TYPE>
-class FXAPI FXObjectListOf : public FXObjectList {
-public:
-  FXObjectListOf(){}
-
-  /// Indexing operator
-  TYPE*& operator[](FXint i){ return (TYPE*&)ptr[i]; }
-  TYPE *const& operator[](FXint i) const { return (TYPE*const&)ptr[i]; }
-
-  /// Access to list
-  TYPE*& at(FXint i){ return (TYPE*&)ptr[i]; }
-  TYPE *const& at(FXint i) const { return (TYPE*const&)ptr[i]; }
-
-  /// Access to content array
-  TYPE** data() const { return (TYPE**)ptr; }
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXOptionMenu.h b/fox-includes/FXOptionMenu.h
deleted file mode 100755
index 4d671bc7..00000000
--- a/fox-includes/FXOptionMenu.h
+++ /dev/null
@@ -1,192 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                             O p t i o n   M e n u                             *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXOptionMenu.h 2344 2006-02-12 21:19:36Z lyle $                      *
-********************************************************************************/
-#ifndef FXOPTIONMENU_H
-#define FXOPTIONMENU_H
-
-#ifndef FXLABEL_H
-#include "FXLabel.h"
-#endif
-
-namespace FX {
-
-
-class FXPopup;
-
-
-/// Option Menu Button
-class FXAPI FXOption : public FXLabel {
-  FXDECLARE(FXOption)
-protected:
-  FXColor selbackColor;
-  FXColor seltextColor;
-protected:
-  FXOption();
-private:
-  FXOption(const FXOption&);
-  FXOption &operator=(const FXOption&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onEnter(FXObject*,FXSelector,void*);
-  long onLeave(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onHotKeyPress(FXObject*,FXSelector,void*);
-  long onHotKeyRelease(FXObject*,FXSelector,void*);
-public:
-
-  /// Constructor
-  FXOption(FXComposite* p,const FXString& text,FXIcon* ic=NULL,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=JUSTIFY_NORMAL|ICON_BEFORE_TEXT,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Returns true because a menu button can receive focus
-  virtual bool canFocus() const;
-
-  /// Set focus to this window
-  virtual void setFocus();
-
-  /// Remove the focus from this window
-  virtual void killFocus();
-
-  /// Return the selection background color
-  void setSelBackColor(FXColor clr);
-
-  /// Return the selection background color
-  FXColor getSelBackColor() const { return selbackColor; }
-
-  /// Return the selection text color
-  void setSelTextColor(FXColor clr);
-
-  /// Return the selection text color
-  FXColor getSelTextColor() const { return seltextColor; }
-
-  /// Destructor
-  virtual ~FXOption();
-  };
-
-
-
-/// Option Menu
-class FXAPI FXOptionMenu : public FXLabel {
-  FXDECLARE(FXOptionMenu)
-protected:
-  FXPopup  *pane;
-  FXOption *current;
-protected:
-  FXOptionMenu(){}
-private:
-  FXOptionMenu(const FXOptionMenu&);
-  FXOptionMenu &operator=(const FXOptionMenu&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onFocusIn(FXObject*,FXSelector,void*);
-  long onFocusOut(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onCmdPost(FXObject*,FXSelector,void*);
-  long onCmdUnpost(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-  long onMouseWheel(FXObject*,FXSelector,void*);
-public:
-
-  /// Constructor
-  FXOptionMenu(FXComposite* p,FXPopup* pup=NULL,FXuint opts=JUSTIFY_NORMAL|ICON_BEFORE_TEXT,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Delete server-side resources
-  virtual void destroy();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Remove the focus from this window
-  virtual void killFocus();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Return TRUE if the position is logically in the pane
-  virtual bool contains(FXint parentx,FXint parenty) const;
-
-  /// Set the current option
-  void setCurrent(FXOption *win,FXbool notify=FALSE);
-
-  /// Return the current option
-  FXOption* getCurrent() const { return current; }
-
-  /// Set the current option number
-  void setCurrentNo(FXint no,FXbool notify=FALSE);
-
-  /// Get the current option number
-  FXint getCurrentNo() const;
-
-  /// Get number of options
-  FXint getNumOptions() const;
-
-  /// Set the pane which will be popped up
-  void setMenu(FXPopup *pup);
-
-  /// Return the pane which is poppup up
-  FXPopup* getMenu() const { return pane; }
-
-  /// Returns true because a option menu can receive focus
-  virtual bool canFocus() const;
-
-  /// Return TRUE if popped up
-  FXbool isPopped() const;
-
-  /// Save option menu to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load option menu from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXOptionMenu();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXPCXIcon.h b/fox-includes/FXPCXIcon.h
deleted file mode 100755
index 601d9e58..00000000
--- a/fox-includes/FXPCXIcon.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        P C X   I c o n   O b j e c t                          *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2001,2006 by Janusz Ganczarski.   All Rights Reserved.          *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXPCXIcon.h 2343 2006-02-12 20:26:26Z lyle $                         *
-********************************************************************************/
-#ifndef FXPCXICON_H
-#define FXPCXICON_H
-
-#ifndef FXICON_H
-#include "FXIcon.h"
-#endif
-
-namespace FX {
-
-/// PCX icon
-class FXAPI FXPCXIcon : public FXIcon {
-  FXDECLARE(FXPCXIcon)
-protected:
-  FXPCXIcon(){}
-private:
-  FXPCXIcon(const FXPCXIcon&);
-  FXPCXIcon &operator=(const FXPCXIcon&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct icon from memory stream formatted in PCX file format
-  FXPCXIcon(FXApp* a,const void *pix=NULL,FXColor clr=FXRGB(192,192,192),FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Save pixels into stream in PCX file format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in PCX file format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy icon
-  virtual ~FXPCXIcon();
-  };
-
-
-/**
-* Check if stream contains a PCX, return TRUE if so.
-*/
-extern FXAPI bool fxcheckPCX(FXStream& store);
-
-
-/**
-* Load an PCX (PC Paintbrush) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadPCX(FXStream& store,FXColor*& data,FXint& width,FXint& height);
-
-
-/**
-* Save an PCX (PC Paintbrush) file to a stream.
-*/
-extern FXAPI bool fxsavePCX(FXStream& store,const FXColor *data,FXint width,FXint height);
-
-}
-
-#endif
diff --git a/fox-includes/FXPCXImage.h b/fox-includes/FXPCXImage.h
deleted file mode 100755
index 0960c7ca..00000000
--- a/fox-includes/FXPCXImage.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                            P C X   I m a g e   O b j e c t                    *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2001,2006 by Janusz Ganczarski.   All Rights Reserved.          *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXPCXImage.h 2343 2006-02-12 20:26:26Z lyle $                        *
-********************************************************************************/
-#ifndef FXPCXIMAGE_H
-#define FXPCXIMAGE_H
-
-#ifndef FXIMAGE_H
-#include "FXImage.h"
-#endif
-
-namespace FX {
-
-///  PCX graphics file
-class FXAPI FXPCXImage : public FXImage {
-  FXDECLARE(FXPCXImage)
-protected:
-  FXPCXImage(){}
-private:
-  FXPCXImage(const FXPCXImage&);
-  FXPCXImage &operator=(const FXPCXImage&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct image from memory stream formatted in PCX file
-  FXPCXImage(FXApp* a,const void *pix=NULL,FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Save pixels into stream in PCX file
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in  bitmap format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy icon
-  virtual ~FXPCXImage();
-  };
-
-
-/**
-* Check if stream contains a PCX, return TRUE if so.
-*/
-extern FXAPI bool fxcheckPCX(FXStream& store);
-
-
-/**
-* Load an PCX (PC Paintbrush) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadPCX(FXStream& store,FXColor*& data,FXint& width,FXint& height);
-
-
-/**
-* Save an PCX (PC Paintbrush) file to a stream.
-*/
-extern FXAPI bool fxsavePCX(FXStream& store,const FXColor *data,FXint width,FXint height);
-
-}
-
-#endif
diff --git a/fox-includes/FXPNGIcon.h b/fox-includes/FXPNGIcon.h
deleted file mode 100755
index b07cfc24..00000000
--- a/fox-includes/FXPNGIcon.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                          P N G   I m a g e   O b j e c t                      *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1999,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXPNGIcon.h 2343 2006-02-12 20:26:26Z lyle $                         *
-********************************************************************************/
-#ifndef FXPNGICON_H
-#define FXPNGICON_H
-
-#ifndef FXICON_H
-#include "FXIcon.h"
-#endif
-
-namespace FX {
-
-
-/// Portable Network Graphics (PNG) Icon class
-class FXAPI FXPNGIcon : public FXIcon {
-  FXDECLARE(FXPNGIcon)
-protected:
-  FXPNGIcon(){}
-private:
-  FXPNGIcon(const FXPNGIcon&);
-  FXPNGIcon &operator=(const FXPNGIcon&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct an icon from memory stream formatted in PNG format
-  FXPNGIcon(FXApp *a,const void *pix=NULL,FXColor clr=FXRGB(192,192,192),FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// True if format is supported
-  static const bool supported;
-
-  /// Save pixels into stream in PNG format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in PNG format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy
-  virtual ~FXPNGIcon();
-  };
-
-
-/**
-* Check if stream contains a PNG, return TRUE if so.
-*/
-extern FXAPI bool fxcheckPNG(FXStream& store);
-
-
-/**
-* Load an PNG (Portable Network Graphics) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadPNG(FXStream& store,FXColor*& data,FXint& width,FXint& height);
-
-
-/**
-* Save an PNG (Portable Network Graphics) file to a stream.
-*/
-extern FXAPI bool fxsavePNG(FXStream& store,const FXColor* data,FXint width,FXint height);
-
-}
-
-#endif
diff --git a/fox-includes/FXPNGImage.h b/fox-includes/FXPNGImage.h
deleted file mode 100755
index d17a714c..00000000
--- a/fox-includes/FXPNGImage.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                          P N G   I m a g e   O b j e c t                      *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1999,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXPNGImage.h 2343 2006-02-12 20:26:26Z lyle $                        *
-********************************************************************************/
-#ifndef FXPNGIMAGE_H
-#define FXPNGIMAGE_H
-
-#ifndef FXIMAGE_H
-#include "FXImage.h"
-#endif
-
-namespace FX {
-
-
-/// Portable Network Graphics (PNG) Image class
-class FXAPI FXPNGImage : public FXImage {
-  FXDECLARE(FXPNGImage)
-protected:
-  FXPNGImage(){}
-private:
-  FXPNGImage(const FXPNGImage&);
-  FXPNGImage &operator=(const FXPNGImage&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct an image from memory stream formatted in PNG format
-  FXPNGImage(FXApp *a,const void *pix=NULL,FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// True if format is supported
-  static const bool supported;
-
-  /// Save pixels into stream in PNG format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Load pixels from stream in PNG format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Destroy
-  virtual ~FXPNGImage();
-  };
-
-
-/**
-* Check if stream contains a PNG, return TRUE if so.
-*/
-extern FXAPI bool fxcheckPNG(FXStream& store);
-
-
-/**
-* Load an PNG (Portable Network Graphics) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadPNG(FXStream& store,FXColor*& data,FXint& width,FXint& height);
-
-
-/**
-* Save an PNG (Portable Network Graphics) file to a stream.
-*/
-extern FXAPI bool fxsavePNG(FXStream& store,const FXColor* data,FXint width,FXint height);
-
-}
-
-#endif
diff --git a/fox-includes/FXPPMIcon.h b/fox-includes/FXPPMIcon.h
deleted file mode 100755
index e2d6a735..00000000
--- a/fox-includes/FXPPMIcon.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        P P M   I c o n   O b j e c t                          *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2003,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXPPMIcon.h 2343 2006-02-12 20:26:26Z lyle $                          *
-********************************************************************************/
-#ifndef FXPPMICON_H
-#define FXPPMICON_H
-
-#ifndef FXICON_H
-#include "FXIcon.h"
-#endif
-
-namespace FX {
-
-
-/// Portable Pixmap icon
-class FXAPI FXPPMIcon : public FXIcon {
-  FXDECLARE(FXPPMIcon)
-protected:
-  FXPPMIcon(){}
-private:
-  FXPPMIcon(const FXPPMIcon&);
-  FXPPMIcon &operator=(const FXPPMIcon&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct icon from memory stream formatted in Portable Pixmap format
-  FXPPMIcon(FXApp* a,const void *pix=NULL,FXColor clr=FXRGB(192,192,192),FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Save pixels into stream in Portable Pixmap format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in Portable Pixmap format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy icon
-  virtual ~FXPPMIcon();
-  };
-
-
-/**
-* Check if stream contains a PPM, return TRUE if so.
-*/
-extern FXAPI bool fxcheckPPM(FXStream& store);
-
-
-/**
-* Load an PPM (Portable Pixmap Format) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadPPM(FXStream& store,FXColor*& data,FXint& width,FXint& height);
-
-
-/**
-* Save an PPM (Portable Pixmap Format) file to a stream.
-*/
-extern FXAPI bool fxsavePPM(FXStream& store,const FXColor *data,FXint width,FXint height);
-
-}
-
-#endif
diff --git a/fox-includes/FXPPMImage.h b/fox-includes/FXPPMImage.h
deleted file mode 100755
index cc51ec52..00000000
--- a/fox-includes/FXPPMImage.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                            P P M   I m a g e   O b j e c t                    *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2003,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXPPMImage.h 2343 2006-02-12 20:26:26Z lyle $                         *
-********************************************************************************/
-#ifndef FXPPMIMAGE_H
-#define FXPPMIMAGE_H
-
-#ifndef FXIMAGE_H
-#include "FXImage.h"
-#endif
-
-namespace FX {
-
-
-/// Portable Pixmap Image
-class FXAPI FXPPMImage : public FXImage {
-  FXDECLARE(FXPPMImage)
-protected:
-  FXPPMImage(){}
-private:
-  FXPPMImage(const FXPPMImage&);
-  FXPPMImage &operator=(const FXPPMImage&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct icon from memory stream formatted in Portable Pixmap format
-  FXPPMImage(FXApp* a,const void *pix=NULL,FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Save pixels into stream in Portable Pixmap format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in Portable Pixmap format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy icon
-  virtual ~FXPPMImage();
-  };
-
-
-/**
-* Check if stream contains a PPM, return TRUE if so.
-*/
-extern FXAPI bool fxcheckPPM(FXStream& store);
-
-
-/**
-* Load an PPM (Portable Pixmap Format) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadPPM(FXStream& store,FXColor*& data,FXint& width,FXint& height);
-
-
-/**
-* Save an PPM (Portable Pixmap Format) file to a stream.
-*/
-extern FXAPI bool fxsavePPM(FXStream& store,const FXColor *data,FXint width,FXint height);
-
-}
-
-#endif
diff --git a/fox-includes/FXPacker.h b/fox-includes/FXPacker.h
deleted file mode 100755
index c080ccb0..00000000
--- a/fox-includes/FXPacker.h
+++ /dev/null
@@ -1,183 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                P a c k e r   C o n t a i n e r   W i d g e t                  *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2003 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXPacker.h 1536 2003-05-14 21:41:00Z lyle $                          *
-********************************************************************************/
-#ifndef FXPACKER_H
-#define FXPACKER_H
-
-#ifndef FXCOMPOSITE_H
-#include "FXComposite.h"
-#endif
-
-namespace FX {
-
-
-/// Default spacing
-enum { DEFAULT_SPACING = 4 };
-
-
-/**
-* Packer is a layout manager which automatically places child windows
-* inside its area against the left, right, top, or bottom side.
-* Each time a child is placed, the remaining space is decreased by the
-* amount of space taken by the child window.
-* The side against which a child is placed is determined by the LAYOUT_SIDE_TOP,
-* LAYOUT_SIDE_BOTTOM, LAYOUT_SIDE_LEFT, and LAYOUT_SIDE_RIGHT hints given by
-* the child window.  Other layout hints from the child are observed as far as
-* sensible.  So for example, a child placed against the right edge can still
-* have LAYOUT_FILL_Y or LAYOUT_TOP, and so on.
-* The last child may have both LAYOUT_FILL_X and LAYOUT_FILL_Y, in which
-* case it will be placed to take all remaining space.
-*/
-class FXAPI FXPacker : public FXComposite {
-  FXDECLARE(FXPacker)
-protected:
-  FXColor baseColor;        // Base color
-  FXColor hiliteColor;      // Highlight color
-  FXColor shadowColor;      // Shadow color
-  FXColor borderColor;      // Border color
-  FXint   padtop;           // Top margin
-  FXint   padbottom;        // Bottom margin
-  FXint   padleft;          // Left margin
-  FXint   padright;         // Right margin
-  FXint   hspacing;         // Horizontal child spacing
-  FXint   vspacing;         // Vertical child spacing
-  FXint   border;           // Border width
-protected:
-  FXPacker();
-  void drawBorderRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawRaisedRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawSunkenRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawRidgeRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawGrooveRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawDoubleRaisedRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawDoubleSunkenRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawFocusRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawFrame(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-private:
-  FXPacker(const FXPacker&);
-  FXPacker &operator=(const FXPacker&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onFocusUp(FXObject*,FXSelector,void*);
-  long onFocusDown(FXObject*,FXSelector,void*);
-  long onFocusLeft(FXObject*,FXSelector,void*);
-  long onFocusRight(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct packer layout manager
-  FXPacker(FXComposite *p,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_SPACING,FXint pr=DEFAULT_SPACING,FXint pt=DEFAULT_SPACING,FXint pb=DEFAULT_SPACING,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING);
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Change frame style
-  void setFrameStyle(FXuint style);
-
-  /// Get current frame style
-  FXuint getFrameStyle() const;
-
-  /// Change packing hints
-  void setPackingHints(FXuint ph);
-
-  /// Return packing hints
-  FXuint getPackingHints() const;
-
-  /// Get border width
-  FXint getBorderWidth() const { return border; }
-
-  /// Change top padding
-  void setPadTop(FXint pt);
-
-  /// Get top interior padding
-  FXint getPadTop() const { return padtop; }
-
-  /// Change bottom padding
-  void setPadBottom(FXint pb);
-
-  /// Get bottom interior padding
-  FXint getPadBottom() const { return padbottom; }
-
-  /// Change left padding
-  void setPadLeft(FXint pl);
-
-  /// Get left interior padding
-  FXint getPadLeft() const { return padleft; }
-
-  /// Change right padding
-  void setPadRight(FXint pr);
-
-  /// Get right interior padding
-  FXint getPadRight() const { return padright; }
-
-  /// Change highlight color
-  void setHiliteColor(FXColor clr);
-
-  /// Get highlight color
-  FXColor getHiliteColor() const { return hiliteColor; }
-
-  /// Change shadow color
-  void setShadowColor(FXColor clr);
-
-  /// Get shadow color
-  FXColor getShadowColor() const { return shadowColor; }
-
-  /// Change border color
-  void setBorderColor(FXColor clr);
-
-  /// Get border color
-  FXColor getBorderColor() const { return borderColor; }
-
-  /// Change base gui color
-  void setBaseColor(FXColor clr);
-
-  /// Get base gui color
-  FXColor getBaseColor() const { return baseColor; }
-
-  /// Change horizontal inter-child spacing
-  void setHSpacing(FXint hs);
-
-  /// Return current horizontal inter-child spacing
-  FXint getHSpacing() const { return hspacing; }
-
-  /// Change vertical inter-child spacing
-  void setVSpacing(FXint vs);
-
-  /// Return current vertical inter-child spacing
-  FXint getVSpacing() const { return vspacing; }
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXPath.h b/fox-includes/FXPath.h
deleted file mode 100644
index 409b7ae7..00000000
--- a/fox-includes/FXPath.h
+++ /dev/null
@@ -1,158 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                  P a t h   N a m e   M a n i p u l a t i o n                  *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2000,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXPath.h 2291 2005-12-05 03:37:36Z lyle $                             *
-********************************************************************************/
-#ifndef FXPATH_H
-#define FXPATH_H
-
-
-namespace FX {
-
-
-namespace FXPath {
-
-  /**
-  * Return root of absolute path; on Unix, this is just "/". On
-  * Windows, this is "\\" or "C:\".  Returns the empty string
-  * if the given path is not absolute.
-  */
-  FXString FXAPI root(const FXString& file);
-
-  /**
-  * Return the directory part of the path name.
-  * Note that directory("/bla/bla/") is "/bla/bla" and NOT "/bla".
-  * However, directory("/bla/bla") is "/bla" as we expect!
-  */
-  FXString FXAPI directory(const FXString& file);
-
-  /**
-  * Return name and extension part of the path name.
-  * Note that name("/bla/bla/") is "" and NOT "bla".
-  * However, name("/bla/bla") is "bla" as we expect!
-  */
-  FXString FXAPI name(const FXString& file);
-
-  /// Return file title, i.e. document name only
-  FXString FXAPI title(const FXString& file);
-
-  /// Return extension part of the file name
-  FXString FXAPI extension(const FXString& file);
-
-  /// Return file name less the extension
-  FXString FXAPI stripExtension(const FXString& file);
-
-  /// Return the drive letter prefixing this file name (if any).
-  FXString FXAPI drive(const FXString& file);
-
-  /// Perform tilde or environment variable expansion
-  FXString FXAPI expand(const FXString& file);
-
-  /// Contract path based on user name and environment variable
-  FXString FXAPI contract(const FXString& file,const FXString& user=FXString::null,const FXString& var=FXString::null);
-
-  /**
-  * Simplify a file path; the path will remain relative if it was relative,
-  * or absolute if it was absolute.  Also, a trailing "/" will be preserved
-  * as this is important in other functions.
-  * For example, simplify("..//aaa/./bbb//../c/") becomes "../aaa/c/".
-  */
-  FXString FXAPI simplify(const FXString& file);
-
-  /// Return absolute path from current directory and file name
-  FXString FXAPI absolute(const FXString& file);
-
-  /// Return absolute path from base directory and file name
-  FXString FXAPI absolute(const FXString& base,const FXString& file);
-
-  /// Return relative path of file to the current directory
-  FXString FXAPI relative(const FXString& file);
-
-  /// Return relative path of file to given base directory
-  FXString FXAPI relative(const FXString& base,const FXString& file);
-
-  /// Return path following local path separator conventions
-  FXString FXAPI convert(const FXString& path);
-
-  /// Return path to directory above input directory name
-  FXString FXAPI upLevel(const FXString& file);
-
-  /// Return true if file name is absolute
-  bool FXAPI isAbsolute(const FXString& file);
-
-  /// Return true if input directory is a top-level directory
-  bool FXAPI isTopDirectory(const FXString& file);
-
-  /// Return true if input path is a file share
-  bool FXAPI isShare(const FXString& file);
-
-  /// Enquote filename to make safe for shell
-  FXString FXAPI enquote(const FXString& file,bool forcequotes=false);
-
-  /// Dequote filename to get original again
-  FXString FXAPI dequote(const FXString& file);
-
-  /**
-  * Perform wildcard match of a filename against a wildcard pattern.
-  * The wildcard pattern may comprise ordinary characters or special
-  * matching characters, as given below:
-  *
-  *  ?           Any single character.
-  *  *           Zero or more of any character.
-  *  [abc]       Any character from the set {a,b,c}.
-  *  [^abc]      Any character BUT the ones from the set {a,b,c}.
-  *  [!abc]      Ditto.
-  *  [a-zA-Z]    Matches single character, which must be one of a-z or A-Z.
-  *  [^a-zA-Z]   Matches single character, which must be anything other than a-z or A-Z.
-  *  [!a-zA-Z]   Ditto.
-  *  pat1|pat2   Match sub-pattern pat1 or pat2.
-  *  pat1,pat2   Ditto.
-  *  (pat1|pat2) Match sub-pattern pat1 or pat2; patterns may be nested.
-  *  (pat1,pat2) Ditto.
-  *
-  * The special characters may be escaped to treat them as ordinary characters.
-  * Matching may be influenced by a number of flags:
-  *
-  *  FILEMATCH_FILE_NAME         No wildcard can ever match /
-  *  FILEMATCH_NOESCAPE          Backslashes don't quote special chars
-  *  FILEMATCH_PERIOD            Leading . is matched only explicitly
-  *  FILEMATCH_LEADING_DIR       Ignore /... after a match
-  *  FILEMATCH_CASEFOLD          Compare without regard to case
-  */
-  bool FXAPI match(const FXString& pattern,const FXString& file,FXuint flags=(FILEMATCH_NOESCAPE|FILEMATCH_FILE_NAME));
-
-  /**
-  * Generate unique filename of the form pathnameXXX.ext, where
-  * pathname.ext is the original input file, and XXX is a number,
-  * possibly empty, that makes the file unique.
-  */
-  FXString FXAPI unique(const FXString& file);
-
-  /**
-  * Search path list for this file, return full path name for first occurrence.
-  */
-  FXString FXAPI search(const FXString& pathlist,const FXString& file);
-
-  }
-
-}
-
-#endif
diff --git a/fox-includes/FXPicker.h b/fox-includes/FXPicker.h
deleted file mode 100755
index 2c83a0ff..00000000
--- a/fox-includes/FXPicker.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                          P i c k e r   B u t t o n                            *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2001,2002 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXPicker.h 809 2002-07-11 17:28:15Z lyle $                           *
-********************************************************************************/
-#ifndef FXPICKER_H
-#define FXPICKER_H
-
-#ifndef FXBUTTON_H
-#include "FXButton.h"
-#endif
-
-namespace FX {
-
-
-/**
-* A picker button allows you to identify an arbitrary
-* location on the screen.
-*/
-class FXAPI FXPicker : public FXButton {
-  FXDECLARE(FXPicker)
-protected:
-  FXPicker(){}
-private:
-  FXPicker(const FXPicker&);
-  FXPicker& operator=(const FXPicker&);
-public:
-  long onMotion(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onEnter(FXObject*,FXSelector,void*);
-  long onLeave(FXObject*,FXSelector,void*);
-public:
-  FXPicker(FXComposite* p,const FXString& text,FXIcon* ic=NULL,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=BUTTON_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXPipe.h b/fox-includes/FXPipe.h
deleted file mode 100644
index 55feed64..00000000
--- a/fox-includes/FXPipe.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                             P i p e   C l a s s                               *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2005,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXPipe.h 2343 2006-02-12 20:26:26Z lyle $                             *
-********************************************************************************/
-#ifndef FXPIPE_H
-#define FXFILE_H
-
-#ifndef FXIO_H
-#include "FXIO.h"
-#endif
-
-
-////////////////////////////  UNDER DEVELOPMENT  ////////////////////////////////
-
-
-namespace FX {
-
-
-/**
-* Pipe i/o device.
-*/
-class FXAPI FXPipe : public FXIO {
-private:
-  FXPipe(const FXPipe&);
-  FXPipe &operator=(const FXPipe&);
-public:
-
-  /// Construct socket
-  FXPipe(){ }
-
-  /// Construct file and attach existing handle h
-  FXPipe(FXInputHandle handle,FXuint mode);
-
-  /// Open device with access mode and handle
-  virtual bool open(FXInputHandle handle,FXuint mode);
-
-  /// Read block of bytes, returning number of bytes read
-  virtual FXival readBlock(void* data,FXival count);
-
-  /// Write block of bytes, returning number of bytes written
-  virtual FXival writeBlock(const void* data,FXival count);
-
-  /// Close socket
-  virtual bool close();
-
-  /// Create a named pipe
-  static bool create(const FXString& file,FXuint perm=FXIO::OwnerReadWrite|FXIO::GroupReadWrite|FXIO::OtherReadWrite);
-
-  /// Destroy
-  virtual ~FXPipe();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXPoint.h b/fox-includes/FXPoint.h
deleted file mode 100755
index 4dd50109..00000000
--- a/fox-includes/FXPoint.h
+++ /dev/null
@@ -1,100 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                             P o i n t    C l a s s                            *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1994,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXPoint.h 2344 2006-02-12 21:19:36Z lyle $                           *
-********************************************************************************/
-#ifndef FXPOINT_H
-#define FXPOINT_H
-
-#ifndef FXSIZE_H
-#include "FXSize.h"
-#endif
-
-namespace FX {
-
-
-/// Point
-class FXAPI FXPoint {
-public:
-  FXshort x;
-  FXshort y;
-public:
-
-  /// Constructors
-  FXPoint(){ }
-  FXPoint(const FXSize& s):x(s.w),y(s.h){ }
-  FXPoint(const FXPoint& p):x(p.x),y(p.y){ }
-  FXPoint(FXshort xx,FXshort yy):x(xx),y(yy){ }
-
-  /// Test if zero
-  bool operator!() const { return x==0 && y==0; }
-
-  /// Equality
-  bool operator==(const FXPoint& p) const { return x==p.x && y==p.y; }
-  bool operator!=(const FXPoint& p) const { return x!=p.x || y!=p.y; }
-
-  /// Assignment
-  FXPoint& operator=(const FXPoint& p){ x=p.x; y=p.y; return *this; }
-
-  /// Set value from another point
-  FXPoint& set(const FXPoint& p){ x=p.x; y=p.y; return *this; }
-
-  /// Set value from components
-  FXPoint& set(FXshort xx,FXshort yy){ x=xx; y=yy; return *this; }
-
-  /// Assignment operators
-  FXPoint& operator+=(const FXPoint& p){ x+=p.x; y+=p.y; return *this; }
-  FXPoint& operator-=(const FXPoint& p){ x-=p.x; y-=p.y; return *this; }
-  FXPoint& operator*=(FXshort c){ x*=c; y*=c; return *this; }
-  FXPoint& operator/=(FXshort c){ x/=c; y/=c; return *this; }
-
-  /// Negation
-  FXPoint operator-(){ return FXPoint(-x,-y); }
-
-  /// Addition operators
-  FXPoint operator+(const FXPoint& p) const { return FXPoint(x+p.x,y+p.y); }
-  FXPoint operator-(const FXPoint& p) const { return FXPoint(x-p.x,y-p.y); }
-
-  /// Scale operators
-  friend inline FXPoint operator*(const FXPoint& p,FXshort c);
-  friend inline FXPoint operator*(FXshort c,const FXPoint& p);
-  friend inline FXPoint operator/(const FXPoint& p,FXshort c);
-  friend inline FXPoint operator/(FXshort c,const FXPoint& p);
-
-  /// Save object to a stream
-  friend FXAPI FXStream& operator<<(FXStream& store,const FXPoint& p);
-
-  /// Load object from a stream
-  friend FXAPI FXStream& operator>>(FXStream& store,FXPoint& p);
-  };
-
-
-inline FXPoint operator*(const FXPoint& p,FXshort c){ return FXPoint(p.x*c,p.y*c); }
-inline FXPoint operator*(FXshort c,const FXPoint& p){ return FXPoint(c*p.x,c*p.y); }
-inline FXPoint operator/(const FXPoint& p,FXshort c){ return FXPoint(p.x/c,p.y/c); }
-inline FXPoint operator/(FXshort c,const FXPoint& p){ return FXPoint(c/p.x,c/p.y); }
-
-extern FXAPI FXStream& operator<<(FXStream& store,const FXPoint& p);
-extern FXAPI FXStream& operator>>(FXStream& store,FXPoint& p);
-
-}
-
-#endif
diff --git a/fox-includes/FXPopup.h b/fox-includes/FXPopup.h
deleted file mode 100755
index ab8f5a50..00000000
--- a/fox-includes/FXPopup.h
+++ /dev/null
@@ -1,197 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                     P o p u p   W i n d o w   W i d g e t                     *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXPopup.h 2344 2006-02-12 21:19:36Z lyle $                           *
-********************************************************************************/
-#ifndef FXPOPUP_H
-#define FXPOPUP_H
-
-#ifndef FXSHELL_H
-#include "FXShell.h"
-#endif
-
-namespace FX {
-
-
-/// Popup internal orientation
-enum {
-  POPUP_VERTICAL   = 0,               /// Vertical orientation
-  POPUP_HORIZONTAL = 0x00020000,      /// Horizontal orientation
-  POPUP_SHRINKWRAP = 0x00040000       /// Shrinkwrap to content
-  };
-
-
-
-/// Popup window
-class FXAPI FXPopup : public FXShell {
-  FXDECLARE(FXPopup)
-private:
-  FXPopup  *prevActive;         // Popup below this one in stack
-  FXPopup  *nextActive;         // Popup above this one in stack
-protected:
-  FXWindow *grabowner;          // Window which will get grabbed when outside
-  FXColor   baseColor;
-  FXColor   hiliteColor;
-  FXColor   shadowColor;
-  FXColor   borderColor;
-  FXint     border;
-protected:
-  FXPopup();
-  virtual bool doesOverrideRedirect() const;
-  void drawBorderRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawRaisedRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawSunkenRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawRidgeRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawGrooveRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawDoubleRaisedRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawDoubleSunkenRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawFrame(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-private:
-  FXPopup(const FXPopup&);
-  FXPopup &operator=(const FXPopup&);
-#ifdef WIN32
-  virtual const char* GetClass() const;
-#endif
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onFocusUp(FXObject*,FXSelector,void*);
-  long onFocusDown(FXObject*,FXSelector,void*);
-  long onFocusLeft(FXObject*,FXSelector,void*);
-  long onFocusRight(FXObject*,FXSelector,void*);
-  long onFocusNext(FXObject*,FXSelector,void*);
-  long onFocusPrev(FXObject*,FXSelector,void*);
-  long onEnter(FXObject*,FXSelector,void*);
-  long onLeave(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onMap(FXObject*,FXSelector,void*);
-  long onButtonPress(FXObject*,FXSelector,void*);
-  long onButtonRelease(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onCmdUnpost(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onCmdChoice(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_CHOICE=FXShell::ID_LAST,
-    ID_LAST=ID_CHOICE+1000
-    };
-public:
-
-  /// Construct popup pane
-  FXPopup(FXWindow* owner,FXuint opts=POPUP_VERTICAL|FRAME_RAISED|FRAME_THICK,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Return the default width of this window
-  virtual FXint getDefaultWidth();
-
-  /// Return the default height of this window
-  virtual FXint getDefaultHeight();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return a pointer to the prior active popup
-  FXPopup* getPrevActive() const { return prevActive; }
-
-  /// Return a pointer to the next active popup
-  FXPopup* getNextActive() const { return nextActive; }
-
-  /// Move the focus to this window
-  virtual void setFocus();
-
-  /// Remove the focus from this window
-  virtual void killFocus();
-
-  /// Show this window
-  virtual void show();
-
-  /// Hide this window
-  virtual void hide();
-
-  /// Change frame style
-  void setFrameStyle(FXuint style);
-
-  /// Return frame style
-  FXuint getFrameStyle() const;
-
-  /// Return border width
-  FXint getBorderWidth() const { return border; }
-
-  /// Change highlight color
-  void setHiliteColor(FXColor clr);
-
-  /// Return highlight color
-  FXColor getHiliteColor() const { return hiliteColor; }
-
-  /// Change shadow color
-  void setShadowColor(FXColor clr);
-
-  /// Return shadow color
-  FXColor getShadowColor() const { return shadowColor; }
-
-  /// Change border color
-  void setBorderColor(FXColor clr);
-
-  /// Return border color
-  FXColor getBorderColor() const { return borderColor; }
-
-  /// Change base color
-  void setBaseColor(FXColor clr);
-
-  /// Return base color
-  FXColor getBaseColor() const { return baseColor; }
-
-  /// Popup the menu and grab to the given owner
-  virtual void popup(FXWindow* grabto,FXint x,FXint y,FXint w=0,FXint h=0);
-
-  /// Pop down the menu
-  virtual void popdown();
-
-  /// Return current grab owner
-  FXWindow* getGrabOwner() const;
-
-//   /// Popup the menu and grab to the given owner
-//   virtual FXint popup(FXint x,FXint y,FXint w=0,FXint h=0);
-//
-//   /// Pop down the menu
-//   virtual void popdown(FXint value);
-
-  /// Return popup orientation
-  FXuint getOrientation() const;
-
-  /// Change popup orientation
-  void setOrientation(FXuint orient);
-
-  /// Return shrinkwrap mode
-  FXbool getShrinkWrap() const;
-
-  /// Change shrinkwrap mode
-  void setShrinkWrap(FXbool sw);
-
-  virtual bool doesSaveUnder() const;
-
-  /// Destructor
-  virtual ~FXPopup();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXPrintDialog.h b/fox-includes/FXPrintDialog.h
deleted file mode 100755
index ba2d8438..00000000
--- a/fox-includes/FXPrintDialog.h
+++ /dev/null
@@ -1,157 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        P r i n t   J o b   D i a l o g                        *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1999,2002 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXPrintDialog.h 809 2002-07-11 17:28:15Z lyle $                     *
-********************************************************************************/
-#ifndef FXPRINTDIALOG_H
-#define FXPRINTDIALOG_H
-
-#ifndef FXDIALOGBOX_H
-#include "FXDialogBox.h"
-#endif
-
-namespace FX {
-
-
-class FXRadioButton;
-class FXComboBox;
-class FXListBox;
-class FXTextField;
-class FXSpinner;
-class FXIcon;
-
-
-/// Printer selection dialog
-class FXAPI FXPrintDialog : public FXDialogBox {
-  FXDECLARE(FXPrintDialog)
-protected:
-  FXRadioButton *sendtoprinter;
-  FXComboBox    *printername;
-  FXRadioButton *sendtofile;
-  FXTextField   *filename;
-  FXRadioButton *printall;
-  FXRadioButton *printeven;
-  FXRadioButton *printodd;
-  FXRadioButton *printrange;
-  FXRadioButton *firstpagefirst;
-  FXRadioButton *lastpagefirst;
-  FXRadioButton *printincolor;
-  FXRadioButton *printinblacknwhite;
-  FXRadioButton *orientportrait;
-  FXRadioButton *orientlanscape;
-  FXListBox     *media;
-  FXSpinner     *firstpage;
-  FXSpinner     *lastpage;
-  FXSpinner     *numberofcopies;
-  FXIcon        *landscapeIcon;
-  FXIcon        *portraitIcon;
-  FXPrinter      printer;
-protected:
-  FXPrintDialog(){}
-private:
-  FXPrintDialog(const FXPrintDialog&);
-  FXPrintDialog &operator=(const FXPrintDialog&);
-public:
-  long onCmdToPrinter(FXObject*,FXSelector,void*);
-  long onUpdToPrinter(FXObject*,FXSelector,void*);
-  long onCmdToFile(FXObject*,FXSelector,void*);
-  long onUpdToFile(FXObject*,FXSelector,void*);
-  long onCmdBrowse(FXObject*,FXSelector,void*);
-  long onUpdBrowse(FXObject*,FXSelector,void*);
-  long onCmdProps(FXObject*,FXSelector,void*);
-  long onUpdProps(FXObject*,FXSelector,void*);
-  long onCmdPortrait(FXObject*,FXSelector,void*);
-  long onUpdPortrait(FXObject*,FXSelector,void*);
-  long onCmdLandscape(FXObject*,FXSelector,void*);
-  long onUpdLandscape(FXObject*,FXSelector,void*);
-  long onCmdPages(FXObject*,FXSelector,void*);
-  long onUpdPages(FXObject*,FXSelector,void*);
-  long onCmdColor(FXObject*,FXSelector,void*);
-  long onUpdColor(FXObject*,FXSelector,void*);
-  long onCmdGray(FXObject*,FXSelector,void*);
-  long onUpdGray(FXObject*,FXSelector,void*);
-  long onCmdNumCopies(FXObject*,FXSelector,void*);
-  long onUpdNumCopies(FXObject*,FXSelector,void*);
-  long onCmdFirstPage(FXObject*,FXSelector,void*);
-  long onUpdFirstPage(FXObject*,FXSelector,void*);
-  long onCmdLastPage(FXObject*,FXSelector,void*);
-  long onUpdLastPage(FXObject*,FXSelector,void*);
-  long onCmdCollateNormal(FXObject*,FXSelector,void*);
-  long onUpdCollateNormal(FXObject*,FXSelector,void*);
-  long onCmdCollateReversed(FXObject*,FXSelector,void*);
-  long onUpdCollateReversed(FXObject*,FXSelector,void*);
-  long onCmdFileName(FXObject*,FXSelector,void*);
-  long onUpdFileName(FXObject*,FXSelector,void*);
-  long onCmdPrinterName(FXObject*,FXSelector,void*);
-  long onUpdPrinterName(FXObject*,FXSelector,void*);
-  long onCmdAccept(FXObject*,FXSelector,void*);
-  long onCmdMedia(FXObject*,FXSelector,void*);
-  long onUpdMedia(FXObject*,FXSelector,void*);
-public:
-  enum{
-    ID_TO_PRINTER=FXDialogBox::ID_LAST,
-    ID_TO_FILE,
-    ID_PRINTER_NAME,
-    ID_FILE_NAME,
-    ID_LANDSCAPE,
-    ID_PORTRAIT,
-    ID_MEDIA,
-    ID_COLLATE_NORMAL,
-    ID_COLLATE_REVERSED,
-    ID_PAGES_ALL,
-    ID_PAGES_EVEN,
-    ID_PAGES_ODD,
-    ID_PAGES_RANGE,
-    ID_PAGES_FIRST,
-    ID_PAGES_LAST,
-    ID_BROWSE_FILE,
-    ID_PROPERTIES,
-    ID_COLOR_PRINTER,
-    ID_GRAY_PRINTER,
-    ID_NUM_COPIES
-    };
-public:
-
-  /// Construct print dialog
-  FXPrintDialog(FXWindow* owner,const FXString& name,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Create dialog
-  virtual void create();
-
-  /// Set printer info
-  void setPrinter(const FXPrinter& pr);
-
-  /// Get printer info
-  void getPrinter(FXPrinter& pr);
-
-  /// Save dialog to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load dialog from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXPrintDialog();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXProgressBar.h b/fox-includes/FXProgressBar.h
deleted file mode 100755
index 3652d79f..00000000
--- a/fox-includes/FXProgressBar.h
+++ /dev/null
@@ -1,159 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                      P r o g r e s s B a r   W i d g e t                      *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2002 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXProgressBar.h 814 2002-07-12 16:34:49Z lyle $                     *
-********************************************************************************/
-#ifndef FXPROGRESSBAR_H
-#define FXPROGRESSBAR_H
-
-#ifndef FXFRAME_H
-#include "FXFrame.h"
-#endif
-
-namespace FX {
-
-
-/// Progress bar styles
-enum {
-  PROGRESSBAR_HORIZONTAL = 0,             /// Horizontal display
-  PROGRESSBAR_VERTICAL   = 0x00008000,    /// Vertical display
-  PROGRESSBAR_PERCENTAGE = 0x00010000,    /// Show percentage done
-  PROGRESSBAR_DIAL       = 0x00020000,    /// Show as a dial instead of bar
-  PROGRESSBAR_NORMAL     = FRAME_SUNKEN|FRAME_THICK
-  };
-
-
-/// Progress bar widget
-class FXAPI FXProgressBar : public FXFrame {
-  FXDECLARE(FXProgressBar)
-protected:
-  FXuint   progress;                      // Integer percentage number
-  FXuint   total;                         // Amount for completion
-  FXint    barsize;                       // Bar size
-  FXFont*  font;
-  FXColor  barBGColor;
-  FXColor  barColor;
-  FXColor  textNumColor;
-  FXColor  textAltColor;
-protected:
-  FXProgressBar(){}
-  void drawInterior(FXDCWindow& dc);
-private:
-  FXProgressBar(const FXProgressBar&);
-  FXProgressBar &operator=(const FXProgressBar&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct progress bar
-  FXProgressBar(FXComposite* p,FXObject* target=NULL,FXSelector sel=0,FXuint opts=PROGRESSBAR_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Change the amount of progress
-  void setProgress(FXuint value);
-
-  /// Get current progress
-  FXuint getProgress() const { return progress; }
-
-  /// Set total amount of progress
-  void setTotal(FXuint value);
-
-  /// Return total amount of progrss
-  FXuint getTotal() const { return total; }
-
-  /// Increment progress by given amount
-  void increment(FXuint value);
-
-  /// Hide progress percentage
-  void hideNumber();
-
-  /// Show progress percentage
-  void showNumber();
-
-  /// Change progress bar width
-  void setBarSize(FXint size);
-
-  /// Return progress bar width
-  FXint getBarSize() const { return barsize; }
-
-  /// Change backgroundcolor
-  void setBarBGColor(FXColor clr);
-
-  /// Return background color
-  FXColor getBarBGColor() const { return barBGColor; }
-
-  /// Change bar color
-  void setBarColor(FXColor clr);
-
-  /// Return bar color
-  FXColor getBarColor() const { return barColor; }
-
-  /// Change text color
-  void setTextColor(FXColor clr);
-
-  /// Return text color
-  FXColor getTextColor() const { return textNumColor; }
-
-  /// Change alternate text color shown when bar under text
-  void setTextAltColor(FXColor clr);
-
-  /// Return alternate text color
-  FXColor getTextAltColor() const { return textAltColor; }
-
-  /// Set the text font
-  void setFont(FXFont *fnt);
-
-  /// Get the text font
-  FXFont* getFont() const { return font; }
-
-  /// Change progress bar style
-  void setBarStyle(FXuint style);
-
-  /// Return current progress bar style
-  FXuint getBarStyle() const;
-
-  /// Save progress bar to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load progress bar from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXProgressBar();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXProgressDialog.h b/fox-includes/FXProgressDialog.h
deleted file mode 100755
index 27ac983f..00000000
--- a/fox-includes/FXProgressDialog.h
+++ /dev/null
@@ -1,115 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                      P r o g r e s s   D i a l o g   B o x                    *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2001,2003 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXProgressDialog.h 1536 2003-05-14 21:41:00Z lyle $                  *
-********************************************************************************/
-#ifndef FXPROGRESSDIALOG_H
-#define FXPROGRESSDIALOG_H
-
-#ifndef FXDIALOGBOX_H
-#include "FXDialogBox.h"
-#endif
-
-namespace FX {
-
-
-enum {
-  PROGRESSDIALOG_NOCANCEL = 0,                        /// Default is no cancel button
-  PROGRESSDIALOG_CANCEL   = 0x01000000,               /// Enable the cancel button
-  PROGRESSDIALOG_NORMAL   = (DECOR_TITLE|DECOR_BORDER)
-  };
-
-
-class FXHorizontalSeparator;
-class FXProgressBar;
-class FXButton;
-class FXLabel;
-
-/**
-* A Progress Dialog is a simple dialog which is used to
-* keep a user informed of the progress of a lengthy operation
-* in a program and that the program is in fact still working.
-*/
-class FXAPI FXProgressDialog : public FXDialogBox {
-  FXDECLARE(FXProgressDialog)
-protected:
-  FXProgressBar         *progress;    // Progress bar
-  FXLabel               *message;     // Message
-  FXHorizontalSeparator *separator;   // Separator
-  FXButton              *cancel;      // Cancel button
-  FXbool                 cancelled;   // User hit cancel
-protected:
-  FXProgressDialog();
-private:
-  FXProgressDialog(const FXProgressDialog&);
-  FXProgressDialog &operator=(const FXProgressDialog&);
-public:
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-  long onCmdSetStringValue(FXObject*,FXSelector,void*);
-  long onCmdGetStringValue(FXObject*,FXSelector,void*);
-  long onCmdCancel(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct input dialog box with given caption, icon, and prompt text
-  FXProgressDialog(FXWindow* owner,const FXString& caption,const FXString& label,FXuint opts=PROGRESSDIALOG_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Change the progress message
-  void setMessage(const FXString& msg);
-
-  /// Get progress message
-  FXString getMessage() const;
-
-  /// Change style of the progress bar widget
-  void setBarStyle(FXuint style);
-
-  /// Get style of the progress bar widget
-  FXuint getBarStyle() const;
-
-  /// Change the amount of progress
-  void setProgress(FXuint value);
-
-  /// Get current progress
-  FXuint getProgress() const;
-
-  /// Set total amount of progress
-  void setTotal(FXuint value);
-
-  /// Return total amount of progrss
-  FXuint getTotal() const;
-
-  /// Increment progress by given amount
-  void increment(FXuint value);
-
-  /// Has operation been cancelled?
-  FXbool isCancelled() const { return cancelled; }
-
-  /// Change cancelled flag
-  void setCancelled(FXbool flg){ cancelled=flg; }
-
-  /// Destroy
-  virtual ~FXProgressDialog();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXQuatd.h b/fox-includes/FXQuatd.h
deleted file mode 100755
index 051eaef7..00000000
--- a/fox-includes/FXQuatd.h
+++ /dev/null
@@ -1,144 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*              D o u b l e - P r e c i s i o n  Q u a t e r n i o n             *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1994,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXQuatd.h 2344 2006-02-12 21:19:36Z lyle $                           *
-********************************************************************************/
-#ifndef FXQUATD_H
-#define FXQUATD_H
-
-
-namespace FX {
-
-
-class FXMat3d;
-
-
-/// Double-precision quaternion
-class FXAPI FXQuatd : public FXVec4d {
-public:
-
-  /// Constructors
-  FXQuatd(){}
-
-  /// Copy constructor
-  FXQuatd(const FXQuatd& q):FXVec4d(q){}
-
-  /// Construct from components
-  FXQuatd(FXdouble xx,FXdouble yy,FXdouble zz,FXdouble ww):FXVec4d(xx,yy,zz,ww){}
-
-  /// Construct from array of doubles
-  FXQuatd(const FXdouble v[]):FXVec4d(v){}
-
-  /// Construct from axis and angle
-  FXQuatd(const FXVec3d& axis,FXdouble phi=0.0);
-
-  /// Construct from euler angles yaw (z), pitch (y), and roll (x)
-  FXQuatd(FXdouble roll,FXdouble pitch,FXdouble yaw);
-
-  /// Construct quaternion from two unit vectors
-  FXQuatd(const FXVec3d& fr,const FXVec3d& to);
-
-  /// Construct quaternion from three axes
-  FXQuatd(const FXVec3d& ex,const FXVec3d& ey,const FXVec3d& ez);
-
-  /// Construct quaternion from 3x3 matrix
-  FXQuatd(const FXMat3d& mat);
-
-  /// Adjust quaternion length
-  FXQuatd& adjust();
-
-  /// Set quaternion from axis and angle
-  void setAxisAngle(const FXVec3d& axis,FXdouble phi=0.0);
-
-  /// Obtain axis and angle from quaternion
-  void getAxisAngle(FXVec3d& axis,FXdouble& phi) const;
-
-  /// Set quaternion from roll (x), pitch (y), yaw (z)
-  void setRollPitchYaw(FXdouble roll,FXdouble pitch,FXdouble yaw);
-  void getRollPitchYaw(FXdouble& roll,FXdouble& pitch,FXdouble& yaw) const;
-
-  /// Set quaternion from yaw (z), pitch (y), roll (x)
-  void setYawPitchRoll(FXdouble yaw,FXdouble pitch,FXdouble roll);
-  void getYawPitchRoll(FXdouble& yaw,FXdouble& pitch,FXdouble& roll) const;
-
-  /// Set quaternion from roll (x), yaw (z), pitch (y)
-  void setRollYawPitch(FXdouble roll,FXdouble yaw,FXdouble pitch);
-  void getRollYawPitch(FXdouble& roll,FXdouble& yaw,FXdouble& pitch) const;
-
-  /// Set quaternion from pitch (y), roll (x),yaw (z)
-  void setPitchRollYaw(FXdouble pitch,FXdouble roll,FXdouble yaw);
-  void getPitchRollYaw(FXdouble& pitch,FXdouble& roll,FXdouble& yaw) const;
-
-  /// Set quaternion from pitch (y), yaw (z), roll (x)
-  void setPitchYawRoll(FXdouble pitch,FXdouble yaw,FXdouble roll);
-  void getPitchYawRoll(FXdouble& pitch,FXdouble& yaw,FXdouble& roll) const;
-
-  /// Set quaternion from yaw (z), roll (x), pitch (y)
-  void setYawRollPitch(FXdouble yaw,FXdouble roll,FXdouble pitch);
-  void getYawRollPitch(FXdouble& yaw,FXdouble& roll,FXdouble& pitch) const;
-
-  /// Set quaternion from axes
-  void setAxes(const FXVec3d& ex,const FXVec3d& ey,const FXVec3d& ez);
-
-  /// Get quaternion axes
-  void getAxes(FXVec3d& ex,FXVec3d& ey,FXVec3d& ez) const;
-
-  /// Obtain local x axis
-  FXVec3d getXAxis() const;
-
-  /// Obtain local y axis
-  FXVec3d getYAxis() const;
-
-  /// Obtain local z axis
-  FXVec3d getZAxis() const;
-
-  /// Exponentiate quaternion
-  FXQuatd exp() const;
-
-  /// Take logarithm of quaternion
-  FXQuatd log() const;
-
-  /// Invert quaternion
-  FXQuatd invert() const;
-
-  /// Invert unit quaternion
-  FXQuatd unitinvert() const;
-
-  /// Conjugate quaternion
-  FXQuatd conj() const;
-
-  /// Construct quaternion from arc a->b on unit sphere
-  FXQuatd& arc(const FXVec3d& a,const FXVec3d& b);
-
-  /// Spherical lerp
-  FXQuatd& lerp(const FXQuatd& u,const FXQuatd& v,FXdouble f);
-
-  /// Multiply quaternions
-  FXQuatd operator*(const FXQuatd& q) const;
-
-  /// Rotation of a vector by a quaternion
-  FXVec3d operator*(const FXVec3d& v) const;
-  };
-
-
-}
-
-#endif
diff --git a/fox-includes/FXQuatf.h b/fox-includes/FXQuatf.h
deleted file mode 100755
index 4622e419..00000000
--- a/fox-includes/FXQuatf.h
+++ /dev/null
@@ -1,144 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*              S i n g l e - P r e c i s i o n  Q u a t e r n i o n             *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1994,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXQuatf.h 2344 2006-02-12 21:19:36Z lyle $                           *
-********************************************************************************/
-#ifndef FXQUATF_H
-#define FXQUATF_H
-
-
-namespace FX {
-
-
-class FXMat3f;
-
-
-/// Single-precision quaternion
-class FXAPI FXQuatf : public FXVec4f {
-public:
-
-  /// Construct
-  FXQuatf(){}
-
-  /// Copy constructor
-  FXQuatf(const FXQuatf& q):FXVec4f(q){}
-
-  /// Construct from components
-  FXQuatf(FXfloat xx,FXfloat yy,FXfloat zz,FXfloat ww):FXVec4f(xx,yy,zz,ww){}
-
-  /// Construct from array of floats
-  FXQuatf(const FXfloat v[]):FXVec4f(v){}
-
-  /// Construct from axis and angle
-  FXQuatf(const FXVec3f& axis,FXfloat phi=0.0f);
-
-  /// Construct from euler angles yaw (z), pitch (y), and roll (x)
-  FXQuatf(FXfloat roll,FXfloat pitch,FXfloat yaw);
-
-  /// Construct quaternion from two unit vectors
-  FXQuatf(const FXVec3f& fr,const FXVec3f& to);
-
-  /// Construct quaternion from three axes
-  FXQuatf(const FXVec3f& ex,const FXVec3f& ey,const FXVec3f& ez);
-
-  /// Construct quaternion from 3x3 matrix
-  FXQuatf(const FXMat3f& mat);
-
-  /// Adjust quaternion length
-  FXQuatf& adjust();
-
-  /// Set quaternion from axis and angle
-  void setAxisAngle(const FXVec3f& axis,FXfloat phi=0.0f);
-
-  /// Obtain axis and angle from quaternion
-  void getAxisAngle(FXVec3f& axis,FXfloat& phi) const;
-
-  /// Set quaternion from roll (x), pitch (y), yaw (z)
-  void setRollPitchYaw(FXfloat roll,FXfloat pitch,FXfloat yaw);
-  void getRollPitchYaw(FXfloat& roll,FXfloat& pitch,FXfloat& yaw) const;
-
-  /// Set quaternion from yaw (z), pitch (y), roll (x)
-  void setYawPitchRoll(FXfloat yaw,FXfloat pitch,FXfloat roll);
-  void getYawPitchRoll(FXfloat& yaw,FXfloat& pitch,FXfloat& roll) const;
-
-  /// Set quaternion from roll (x), yaw (z), pitch (y)
-  void setRollYawPitch(FXfloat roll,FXfloat yaw,FXfloat pitch);
-  void getRollYawPitch(FXfloat& roll,FXfloat& yaw,FXfloat& pitch) const;
-
-  /// Set quaternion from pitch (y), roll (x),yaw (z)
-  void setPitchRollYaw(FXfloat pitch,FXfloat roll,FXfloat yaw);
-  void getPitchRollYaw(FXfloat& pitch,FXfloat& roll,FXfloat& yaw) const;
-
-  /// Set quaternion from pitch (y), yaw (z), roll (x)
-  void setPitchYawRoll(FXfloat pitch,FXfloat yaw,FXfloat roll);
-  void getPitchYawRoll(FXfloat& pitch,FXfloat& yaw,FXfloat& roll) const;
-
-  /// Set quaternion from yaw (z), roll (x), pitch (y)
-  void setYawRollPitch(FXfloat yaw,FXfloat roll,FXfloat pitch);
-  void getYawRollPitch(FXfloat& yaw,FXfloat& roll,FXfloat& pitch) const;
-
-  /// Set quaternion from axes
-  void setAxes(const FXVec3f& ex,const FXVec3f& ey,const FXVec3f& ez);
-
-  /// Get quaternion axes
-  void getAxes(FXVec3f& ex,FXVec3f& ey,FXVec3f& ez) const;
-
-  /// Obtain local x axis
-  FXVec3f getXAxis() const;
-
-  /// Obtain local y axis
-  FXVec3f getYAxis() const;
-
-  /// Obtain local z axis
-  FXVec3f getZAxis() const;
-
-  /// Exponentiate quaternion
-  FXQuatf exp() const;
-
-  /// Take logarithm of quaternion
-  FXQuatf log() const;
-
-  /// Invert quaternion
-  FXQuatf invert() const;
-
-  /// Invert unit quaternion
-  FXQuatf unitinvert() const;
-
-  /// Conjugate quaternion
-  FXQuatf conj() const;
-
-  /// Construct quaternion from arc a->b on unit sphere
-  FXQuatf& arc(const FXVec3f& a,const FXVec3f& b);
-
-  /// Spherical lerp
-  FXQuatf& lerp(const FXQuatf& u,const FXQuatf& v,FXfloat f);
-
-  /// Multiply quaternions
-  FXQuatf operator*(const FXQuatf& q) const;
-
-  /// Rotation of a vector by a quaternion
-  FXVec3f operator*(const FXVec3f& v) const;
-  };
-
-
-}
-
-#endif
diff --git a/fox-includes/FXRASIcon.h b/fox-includes/FXRASIcon.h
deleted file mode 100644
index 5380ab4e..00000000
--- a/fox-includes/FXRASIcon.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                   S U N   R A S T E R   I m a g e   O b j e c t               *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2004,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXRASIcon.h 2401 2006-04-27 00:46:49Z lyle $                          *
-********************************************************************************/
-#ifndef FXRASICON_H
-#define FXRASICON_H
-
-#ifndef FXICON_H
-#include "FXIcon.h"
-#endif
-
-namespace FX {
-
-
-/// SUN Raster Image format icon
-class FXAPI FXRASIcon : public FXIcon {
-  FXDECLARE(FXRASIcon)
-protected:
-  FXRASIcon(){}
-private:
-  FXRASIcon(const FXRASIcon&);
-  FXRASIcon &operator=(const FXRASIcon&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct icon from memory stream formatted in SUN Raster Image format
-  FXRASIcon(FXApp* a,const void *pix=NULL,FXColor clr=FXRGB(192,192,192),FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Save pixels into stream in SUN Raster Image format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in SUN Raster Image format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy icon
-  virtual ~FXRASIcon();
-  };
-
-
-/**
-* Check if stream contains a RAS, return TRUE if so.
-*/
-extern FXAPI bool fxcheckRAS(FXStream& store);
-
-
-/**
-* Load an SUN Raster Image format file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadRAS(FXStream& store,FXColor*& data,FXint& width,FXint& height);
-
-
-/**
-* Save an SUN Raster Image format file to a stream.
-*/
-extern FXAPI bool fxsaveRAS(FXStream& store,const FXColor *data,FXint width,FXint height);
-
-}
-
-#endif
diff --git a/fox-includes/FXRASImage.h b/fox-includes/FXRASImage.h
deleted file mode 100644
index c850f194..00000000
--- a/fox-includes/FXRASImage.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                   S U N   R A S T E R   I m a g e   O b j e c t               *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2004,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXRASImage.h 2401 2006-04-27 00:46:49Z lyle $                         *
-********************************************************************************/
-#ifndef FXRASIMAGE_H
-#define FXRASIMAGE_H
-
-#ifndef FXIMAGE_H
-#include "FXImage.h"
-#endif
-
-namespace FX {
-
-
-/// SUN Raster Image format
-class FXAPI FXRASImage : public FXImage {
-  FXDECLARE(FXRASImage)
-protected:
-  FXRASImage(){}
-private:
-  FXRASImage(const FXRASImage&);
-  FXRASImage &operator=(const FXRASImage&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct image from memory stream formatted in SUN Raster Image format
-  FXRASImage(FXApp* a,const void *pix=NULL,FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Save pixels into stream in SUN Raster Image format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in SUN Raster Image format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy icon
-  virtual ~FXRASImage();
-  };
-
-
-/**
-* Check if stream contains a RAS, return TRUE if so.
-*/
-extern FXAPI bool fxcheckRAS(FXStream& store);
-
-
-/**
-* Load an SUN Raster Image format file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadRAS(FXStream& store,FXColor*& data,FXint& width,FXint& height);
-
-
-/**
-* Save an SUN Raster Image format file to a stream.
-*/
-extern FXAPI bool fxsaveRAS(FXStream& store,const FXColor *data,FXint width,FXint height);
-
-}
-
-#endif
diff --git a/fox-includes/FXRGBIcon.h b/fox-includes/FXRGBIcon.h
deleted file mode 100755
index 0d4c13c0..00000000
--- a/fox-includes/FXRGBIcon.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                      I R I S   R G B   I c o n   O b j e c t                  *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2002,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXRGBIcon.h 2343 2006-02-12 20:26:26Z lyle $                         *
-********************************************************************************/
-#ifndef FXRGBICON_H
-#define FXRGBICON_H
-
-#ifndef FXICON_H
-#include "FXIcon.h"
-#endif
-
-namespace FX {
-
-
-/// IRIS RGB icon
-class FXAPI FXRGBIcon : public FXIcon {
-  FXDECLARE(FXRGBIcon)
-protected:
-  FXRGBIcon(){}
-private:
-  FXRGBIcon(const FXRGBIcon&);
-  FXRGBIcon &operator=(const FXRGBIcon&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct icon from memory stream formatted in IRIS-RGB format
-  FXRGBIcon(FXApp* a,const void *pix=NULL,FXColor clr=FXRGB(192,192,192),FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Save pixels into stream in IRIS-RGB format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in IRIS-RGB format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy icon
-  virtual ~FXRGBIcon();
-  };
-
-
-/**
-* Check if stream contains a RGB, return TRUE if so.
-*/
-extern FXAPI bool fxcheckRGB(FXStream& store);
-
-
-/**
-* Load an RGB (SGI IRIS RGB) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadRGB(FXStream& store,FXColor*& data,FXint& width,FXint& height);
-
-
-/**
-* Save an RGB (SGI IRIS RGB) file to a stream.
-*/
-extern FXAPI bool fxsaveRGB(FXStream& store,const FXColor *data,FXint width,FXint height);
-
-}
-
-#endif
diff --git a/fox-includes/FXRGBImage.h b/fox-includes/FXRGBImage.h
deleted file mode 100755
index 87b387b8..00000000
--- a/fox-includes/FXRGBImage.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                     I R I S   R G B   I m a g e   O b j e c t                 *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2002,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXRGBImage.h 2343 2006-02-12 20:26:26Z lyle $                        *
-********************************************************************************/
-#ifndef FXRGBIMAGE_H
-#define FXRGBIMAGE_H
-
-#ifndef FXIMAGE_H
-#include "FXImage.h"
-#endif
-
-namespace FX {
-
-
-/// IRIS RGB image
-class FXAPI FXRGBImage : public FXImage {
-  FXDECLARE(FXRGBImage)
-protected:
-  FXRGBImage(){}
-private:
-  FXRGBImage(const FXRGBImage&);
-  FXRGBImage &operator=(const FXRGBImage&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct image from memory stream formatted in IRIS-RGB format
-  FXRGBImage(FXApp* a,const void *pix=NULL,FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Save pixels into stream in IRIS-RGB format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in IRIS-RGB format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy icon
-  virtual ~FXRGBImage();
-  };
-
-
-/**
-* Check if stream contains a RGB, return TRUE if so.
-*/
-extern FXAPI bool fxcheckRGB(FXStream& store);
-
-
-/**
-* Load an RGB (SGI IRIS RGB) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadRGB(FXStream& store,FXColor*& data,FXint& width,FXint& height);
-
-
-/**
-* Save an RGB (SGI IRIS RGB) file to a stream.
-*/
-extern FXAPI bool fxsaveRGB(FXStream& store,const FXColor *data,FXint width,FXint height);
-
-}
-
-#endif
diff --git a/fox-includes/FXRadioButton.h b/fox-includes/FXRadioButton.h
deleted file mode 100755
index 5a22d107..00000000
--- a/fox-includes/FXRadioButton.h
+++ /dev/null
@@ -1,133 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                  R a d i o   B u t t o n    W i d g e t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXRadioButton.h 2343 2006-02-12 20:26:26Z lyle $                     *
-********************************************************************************/
-#ifndef FXRADIOBUTTON_H
-#define FXRADIOBUTTON_H
-
-#ifndef FXLABEL_H
-#include "FXLabel.h"
-#endif
-
-namespace FX {
-
-
-/// RadioButton flags
-enum {
-  RADIOBUTTON_AUTOGRAY = 0x00800000,  /// Automatically gray out when not updated
-  RADIOBUTTON_AUTOHIDE = 0x01000000,  /// Automatically hide when not updated
-  RADIOBUTTON_NORMAL   = JUSTIFY_NORMAL|ICON_BEFORE_TEXT
-  };
-
-
-
-/**
-* A radio button is a tri-state button.  Normally, it is either
-* TRUE or FALSE; a third state MAYBE may be set to indicate that no selection
-* has been made yet by the user, or that the state is ambiguous.
-* When pressed, the radio button sets its state to TRUE and sends a SEL_COMMAND
-* to its target, and the message data set to the state of the radio button,
-* of the type FXbool.
-* A group of radio buttons can be made mutually exclusive by linking them
-* to a common data target.  Alternatively, an application can implement a
-* common SEL_UPDATED handler to check and uncheck radio buttons as appropriate.
-*/
-class FXAPI FXRadioButton : public FXLabel {
-  FXDECLARE(FXRadioButton)
-protected:
-  FXColor  radioColor;  // Color of radio ball
-  FXColor  diskColor;   // Color of radio disk
-  FXbool   check;       // Radio state
-  FXbool   oldcheck;    // Old radio state
-protected:
-  FXRadioButton();
-private:
-  FXRadioButton(const FXRadioButton&);
-  FXRadioButton &operator=(const FXRadioButton&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onUpdate(FXObject*,FXSelector,void*);
-  long onEnter(FXObject*,FXSelector,void*);
-  long onLeave(FXObject*,FXSelector,void*);
-  long onFocusIn(FXObject*,FXSelector,void*);
-  long onFocusOut(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onHotKeyPress(FXObject*,FXSelector,void*);
-  long onHotKeyRelease(FXObject*,FXSelector,void*);
-  long onCheck(FXObject*,FXSelector,void*);
-  long onUncheck(FXObject*,FXSelector,void*);
-  long onUnknown(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct new radio button
-  FXRadioButton(FXComposite* p,const FXString& text,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=RADIOBUTTON_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Returns true because a radio button can receive focus
-  virtual bool canFocus() const;
-
-  /// Get default width
-  virtual FXint getDefaultWidth();
-
-  /// Get default height
-  virtual FXint getDefaultHeight();
-
-  /// Set radio button state (TRUE, FALSE or MAYBE)
-  void setCheck(FXbool s=TRUE,FXbool notify=FALSE);
-
-  /// Get radio button state (TRUE, FALSE or MAYBE)
-  FXbool getCheck() const { return check; }
-
-  /// Change radio button style
-  void setRadioButtonStyle(FXuint style);
-
-  /// Return current radio button style
-  FXuint getRadioButtonStyle() const;
-
-  /// Get the radio ball color
-  FXColor getRadioColor() const { return radioColor; }
-
-  /// Set the radio ball color
-  void setRadioColor(FXColor clr);
-
-  /// Get the radio disk color
-  FXColor getDiskColor() const { return diskColor; }
-
-  /// Set the radio disk color
-  void setDiskColor(FXColor clr);
-
-  /// Save radio button to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load radio button from a stream
-  virtual void load(FXStream& store);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXRanged.h b/fox-includes/FXRanged.h
deleted file mode 100755
index ad59f46b..00000000
--- a/fox-includes/FXRanged.h
+++ /dev/null
@@ -1,169 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*          D o u b l e - P r e c i s i o n    R a n g e    C l a s s            *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2004,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXRanged.h 2344 2006-02-12 21:19:36Z lyle $                          *
-********************************************************************************/
-#ifndef FXRANGED_H
-#define FXRANGED_H
-
-
-namespace FX {
-
-
-class FXSphered;
-
-
-/// Bounds
-class FXAPI FXRanged {
-public:
-  FXVec3d lower;
-  FXVec3d upper;
-public:
-
-  /// Default constructor
-  FXRanged(){}
-
-  /// Initialize from another range
-  FXRanged(const FXRanged& bounds):lower(bounds.lower),upper(bounds.upper){}
-
-  /// Initialize from two vectors
-  FXRanged(const FXVec3d& lo,const FXVec3d& hi):lower(lo),upper(hi){}
-
-  /// Initialize from six numbers
-  FXRanged(FXdouble xlo,FXdouble xhi,FXdouble ylo,FXdouble yhi,FXdouble zlo,FXdouble zhi):lower(xlo,ylo,zlo),upper(xhi,yhi,zhi){}
-
-  /// Initialize box to fully contain the given bounding sphere
-  FXRanged(const FXSphered& sphere);
-
-  /// Assignment
-  FXRanged& operator=(const FXRanged& bounds){ lower=bounds.lower; upper=bounds.upper; return *this; }
-
-  /// Set value from another range
-  FXRanged& set(const FXRanged& bounds){ lower=bounds.lower; upper=bounds.upper; return *this; }
-
-  /// Set value from two vectors
-  FXRanged& set(const FXVec3d& lo,const FXVec3d& hi){ lower=lo; upper=hi; return *this; }
-
-  /// Set value from six numbers
-  FXRanged& set(FXdouble xlo,FXdouble xhi,FXdouble ylo,FXdouble yhi,FXdouble zlo,FXdouble zhi){ lower.set(xlo,ylo,zlo); upper.set(xhi,yhi,zhi); return *this; }
-
-  /// Indexing with 0..1
-  FXVec3d& operator[](FXint i){ return (&lower)[i]; }
-
-  /// Indexing with 0..1
-  const FXVec3d& operator[](FXint i) const { return (&lower)[i]; }
-
-  /// Comparison
-  bool operator==(const FXRanged& r) const { return lower==r.lower && upper==r.upper; }
-  bool operator!=(const FXRanged& r) const { return lower!=r.lower || upper!=r.upper; }
-
-  /// Width of box
-  FXdouble width() const { return upper.x-lower.x; }
-
-  /// Height of box
-  FXdouble height() const { return upper.y-lower.y; }
-
-  /// Depth of box
-  FXdouble depth() const { return upper.z-lower.z; }
-
-  /// Longest side
-  FXdouble longest() const;
-
-  /// shortest side
-  FXdouble shortest() const;
-
-  /// Length of diagonal
-  FXdouble diameter() const;
-
-  /// Get radius of box
-  FXdouble radius() const;
-
-  /// Compute diagonal
-  FXVec3d diagonal() const;
-
-  /// Get center of box
-  FXVec3d center() const;
-
-  /// Test if empty
-  bool empty() const;
-
-  /// Test if box contains point x,y,z
-  bool contains(FXdouble x,FXdouble y,FXdouble z) const;
-
-  /// Test if box contains point p
-  bool contains(const FXVec3d& p) const;
-
-  /// Test if box properly contains another box
-  bool contains(const FXRanged& bounds) const;
-
-  /// Test if box properly contains sphere
-  bool contains(const FXSphered& sphere) const;
-
-  /// Include point
-  FXRanged& include(FXdouble x,FXdouble y,FXdouble z);
-
-  /// Include point
-  FXRanged& include(const FXVec3d& v);
-
-  /// Include given range into box
-  FXRanged& include(const FXRanged& box);
-
-  /// Include given sphere into this box
-  FXRanged& include(const FXSphered& sphere);
-
-  /// Intersect box with normalized plane ax+by+cz+w; returns -1,0,+1
-  FXint intersect(const FXVec4d &plane) const;
-
-  /// Intersect box with ray u-v
-  bool intersect(const FXVec3d& u,const FXVec3d& v);
-
-  /// Test if bounds overlap
-  friend FXAPI bool overlap(const FXRanged& a,const FXRanged& b);
-
-  /// Get corner number 0..7
-  FXVec3d corner(FXint c) const { return FXVec3d((&lower)[c&1].x, (&lower)[(c>>1)&1].y, (&lower)[c>>2].z); }
-
-  /// Union of two boxes
-  friend FXAPI FXRanged unite(const FXRanged& a,const FXRanged& b);
-
-  /// Intersection of two boxes
-  friend FXAPI FXRanged intersect(const FXRanged& a,const FXRanged& b);
-
-  /// Save object to a stream
-  friend FXAPI FXStream& operator<<(FXStream& store,const FXRanged& bounds);
-
-  /// Load object from a stream
-  friend FXAPI FXStream& operator>>(FXStream& store,FXRanged& bounds);
-  };
-
-
-extern FXAPI bool overlap(const FXRanged& a,const FXRanged& b);
-
-extern FXAPI FXRanged unite(const FXRanged& a,const FXRanged& b);
-extern FXAPI FXRanged intersect(const FXRanged& a,const FXRanged& b);
-
-extern FXAPI FXStream& operator<<(FXStream& store,const FXRanged& bounds);
-extern FXAPI FXStream& operator>>(FXStream& store,FXRanged& bounds);
-
-}
-
-#endif
-
diff --git a/fox-includes/FXRangef.h b/fox-includes/FXRangef.h
deleted file mode 100755
index 20cc6b49..00000000
--- a/fox-includes/FXRangef.h
+++ /dev/null
@@ -1,169 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*           S i n g l e - P r e c i s i o n    R a n g e    C l a s s           *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2004,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXRangef.h 2344 2006-02-12 21:19:36Z lyle $                          *
-********************************************************************************/
-#ifndef FXRANGEF_H
-#define FXRANGEF_H
-
-
-namespace FX {
-
-
-class FXSpheref;
-
-
-/// Bounds
-class FXAPI FXRangef {
-public:
-  FXVec3f lower;
-  FXVec3f upper;
-public:
-
-  /// Default constructor
-  FXRangef(){}
-
-  /// Copy constructor
-  FXRangef(const FXRangef& bounds):lower(bounds.lower),upper(bounds.upper){}
-
-  /// Initialize from two vectors
-  FXRangef(const FXVec3f& lo,const FXVec3f& hi):lower(lo),upper(hi){}
-
-  /// Initialize from six numbers
-  FXRangef(FXfloat xlo,FXfloat xhi,FXfloat ylo,FXfloat yhi,FXfloat zlo,FXfloat zhi):lower(xlo,ylo,zlo),upper(xhi,yhi,zhi){}
-
-  /// Initialize box to fully contain the given bounding sphere
-  FXRangef(const FXSpheref& sphere);
-
-  /// Assignment
-  FXRangef& operator=(const FXRangef& bounds){ lower=bounds.lower; upper=bounds.upper; return *this; }
-
-  /// Set value from another range
-  FXRangef& set(const FXRangef& bounds){ lower=bounds.lower; upper=bounds.upper; return *this; }
-
-  /// Set value from two vectors
-  FXRangef& set(const FXVec3f& lo,const FXVec3f& hi){ lower=lo; upper=hi; return *this; }
-
-  /// Set value from six numbers
-  FXRangef& set(FXfloat xlo,FXfloat xhi,FXfloat ylo,FXfloat yhi,FXfloat zlo,FXfloat zhi){ lower.set(xlo,ylo,zlo); upper.set(xhi,yhi,zhi); return *this; }
-
-  /// Indexing with 0..1
-  FXVec3f& operator[](FXint i){ return (&lower)[i]; }
-
-  /// Indexing with 0..1
-  const FXVec3f& operator[](FXint i) const { return (&lower)[i]; }
-
-  /// Comparison
-  bool operator==(const FXRangef& r) const { return lower==r.lower && upper==r.upper; }
-  bool operator!=(const FXRangef& r) const { return lower!=r.lower || upper!=r.upper; }
-
-  /// Width of box
-  FXfloat width() const { return upper.x-lower.x; }
-
-  /// Height of box
-  FXfloat height() const { return upper.y-lower.y; }
-
-  /// Depth of box
-  FXfloat depth() const { return upper.z-lower.z; }
-
-  /// Longest side
-  FXfloat longest() const;
-
-  /// shortest side
-  FXfloat shortest() const;
-
-  /// Length of diagonal
-  FXfloat diameter() const;
-
-  /// Get radius of box
-  FXfloat radius() const;
-
-  /// Compute diagonal
-  FXVec3f diagonal() const;
-
-  /// Get center of box
-  FXVec3f center() const;
-
-  /// Test if empty
-  bool empty() const;
-
-  /// Test if box contains point x,y,z
-  bool contains(FXfloat x,FXfloat y,FXfloat z) const;
-
-  /// Test if box contains point p
-  bool contains(const FXVec3f& p) const;
-
-  /// Test if box properly contains another box
-  bool contains(const FXRangef& bounds) const;
-
-  /// Test if box properly contains sphere
-  bool contains(const FXSpheref& sphere) const;
-
-  /// Include point
-  FXRangef& include(FXfloat x,FXfloat y,FXfloat z);
-
-  /// Include point
-  FXRangef& include(const FXVec3f& v);
-
-  /// Include given range into box
-  FXRangef& include(const FXRangef& box);
-
-  /// Include given sphere into this box
-  FXRangef& include(const FXSpheref& sphere);
-
-  /// Intersect box with normalized plane ax+by+cz+w; returns -1,0,+1
-  FXint intersect(const FXVec4f& plane) const;
-
-  /// Intersect box with ray u-v
-  bool intersect(const FXVec3f& u,const FXVec3f& v);
-
-  /// Test if boxes a and b overlap
-  friend FXAPI bool overlap(const FXRangef& a,const FXRangef& b);
-
-  /// Get corner number 0..7
-  FXVec3f corner(FXint c) const { return FXVec3f((&lower)[c&1].x,(&lower)[(c>>1)&1].y,(&lower)[c>>2].z); }
-
-  /// Union of two boxes
-  friend FXAPI FXRangef unite(const FXRangef& a,const FXRangef& b);
-
-  /// Intersection of two boxes
-  friend FXAPI FXRangef intersect(const FXRangef& a,const FXRangef& b);
-
-  /// Save object to a stream
-  friend FXAPI FXStream& operator<<(FXStream& store,const FXRangef& bounds);
-
-  /// Load object from a stream
-  friend FXAPI FXStream& operator>>(FXStream& store,FXRangef& bounds);
-  };
-
-
-extern FXAPI bool overlap(const FXRangef& a,const FXRangef& b);
-
-extern FXAPI FXRangef unite(const FXRangef& a,const FXRangef& b);
-extern FXAPI FXRangef intersect(const FXRangef& a,const FXRangef& b);
-
-extern FXAPI FXStream& operator<<(FXStream& store,const FXRangef& bounds);
-extern FXAPI FXStream& operator>>(FXStream& store,FXRangef& bounds);
-
-}
-
-#endif
-
diff --git a/fox-includes/FXRealSlider.h b/fox-includes/FXRealSlider.h
deleted file mode 100755
index e3e05913..00000000
--- a/fox-includes/FXRealSlider.h
+++ /dev/null
@@ -1,209 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       R e a l S l i d e r   W i d g e t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXRealSlider.h 2343 2006-02-12 20:26:26Z lyle $                      *
-********************************************************************************/
-#ifndef FXREALSLIDER_H
-#define FXREALSLIDER_H
-
-#ifndef FXFRAME_H
-#include "FXFrame.h"
-#endif
-
-namespace FX {
-
-
-/// Slider Control styles
-enum {
-  REALSLIDER_HORIZONTAL   = 0,                          /// Slider shown horizontally
-  REALSLIDER_VERTICAL     = 0x00008000,                 /// Slider shown vertically
-  REALSLIDER_ARROW_UP     = 0x00010000,                 /// Slider has arrow head pointing up
-  REALSLIDER_ARROW_DOWN   = 0x00020000,                 /// Slider has arrow head pointing down
-  REALSLIDER_ARROW_LEFT   = REALSLIDER_ARROW_UP,        /// Slider has arrow head pointing left
-  REALSLIDER_ARROW_RIGHT  = REALSLIDER_ARROW_DOWN,      /// Slider has arrow head pointing right
-  REALSLIDER_INSIDE_BAR   = 0x00040000,                 /// Slider is inside the slot rather than overhanging
-  REALSLIDER_TICKS_TOP    = 0x00080000,                 /// Ticks on the top of horizontal slider
-  REALSLIDER_TICKS_BOTTOM = 0x00100000,                 /// Ticks on the bottom of horizontal slider
-  REALSLIDER_TICKS_LEFT   = REALSLIDER_TICKS_TOP,       /// Ticks on the left of vertical slider
-  REALSLIDER_TICKS_RIGHT  = REALSLIDER_TICKS_BOTTOM,    /// Ticks on the right of vertical slider
-  REALSLIDER_NORMAL       = REALSLIDER_HORIZONTAL
-  };
-
-
-/**
-* The real slider widget is a valuator widget which provides simple linear value range.
-* Two visual appearances are supported:- the sunken look, which is enabled with
-* the SLIDER_INSIDE_BAR option and the regular look.  The latter may have optional
-* arrows on the slider thumb.
-* While being moved, the real slider sends a SEL_CHANGED message to its target;
-* at the end of the interaction, a SEL_COMMAND message is sent.
-* The message data represents the current slider value, of type pointer to FXdouble.
-*/
-class FXAPI FXRealSlider : public FXFrame {
-  FXDECLARE(FXRealSlider)
-protected:
-  FXdouble      range[2];                 // Reported data range
-  FXdouble      pos;                      // Reported data position
-  FXdouble      incr;                     // Increment when auto-sliding
-  FXdouble      delta;                    // Interval between ticks
-  FXint         headpos;                  // Head position
-  FXint         headsize;                 // Head size
-  FXint         slotsize;                 // Slot size
-  FXColor       slotColor;                // Color of slot the head moves in
-  FXint         dragpoint;                // Where on the head is grabbed
-  FXString      help;                     // Help string
-  FXString      tip;                      // Tip string
-protected:
-  FXRealSlider();
-  void drawSliderHead(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawHorzTicks(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawVertTicks(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-private:
-  FXRealSlider(const FXRealSlider&);
-  FXRealSlider &operator=(const FXRealSlider&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onMouseWheel(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onMiddleBtnPress(FXObject*,FXSelector,void*);
-  long onMiddleBtnRelease(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onAutoSlide(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-  long onCmdSetRealValue(FXObject*,FXSelector,void*);
-  long onCmdGetRealValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntRange(FXObject*,FXSelector,void*);
-  long onCmdGetIntRange(FXObject*,FXSelector,void*);
-  long onCmdSetRealRange(FXObject*,FXSelector,void*);
-  long onCmdGetRealRange(FXObject*,FXSelector,void*);
-  long onCmdSetHelp(FXObject*,FXSelector,void*);
-  long onCmdGetHelp(FXObject*,FXSelector,void*);
-  long onCmdSetTip(FXObject*,FXSelector,void*);
-  long onCmdGetTip(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-public:
-  enum{
-    ID_AUTOSLIDE=FXFrame::ID_LAST,
-    ID_LAST
-    };
-public:
-
-  /// Construct a slider widget
-  FXRealSlider(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=REALSLIDER_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=0,FXint pr=0,FXint pt=0,FXint pb=0);
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Returns true because a slider can receive focus
-  virtual bool canFocus() const;
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Enable the slider
-  virtual void enable();
-
-  /// Disable the slider
-  virtual void disable();
-
-  /// Change slider value
-  void setValue(FXdouble value,FXbool notify=FALSE);
-
-  /// Return slider value
-  FXdouble getValue() const { return pos; }
-
-  /// Change the slider's range
-  void setRange(FXdouble lo,FXdouble hi,FXbool notify=FALSE);
-
-  /// Get the slider's current range
-  void getRange(FXdouble& lo,FXdouble& hi) const { lo=range[0]; hi=range[1]; }
-
-  /// Change the slider style
-  FXuint getSliderStyle() const;
-
-  /// Get the current slider style
-  void setSliderStyle(FXuint style);
-
-  /// Get the slider's head size
-  FXint getHeadSize() const { return headsize; }
-
-  /// Change the slider's head size
-  void setHeadSize(FXint hs);
-
-  /// Get the slider's current slot size
-  FXint getSlotSize() const { return slotsize; }
-
-  /// Change the slider's slot size
-  void setSlotSize(FXint bs);
-
-  /// Get the slider's auto-increment/decrement value
-  FXdouble getIncrement() const { return incr; }
-
-  /// Change the slider's auto-increment/decrement value
-  void setIncrement(FXdouble inc);
-
-  /// Change the delta between ticks
-  void setTickDelta(FXdouble dist);
-
-  /// Get delta between ticks
-  FXdouble getTickDelta() const { return delta; }
-
-  /// Change the color of the slot the slider head moves in
-  void setSlotColor(FXColor clr);
-
-  /// Get the current slot color
-  FXColor getSlotColor() const { return slotColor; }
-
-  /// Set the help text to be displayed on the status line
-  void setHelpText(const FXString& text){ help=text; }
-
-  /// Get the current help text
-  const FXString& getHelpText() const { return help; }
-
-  /// Set the tip text to be displayed in the tooltip
-  void setTipText(const FXString& text){ tip=text; }
-
-  /// Get the current tooltip text value
-  const FXString& getTipText() const { return tip; }
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destroy the slider
-  virtual ~FXRealSlider();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXRealSpinner.h b/fox-includes/FXRealSpinner.h
deleted file mode 100755
index 684151a2..00000000
--- a/fox-includes/FXRealSpinner.h
+++ /dev/null
@@ -1,244 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*             R e a l - V a l u e d   S p i n n e r  W i d g e t                *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2003,2006 by Bill Baxter.   All Rights Reserved.                *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXRealSpinner.h 2360 2006-03-29 04:10:56Z lyle $                     *
-********************************************************************************/
-#ifndef FXREALSPINNER_H
-#define FXREALSPINNER_H
-
-#ifndef FXPACKER_H
-#include "FXPacker.h"
-#endif
-
-namespace FX {
-
-
-/// RealSpinner Options
-enum {
-  REALSPIN_NORMAL  =  0,                /// Normal, non-cyclic
-  REALSPIN_CYCLIC  =  0x00020000,       /// Cyclic spinner
-  REALSPIN_NOTEXT  =  0x00040000,       /// No text visible
-  REALSPIN_NOMAX   =  0x00080000,       /// Spin all the way up to infinity
-  REALSPIN_NOMIN   =  0x00100000,       /// Spin all the way down to -infinity
-  REALSPIN_LOG     =  0x00200000        /// Logarithmic rather than linear
-  };
-
-
-class FXTextField;
-class FXDial;
-
-
-/// Spinner control
-class FXAPI FXRealSpinner : public FXPacker {
-  FXDECLARE(FXRealSpinner)
-protected:
-  FXTextField   *textField;         // Text field
-  FXArrowButton *upButton;          // The up button
-  FXArrowButton *downButton;        // The down button
-  FXdouble       range[2];          // Reported data range
-  FXdouble       incr;              // Increment
-  FXdouble       gran;              // Granularity
-  FXdouble       pos;               // Current position
-protected:
-  FXRealSpinner();
-private:
-  FXRealSpinner(const FXRealSpinner&);
-  FXRealSpinner& operator=(const FXRealSpinner&);
-public:
-  long onUpdIncrement(FXObject*,FXSelector,void*);
-  long onCmdIncrement(FXObject*,FXSelector,void*);
-  long onUpdDecrement(FXObject*,FXSelector,void*);
-  long onCmdDecrement(FXObject*,FXSelector,void*);
-  long onCmdEntry(FXObject*,FXSelector,void*);
-  long onChgEntry(FXObject*,FXSelector,void*);
-  long onWheelEntry(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntRange(FXObject*,FXSelector,void*);
-  long onCmdGetIntRange(FXObject*,FXSelector,void*);
-  long onCmdSetRealValue(FXObject*,FXSelector,void*);
-  long onCmdGetRealValue(FXObject*,FXSelector,void*);
-  long onCmdSetRealRange(FXObject*,FXSelector,void*);
-  long onCmdGetRealRange(FXObject*,FXSelector,void*);
-  long onFocusSelf(FXObject*,FXSelector,void*);
-public:
-  enum{
-    ID_INCREMENT=FXPacker::ID_LAST,
-    ID_DECREMENT,
-    ID_ENTRY,
-    ID_LAST
-    };
-public:
-
-  /// Construct a spinner
-  FXRealSpinner(FXComposite *p,FXint cols,FXObject *tgt=NULL,FXSelector sel=0,FXuint opts=REALSPIN_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Disable spinner
-  virtual void disable();
-
-  /// Enable spinner
-  virtual void enable();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Increment spinner
-  void increment(FXbool notify=FALSE);
-
-  /// Increment spinner by certain amount
-  void incrementByAmount(FXdouble amount,FXbool notify=FALSE);
-
-  /// Decrement spinner
-  void decrement(FXbool notify=FALSE);
-
-  /// Decrement spinner by certain amount
-  void decrementByAmount(FXdouble amount, FXbool notify=FALSE);
-
-  /// Return TRUE if in cyclic mode
-  FXbool isCyclic() const;
-
-  /// Set to cyclic mode, i.e. wrap around at maximum/minimum
-  void setCyclic(FXbool cyclic);
-
-  /// Return TRUE if text is visible
-  FXbool isTextVisible() const;
-
-  /// Set text visible flag
-  void setTextVisible(FXbool shown);
-
-  /// Change current value
-  virtual void setValue(FXdouble value,FXbool notify=FALSE);
-
-  /// Return current value
-  FXdouble getValue() const { return pos; }
-
-  /// Change the spinner's range
-  void setRange(FXdouble lo,FXdouble hi,FXbool notify=FALSE);
-
-  /// Get the spinner's current range
-  void getRange(FXdouble& lo,FXdouble& hi) const { lo=range[0]; hi=range[1]; }
-
-  /// Change spinner increment
-  void setIncrement(FXdouble increment);
-
-  /// Return spinner increment
-  FXdouble getIncrement() const { return incr; }
-
-  /// Change spinner granularity
-  void setGranularity(FXdouble gr);
-
-  /// Return spinner granularity
-  FXdouble getGranularity() const { return gran; }
-
-  /// Set the text font
-  void setFont(FXFont *fnt);
-
-  /// Get the text font
-  FXFont *getFont() const;
-
-  /// Set the status line help text for this spinner
-  void setHelpText(const FXString& text);
-
-  /// Get the status line help text for this spinner
-  const FXString& getHelpText() const;
-
-  /// Set the tool tip message for this spinner
-  void setTipText(const FXString& text);
-
-  /// Get the tool tip message for this spinner
-  const FXString& getTipText() const;
-
-  /// Change spinner style
-  void setSpinnerStyle(FXuint style);
-
-  /// Return current spinner style
-  FXuint getSpinnerStyle() const;
-
-  /// Allow editing of the text field
-  void setEditable(FXbool edit=TRUE);
-
-  /// Return TRUE if text field is editable
-  FXbool isEditable() const;
-
-  /// Change color of the up arrow
-  void setUpArrowColor(FXColor clr);
-
-  /// Return color of the up arrow
-  FXColor getUpArrowColor() const;
-
-  /// Change color of the down arrow
-  void setDownArrowColor(FXColor clr);
-
-  /// Return color of the the down arrow
-  FXColor getDownArrowColor() const;
-
-  /// Change text color
-  void setTextColor(FXColor clr);
-
-  /// Return text color
-  FXColor getTextColor() const;
-
-  /// Change selected background color
-  void setSelBackColor(FXColor clr);
-
-  /// Return selected background color
-  FXColor getSelBackColor() const;
-
-  /// Change selected text color
-  void setSelTextColor(FXColor clr);
-
-  /// Return selected text color
-  FXColor getSelTextColor() const;
-
-  /// Changes the cursor color
-  void setCursorColor(FXColor clr);
-
-  /// Return the cursor color
-  FXColor getCursorColor() const;
-
-  /// Change width of text field in terms of number of columns * `m'
-  void setNumColumns(FXint cols);
-
-  /// Return number of columns
-  FXint getNumColumns() const;
-
-  /// Save spinner to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load spinner from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXRealSpinner();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXRecentFiles.h b/fox-includes/FXRecentFiles.h
deleted file mode 100755
index e907e2ff..00000000
--- a/fox-includes/FXRecentFiles.h
+++ /dev/null
@@ -1,145 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                     R e c e n t   F i l e s   L i s t                         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXRecentFiles.h 2272 2005-12-02 02:11:23Z lyle $                     *
-********************************************************************************/
-#ifndef FXRECENTFILES_H
-#define FXRECENTFILES_H
-
-#ifndef FXOBJECT_H
-#include "FXObject.h"
-#endif
-
-namespace FX {
-
-
-class FXApp;
-
-
-/**
-* The recent files object manages a most recently used (MRU) file list by
-* means of the standard system registry.
-* When connected to a widget, like a menu command, the recent files object
-* updates the menu commands label to the associated recent file name; when
-* the menu command is invoked, the recent file object sends its target a
-* SEL_COMMAND message with the message data set to the associated file name,
-* of the type const char*.
-* When adding or removing file names, the recent files object automatically
-* updates the system registry to record these changes.
-*/
-class FXAPI FXRecentFiles : public FXObject {
-  FXDECLARE(FXRecentFiles)
-private:
-  FXApp      *app;            // Backlink to application
-  FXObject   *target;         // Target object to send message
-  FXSelector  message;        // Message to send
-  FXString    group;          // MRU File group
-  FXint       maxfiles;       // Maximum number of files to track
-private:
-  FXRecentFiles(const FXRecentFiles&);
-  FXRecentFiles &operator=(const FXRecentFiles&);
-public:
-  long onCmdClear(FXObject*,FXSelector,void*);
-  long onCmdFile(FXObject*,FXSelector,void*);
-  long onUpdFile(FXObject*,FXSelector,void*);
-  long onUpdAnyFiles(FXObject*,FXSelector,void*);
-public:
-  enum{
-    ID_CLEAR,
-    ID_ANYFILES,
-    ID_FILE_1,
-    ID_FILE_2,
-    ID_FILE_3,
-    ID_FILE_4,
-    ID_FILE_5,
-    ID_FILE_6,
-    ID_FILE_7,
-    ID_FILE_8,
-    ID_FILE_9,
-    ID_FILE_10,
-    ID_LAST
-    };
-public:
-
-  /// Make new recent files group, using global application instance
-  FXRecentFiles();
-
-  /// Make new recent files group with default groupname
-  FXRecentFiles(FXApp* a);
-
-  /// Make new recent files group with groupname gp
-  FXRecentFiles(FXApp* a,const FXString& gp,FXObject *tgt=NULL,FXSelector sel=0);
-
-  /// Get application
-  FXApp* getApp() const { return app; }
-
-  /// Change number of files we're tracking
-  void setMaxFiles(FXint mx){ maxfiles=mx; }
-
-  /// Return the maximum number of files being tracked
-  FXint getMaxFiles() const { return maxfiles; }
-
-  /// Set group name
-  void setGroupName(const FXString& name){ group=name; }
-
-  /// Return group name
-  FXString getGroupName() const { return group; }
-
-  /// Change the target
-  void setTarget(FXObject *t){ target=t; }
-
-  /// Get the target
-  FXObject *getTarget() const { return target; }
-
-  /// Change the message
-  void setSelector(FXSelector sel){ message=sel; }
-
-  /// Return the message id
-  FXSelector getSelector() const { return message; }
-
-  /// Obtain the filename at index
-  FXString getFile(FXint index) const;
-
-  /// Change the filename at index
-  void setFile(FXint index,const FXString& filename);
-
-  /// Append a file
-  void appendFile(const FXString& filename);
-
-  /// Remove a file
-  void removeFile(const FXString& filename);
-
-  /// Clear the list of files
-  void clear();
-
-  /// Save to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXRecentFiles();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXRectangle.h b/fox-includes/FXRectangle.h
deleted file mode 100755
index 2690aa8b..00000000
--- a/fox-includes/FXRectangle.h
+++ /dev/null
@@ -1,129 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                          R e c t a n g l e    C l a s s                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1994,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXRectangle.h 2344 2006-02-12 21:19:36Z lyle $                       *
-********************************************************************************/
-#ifndef FXRECTANGLE_H
-#define FXRECTANGLE_H
-
-
-#ifndef FXPOINT_H
-#include "FXPoint.h"
-#endif
-
-
-namespace FX {
-
-
-/// Rectangle
-class FXAPI FXRectangle {
-public:
-  FXshort x;
-  FXshort y;
-  FXshort w;
-  FXshort h;
-public:
-
-  /// Constructors
-  FXRectangle(){ }
-  FXRectangle(FXshort xx,FXshort yy,FXshort ww,FXshort hh):x(xx),y(yy),w(ww),h(hh){ }
-  FXRectangle(const FXPoint& p,const FXSize& s):x(p.x),y(p.y),w(s.w),h(s.h){ }
-  FXRectangle(const FXPoint& topleft,const FXPoint& bottomright):x(topleft.x),y(topleft.y),w(bottomright.x-topleft.x+1),h(bottomright.y-topleft.y+1){ }
-
-  /// Test if empty
-  bool empty() const { return w<=0 || h<=0; }
-
-  /// Test if zero
-  bool operator!() const { return x==0 && y==0 && w==0 && h==0; }
-
-  /// Equality
-  bool operator==(const FXRectangle& r) const { return x==r.x && y==r.y && w==r.w && h==r.h; }
-  bool operator!=(const FXRectangle& r) const { return x!=r.x || y!=r.y || w!=r.w || h!=r.h; }
-
-  /// Point in rectangle
-  bool contains(const FXPoint& p) const { return x<=p.x && y<=p.y && p.x<x+w && p.y<y+h; }
-  bool contains(FXshort xx,FXshort yy) const { return x<=xx && y<=yy && xx<x+w && yy<y+h; }
-
-  /// Rectangle properly contained in rectangle
-  bool contains(const FXRectangle& r) const { return x<=r.x && y<=r.y && r.x+r.w<=x+w && r.y+r.h<=y+h; }
-
-  /// Rectangles overlap
-  friend inline bool overlap(const FXRectangle& a,const FXRectangle& b);
-
-  /// Return moved rectangle
-  FXRectangle& move(const FXPoint& p){ x+=p.x; y+=p.y; return *this; }
-  FXRectangle& move(FXshort dx,FXshort dy){ x+=dx; y+=dy; return *this; }
-
-  /// Grow by amount
-  FXRectangle& grow(FXshort margin);
-  FXRectangle& grow(FXshort hormargin,FXshort vermargin);
-  FXRectangle& grow(FXshort leftmargin,FXshort rightmargin,FXshort topmargin,FXshort bottommargin);
-
-  /// Shrink by amount
-  FXRectangle& shrink(FXshort margin);
-  FXRectangle& shrink(FXshort hormargin,FXshort vermargin);
-  FXRectangle& shrink(FXshort leftmargin,FXshort rightmargin,FXshort topmargin,FXshort bottommargin);
-
-  /// Corners
-  FXPoint tl() const { return FXPoint(x,y); }
-  FXPoint tr() const { return FXPoint(x+w-1,y); }
-  FXPoint bl() const { return FXPoint(x,y+h-1); }
-  FXPoint br() const { return FXPoint(x+w-1,y+h-1); }
-
-  /// Assignment
-  FXRectangle& operator=(const FXRectangle& r){ x=r.x; y=r.y; w=r.w; h=r.h; return *this; }
-
-  /// Set value from another rectangle
-  FXRectangle& set(const FXRectangle& r){ x=r.x; y=r.y; w=r.w; h=r.h; return *this; }
-
-  /// Set from point and size
-  FXRectangle& set(const FXPoint& p,const FXSize& s){ x=p.x; y=p.y; w=s.w; h=s.h; return *this; }
-
-  /// Set from corners
-  FXRectangle& set(const FXPoint& topleft,const FXPoint& bottomright){ x=topleft.x; y=topleft.y; w=bottomright.x-topleft.x+1; h=bottomright.y-topleft.y+1; return *this; }
-
-  /// Set value from components
-  FXRectangle& set(FXshort xx,FXshort yy,FXshort ww,FXshort hh){ x=xx; y=yy; w=ww; h=hh; return *this; }
-
-  /// Union and intersection with rectangle
-  FXRectangle& operator+=(const FXRectangle &r);
-  FXRectangle& operator*=(const FXRectangle &r);
-
-  /// Union and intersection between rectangles
-  FXRectangle operator+(const FXRectangle& r) const;
-  FXRectangle operator*(const FXRectangle& r) const;
-
-  /// Save object to a stream
-  friend FXAPI FXStream& operator<<(FXStream& store,const FXRectangle& r);
-
-  /// Load object from a stream
-  friend FXAPI FXStream& operator>>(FXStream& store,FXRectangle& r);
-  };
-
-
-inline bool overlap(const FXRectangle& a,const FXRectangle& b){ return b.x<a.x+a.w && b.y<a.y+a.h && a.x<b.x+b.w && a.y<b.y+b.h; }
-
-extern FXAPI FXStream& operator<<(FXStream& store,const FXRectangle& r);
-extern FXAPI FXStream& operator>>(FXStream& store,FXRectangle& r);
-
-}
-
-#endif
diff --git a/fox-includes/FXRegion.h b/fox-includes/FXRegion.h
deleted file mode 100755
index 640bbf6c..00000000
--- a/fox-includes/FXRegion.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                      C l i p p i n g   R e g i o n                            *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2000,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXRegion.h 2344 2006-02-12 21:19:36Z lyle $                          *
-********************************************************************************/
-#ifndef FXREGION_H
-#define FXREGION_H
-
-namespace FX {
-
-/// Region
-class FXAPI FXRegion {
-  friend class FXDC;
-  friend class FXDCWindow;
-  friend class FXWindow;
-private:
-  void *region;
-public:
-
-  /// Construct new empty region
-  FXRegion();
-
-  /// Construct new region copied from region r
-  FXRegion(const FXRegion& r);
-
-  /// Construct new region from rectangle rect
-  FXRegion(const FXRectangle& rect);
-
-  /// Construct rectangle region
-  FXRegion(FXint x,FXint y,FXint w,FXint h);
-
-  /// Construct polygon region
-  FXRegion(const FXPoint* points,FXuint npoints,bool winding=false);
-
-  /// Assign region r to this one
-  FXRegion &operator=(const FXRegion& r);
-
-  /// Return true if region is empty
-  bool empty() const;
-
-  /// Return true if region contains point
-  bool contains(FXint x,FXint y) const;
-
-  /// Return true if region contains rectangle
-  bool contains(FXint x,FXint y,FXint w,FXint h) const;
-
-  /// Return bounding box
-  FXRectangle bounds() const;
-
-  /// Offset region by dx,dy
-  FXRegion& offset(FXint dx,FXint dy);
-
-  /// Return true if region equal to this one
-  bool operator==(const FXRegion& r) const;
-
-  /// Return true if region not equal to this one
-  bool operator!=(const FXRegion& r) const;
-
-  /// Union region r with this one
-  FXRegion& operator+=(const FXRegion& r);
-
-  /// Intersect region r with this one
-  FXRegion& operator*=(const FXRegion& r);
-
-  /// Subtract region r from this one
-  FXRegion& operator-=(const FXRegion& r);
-
-  /// Xor region r with this one
-  FXRegion& operator^=(const FXRegion& r);
-
-  /// Union of this region and region r
-  FXRegion operator+(const FXRegion& r) const;
-
-  /// Intersection of this region and region r
-  FXRegion operator*(const FXRegion& r) const;
-
-  /// Subtract region r from this region
-  FXRegion operator-(const FXRegion& r) const;
-
-  /// Xor of this region and region r
-  FXRegion operator^(const FXRegion& r) const;
-
-  /// Reset region to empty
-  void reset();
-
-  /// Destroy region
- ~FXRegion();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXRegistry.h b/fox-includes/FXRegistry.h
deleted file mode 100755
index 7e38984d..00000000
--- a/fox-includes/FXRegistry.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                           R e g i s t r y   C l a s s                         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXRegistry.h 2344 2006-02-12 21:19:36Z lyle $                        *
-********************************************************************************/
-#ifndef FXREGISTRY_H
-#define FXREGISTRY_H
-
-#ifndef FXSETTINGS_H
-#include "FXSettings.h"
-#endif
-
-namespace FX {
-
-
-/**
-* The registry maintains a database of persistent settings for an application.
-* The settings database is organized in two groups of three layers each.  The
-* system-wide settings group contains settings information pertaining to all
-* users on a system.  The per-user settings group contains settings affecting
-* that user only.
-* Each settings group contains a desktop layer, which comprises the settings
-* which affect all FOX programs, a vendor layer which holds settings that
-* affect all applications from that vendor (e.g. a application-suite), and
-* an application layer which holds settings only for a single application.
-* The vendor-key and application-key determine which files these layers come
-* from, while the "Desktop" key is used for all FOX applications.
-* Settings in the system-wide group are overwritten by the per-user group,
-* and settings from the "Desktop" layer are overwritten by the vendor-layer;
-* vendor-layer settings are overwritten by the application-layer settings.
-* Only the per-user, per-application settings ever gets written; the layers
-* in the system-group only get written during installation and configuration
-* of the application.
-* The registry is read when FXApp::init() is called, and written back to the
-* system when FXApp::exit() is called.
-*/
-class FXAPI FXRegistry : public FXSettings {
-  FXDECLARE(FXRegistry)
-protected:
-  FXString applicationkey;  // Application key
-  FXString vendorkey;       // Vendor key
-  bool     ascii;           // ASCII file-based registry
-protected:
-  bool readFromDir(const FXString& dirname,bool mark);
-#ifdef WIN32
-  bool readFromRegistry(void* hRootKey,bool mark);
-  bool writeToRegistry(void* hRootKey);
-  bool readFromRegistryGroup(void* org,const char* groupname,bool mark=false);
-  bool writeToRegistryGroup(void* org,const char* groupname);
-#endif
-private:
-  FXRegistry(const FXRegistry&);
-  FXRegistry &operator=(const FXRegistry&);
-public:
-
-  /**
-  * Construct registry object; akey and vkey must be string constants.
-  * Regular applications SHOULD set a vendor key!
-  */
-  FXRegistry(const FXString& akey=FXString::null,const FXString& vkey=FXString::null);
-
-  /// Read registry
-  bool read();
-
-  /// Write registry
-  bool write();
-
-  /// Return application key
-  const FXString& getAppKey() const { return applicationkey; }
-
-  /// Return vendor key
-  const FXString& getVendorKey() const { return vendorkey; }
-
-  /**
-  * Set ASCII mode; under MS-Windows, this will switch the system to a
-  * file-based registry system, instead of using the System Registry API.
-  */
-  void setAsciiMode(bool asciiMode){ ascii=asciiMode; }
-
-  /// Get ASCII mode
-  bool getAsciiMode() const { return ascii; }
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXReplaceDialog.h b/fox-includes/FXReplaceDialog.h
deleted file mode 100755
index 52a4b7d6..00000000
--- a/fox-includes/FXReplaceDialog.h
+++ /dev/null
@@ -1,135 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                      T e x t   R e p l a c e   D i a l o g                    *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2000,2002 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXReplaceDialog.h 809 2002-07-11 17:28:15Z lyle $                   *
-********************************************************************************/
-#ifndef FXREPLACEDIALOG_H
-#define FXREPLACEDIALOG_H
-
-#ifndef FXDIALOGBOX_H
-#include "FXDialogBox.h"
-#endif
-
-namespace FX {
-
-
-class FXButton;
-class FXLabel;
-class FXTextField;
-class FXHorizontalFrame;
-
-
-/// Text replace dialog
-class FXAPI FXReplaceDialog : public FXDialogBox {
-  FXDECLARE(FXReplaceDialog)
-protected:
-  FXLabel           *searchlabel;
-  FXTextField       *searchtext;
-  FXHorizontalFrame *searchbox;
-  FXLabel           *replacelabel;
-  FXTextField       *replacetext;
-  FXHorizontalFrame *replacebox;
-  FXButton          *accept;
-  FXButton          *cancel;
-  FXButton          *every;
-  FXuint             searchmode;
-  FXuint             current;
-protected:
-  FXReplaceDialog(){}
-  void appendHistory(const FXString& search,const FXString& replace,FXuint mode);
-private:
-  FXReplaceDialog(const FXReplaceDialog&);
-  FXReplaceDialog &operator=(const FXReplaceDialog&);
-public:
-  long onCmdAll(FXObject*,FXSelector,void*);
-  long onCmdNext(FXObject*,FXSelector,void*);
-  long onUpdDir(FXObject*,FXSelector,void*);
-  long onCmdDir(FXObject*,FXSelector,void*);
-  long onUpdMode(FXObject*,FXSelector,void*);
-  long onCmdMode(FXObject*,FXSelector,void*);
-  long onSearchKey(FXObject*,FXSelector,void*);
-  long onReplaceKey(FXObject*,FXSelector,void*);
-  long onCmdSearchHist(FXObject*,FXSelector,void*);
-  long onCmdReplaceHist(FXObject*,FXSelector,void*);
-  long onCmdAccept(FXObject*,FXSelector,void*);
-public:
-  enum{
-    ID_NEXT=FXDialogBox::ID_LAST,
-    ID_PREV,
-    ID_SEARCH_UP,
-    ID_SEARCH_DN,
-    ID_REPLACE_UP,
-    ID_REPLACE_DN,
-    ID_ALL,
-    ID_DIR,
-    ID_SEARCH_TEXT,
-    ID_REPLACE_TEXT,
-    ID_MODE,
-    ID_LAST=ID_MODE+32
-    };
-public:
-  enum {
-    DONE          = 0,    /// Cancel search
-    SEARCH        = 1,    /// Search first occurrence
-    REPLACE       = 1,    /// Replace first occurrence
-    SEARCH_NEXT   = 2,    /// Search next occurrence
-    REPLACE_NEXT  = 2,    /// Replace next occurrence
-    REPLACE_ALL   = 3     /// Replace all occurrences
-    };
-public:
-
-  /// Construct search and replace dialog box
-  FXReplaceDialog(FXWindow* owner,const FXString& caption,FXIcon* ic=NULL,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Set text or pattern to search for
-  void setSearchText(const FXString& text);
-
-  /// Return text or pattern the user has entered
-  FXString getSearchText() const;
-
-  /// Set replace text
-  void setReplaceText(const FXString& text);
-
-  /// Return replace text the user has entered
-  FXString getReplaceText() const;
-
-  /// Set search match mode
-  void setSearchMode(FXuint mode){ searchmode=mode; }
-
-  /// Return search mode the user has selected
-  FXuint getSearchMode() const { return searchmode; }
-
-  /// Run modal invocation of the dialog
-  virtual FXuint execute(FXuint placement=PLACEMENT_CURSOR);
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXReplaceDialog();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXRex.h b/fox-includes/FXRex.h
deleted file mode 100755
index 4d90e097..00000000
--- a/fox-includes/FXRex.h
+++ /dev/null
@@ -1,180 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                 R e g u l a r   E x p r e s s i o n   C l a s s               *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1999,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXRex.h 2343 2006-02-12 20:26:26Z lyle $                             *
-********************************************************************************/
-#ifndef FXREX_H
-#define FXREX_H
-
-
-namespace FX {
-
-
-/// Regular expression error codes
-enum FXRexError {
-  REGERR_OK,
-  REGERR_EMPTY,             /// Empty pattern
-  REGERR_PAREN,             /// Unmatched parenthesis
-  REGERR_BRACK,             /// Unmatched bracket
-  REGERR_BRACE,             /// Unmatched brace
-  REGERR_RANGE,             /// Bad character range
-  REGERR_ESC,               /// Bad escape sequence
-  REGERR_COUNT,             /// Bad counted repeat
-  REGERR_NOATOM,            /// No atom preceding repetition
-  REGERR_REPEAT,            /// Repeat following repeat
-  REGERR_BACKREF,           /// Bad backward reference
-  REGERR_CLASS,             /// Bad character class
-  REGERR_COMPLEX,           /// Expression too complex
-  REGERR_MEMORY,            /// Out of memory
-  REGERR_TOKEN              /// Illegal token
-  };
-
-
-/// Regular expression parse flags
-enum {
-  REX_NORMAL    = 0,        /// Normal mode
-  REX_CAPTURE   = 1,        /// Perform capturing parentheses
-  REX_ICASE     = 2,        /// Case independent matching
-  REX_NEWLINE   = 4,        /// Match-any operators match newline too
-  REX_VERBATIM  = 8,        /// Disable interpretation of magic characters
-  REX_SYNTAX    = 16        /// Perform syntax check only
-  };
-
-
-/// Regular expression match flags
-enum {
-  REX_FORWARD   = 0,        /// Match scanning forward from offset
-  REX_BACKWARD  = 32,       /// Match scanning backward from offset
-  REX_NOT_BOL   = 64,       /// Start of string is NOT begin of line
-  REX_NOT_EOL   = 128,      /// End of string is NOT end of line
-  REX_NOT_EMPTY = 256       /// Do not match empty
-  };
-
-
-/**
-* FXRex is a regular expression class implementing a NFA matcher.
-* It supports capturing parentheses, non-capturing parentheses,
-* positive or negative lookahead, backreferences, case-insensitive
-* matching, counted repetitions, lazy or greedy matches, and
-* PERL-like matching operators.
-* The subject string may be scanned forwards or backwards, and may
-* contain any of 256 possible character values.
-*
-* When parsing a regular expression pattern, the mode parameter is
-* the bitwise OR of a set of flags and affects the match algorithm.
-* Passing the flag REX_CAPTURE enables capturing parentheses
-* and back references. The flag REX_ICASE enables case-insensitive
-* matching. When the flag REX_NEWLINE is passed, newlines are treated
-* like normal characters; otherwise, newline is NOT matched
-* except when explicitly part of a character class. The flag
-* REX_VERBATIM disables all special character interpretation.
-*
-* When matching a compiled pattern, the mode parameter is the
-* bitwise OR of a set of flags that affects how the match is
-* performed.  Passing the flag REX_BACKWARD causes the match
-* to proceed backwards through the subject string.  Passing the
-* flags REX_NOT_BOL and/or REX_NOT_EOL causes the begin and
-* end of the subject string NOT to be considered a line start
-* or line end. The flag REX_NOT_EMPTY causes a match to fail if
-* the empty string was matched.
-*/
-class FXAPI FXRex {
-private:
-  FXint *code;
-private:
-  static const FXchar *const errors[];
-  static const FXint fallback[];
-public:
-
-  /// Construct empty regular expression object
-  FXRex():code((FXint*)fallback){}
-
-  /// Copy regular expression object
-  FXRex(const FXRex& orig);
-
-  /// Compile expression from pattern; if error is not NULL, error code is returned
-  FXRex(const FXchar* pattern,FXint mode=REX_NORMAL,FXRexError* error=NULL);
-
-  /// Compile expression from pattern; if error is not NULL, error code is returned
-  FXRex(const FXString& pattern,FXint mode=REX_NORMAL,FXRexError* error=NULL);
-
-  /// Assign another regular expression to this one
-  FXRex& operator=(const FXRex& orig);
-
-  /**
-  * See if regular expression is empty; the regular expression
-  * will be empty when it is unable to parse a pattern due to
-  * a syntax error.
-  */
-  bool empty() const { return (code==fallback); }
-
-  /// Parse pattern, return error code if syntax error is found
-  FXRexError parse(const FXchar* pattern,FXint mode=REX_NORMAL);
-
-  /// Parse pattern, return error code if syntax error is found
-  FXRexError parse(const FXString& pattern,FXint mode=REX_NORMAL);
-
-  /**
-  * Match a subject string of length len, returning TRUE if a match is found
-  * and FALSE otherwise.  The entire pattern is captured in beg[0] and end[0],
-  * where beg[0] refers to the position of the first matched character and end[0]
-  * refers to the position after the last matched character.
-  * Sub expressions from capturing parenthesis i are returned in beg[i] and end[i].
-  */
-  bool match(const FXchar* string,FXint len,FXint* beg=NULL,FXint* end=NULL,FXint mode=REX_FORWARD,FXint npar=1,FXint fm=0,FXint to=2147483647) const;
-
-  /// Search for match in a string
-  bool match(const FXString& string,FXint* beg=NULL,FXint* end=NULL,FXint mode=REX_FORWARD,FXint npar=1,FXint fm=0,FXint to=2147483647) const;
-
-  /**
-  * After performing a regular expression match with capturing parentheses,
-  * a substitution string is build from the replace string, where where "&"
-  * is replaced by the entire matched pattern, and "\1" through "\9" are
-  * replaced by captured expressions.  The original source string and its
-  * length, and the match arrays beg and end must be passed.
-  */
-  static FXString substitute(const FXchar* string,FXint len,FXint* beg,FXint* end,const FXString& replace,FXint npar=1);
-
-  /// Return substitution string
-  static FXString substitute(const FXString& string,FXint* beg,FXint* end,const FXString& replace,FXint npar=1);
-
-  /// Returns error code for given error
-  static const FXchar* getError(FXRexError err){ return errors[err]; }
-
-  /// Comparison operators
-  bool operator==(const FXRex& rex) const;
-  bool operator!=(const FXRex& rex) const;
-
-  /// Saving and loading
-  friend FXAPI FXStream& operator<<(FXStream& store,const FXRex& s);
-  friend FXAPI FXStream& operator>>(FXStream& store,FXRex& s);
-
-  /// Delete
- ~FXRex();
-  };
-
-
-extern FXAPI FXStream& operator<<(FXStream& store,const FXRex& s);
-extern FXAPI FXStream& operator>>(FXStream& store,FXRex& s);
-
-}
-
-#endif
diff --git a/fox-includes/FXRootWindow.h b/fox-includes/FXRootWindow.h
deleted file mode 100755
index 29688548..00000000
--- a/fox-includes/FXRootWindow.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                     R o o t   W i n d o w   W i d g e t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2003 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXRootWindow.h 1641 2003-07-09 19:55:56Z lyle $                      *
-********************************************************************************/
-#ifndef FXROOTWINDOW_H
-#define FXROOTWINDOW_H
-
-#ifndef FXCOMPOSITE_H
-#include "FXComposite.h"
-#endif
-
-namespace FX {
-
-
-/// Root window
-class FXAPI FXRootWindow : public FXComposite {
-  FXDECLARE(FXRootWindow)
-protected:
-  FXRootWindow(){}
-#ifdef WIN32
-  virtual FXID GetDC() const;
-  virtual int ReleaseDC(FXID) const;
-#endif
-private:
-  FXRootWindow(const FXRootWindow&);
-  FXRootWindow &operator=(const FXRootWindow&);
-public:
-
-  /// Construct root window
-  FXRootWindow(FXApp* a,FXVisual *vis);
-
-  /// Root window need not be created
-  virtual void create();
-
-  /// Root window may not be detached
-  virtual void detach();
-
-  /// Root window can not be destroyed
-  virtual void destroy();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return width of the root window
-  virtual FXint getDefaultWidth();
-
-  /// Return height of the root window
-  virtual FXint getDefaultHeight();
-
-  /// No op
-  virtual void recalc();
-
-  /// Root window can not be moved
-  virtual void move(FXint x,FXint y);
-
-  /// Root window can not be resized
-  virtual void resize(FXint w,FXint h);
-
-  /// Root window can not be positioned
-  virtual void position(FXint x,FXint y,FXint w,FXint h);
-
-  /// Root window can not get focus
-  virtual void setFocus();
-
-  /// Root window can not loose
-  virtual void killFocus();
-
-  /// Destructor
-  virtual ~FXRootWindow();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXRuler.h b/fox-includes/FXRuler.h
deleted file mode 100755
index da740e39..00000000
--- a/fox-includes/FXRuler.h
+++ /dev/null
@@ -1,282 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                            R u l e r   W i d g e t                            *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2002,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXRuler.h 2344 2006-02-12 21:19:36Z lyle $                           *
-********************************************************************************/
-#ifndef FXRULER_H
-#define FXRULER_H
-
-#ifndef FXFRAME_H
-#include "FXFrame.h"
-#endif
-
-namespace FX {
-
-
-/// Ruler options
-enum {
-  RULER_NORMAL        = 0,                                      /// Default appearance (default)
-  RULER_HORIZONTAL    = 0,                                      /// Ruler is horizontal (default)
-  RULER_VERTICAL      = 0x00008000,                             /// Ruler is vertical
-  RULER_TICKS_OFF     = 0,                                      /// Tick marks off (default)
-  RULER_TICKS_TOP     = 0x00010000,                             /// Ticks on the top (if horizontal)
-  RULER_TICKS_BOTTOM  = 0x00020000,                             /// Ticks on the bottom (if horizontal)
-  RULER_TICKS_LEFT    = RULER_TICKS_TOP,                        /// Ticks on the left (if vertical)
-  RULER_TICKS_RIGHT   = RULER_TICKS_BOTTOM,                     /// Ticks on the right (if vertical)
-  RULER_TICKS_CENTER  = RULER_TICKS_TOP|RULER_TICKS_BOTTOM,     /// Tickmarks centered
-  RULER_NUMBERS       = 0x00040000,                             /// Show numbers
-  RULER_ARROW         = 0x00080000,                             /// Draw small arrow for cursor position
-  RULER_MARKERS       =  0x00100000,                            /// Draw markers for indentation settings
-  RULER_METRIC        = 0,                                      /// Metric subdivision (default)
-  RULER_ENGLISH       = 0x00200000,                             /// English subdivision
-  RULER_MARGIN_ADJUST = 0x00400000,                             /// Allow margin adjustment
-  RULER_ALIGN_CENTER  = 0,                                      /// Center document horizontally
-  RULER_ALIGN_LEFT    = 0x00800000,                             /// Align document to the left
-  RULER_ALIGN_RIGHT   = 0x01000000,                             /// Align document to the right
-  RULER_ALIGN_TOP     = RULER_ALIGN_LEFT,                       /// Align document to the top
-  RULER_ALIGN_BOTTOM  = RULER_ALIGN_RIGHT,                      /// Align document to the bottom
-  RULER_ALIGN_STRETCH = RULER_ALIGN_LEFT|RULER_ALIGN_RIGHT,     /// Stretch document to fit horizontally
-  RULER_ALIGN_NORMAL  = RULER_ALIGN_CENTER                      /// Normally, document is centered both ways
-  };
-
-
-class FXFont;
-
-
-/**
-* The ruler widget is placed alongside a document to measure position
-* and size of entities within the document, such as margins, paragraph
-* indents, and tickmarks.
-* The ruler widget sends a SEL_CHANGED when the indentation or margins
-* are interactively changed by the user.
-* If the document size exceeds the available space, it is possible to
-* scroll the document using setPosition().  When the document size is
-* less than the available space, the alignment options can be used to
-* center, left-adjust, or right-adjust the document.
-* Finally, a special option exists to stretch the document to the
-* available space, that is to say, the document will always be fitten
-* with given left and right edges substracted from the available space.
-*/
-class FXAPI FXRuler : public FXFrame {
-  FXDECLARE(FXRuler)
-protected:
-  FXFont  *font;                // Font for numbers
-  FXint    documentSize;        // Size of document
-  FXint    edgeSpacing;         // Edge spacing around document
-  FXint    marginLower;         // Lower margin
-  FXint    marginUpper;         // Upper margin
-  FXint    indentFirst;         // First line paragraph indent
-  FXint    indentLower;         // Lower paragraph indent
-  FXint    indentUpper;         // Upper paragraph indent
-  FXdouble pixelPerTick;        // Number of pixels per tick increment
-  FXint    numberTicks;         // Tick increments between numbers
-  FXint    majorTicks;          // Tick increments between major ticks
-  FXint    mediumTicks;         // Tick increments between medium ticks
-  FXint    tinyTicks;           // Tick increments between tiny ticks
-  FXint    arrowPos;            // Arrow position
-  FXColor  textColor;           // Color for numbers and ticks
-  FXint    shift;               // Left edge of content
-  FXint    pos;                 // Scroll position
-  FXint    off;                 // Offset item was grabbed
-  FXString tip;                 // Tooltip text
-  FXString help;                // Help text
-  FXuchar  mode;                // Mode widget is in
-protected:
-  FXRuler();
-  FXint picked(FXint x,FXint y);
-  void drawLeftArrow(FXDCWindow& dc,FXint x,FXint y);
-  void drawRightArrow(FXDCWindow& dc,FXint x,FXint y);
-  void drawUpArrow(FXDCWindow& dc,FXint x,FXint y);
-  void drawDownArrow(FXDCWindow& dc,FXint x,FXint y);
-  void drawLeftMarker(FXDCWindow& dc,FXint x,FXint y);
-  void drawRightMarker(FXDCWindow& dc,FXint x,FXint y);
-  void drawUpMarker(FXDCWindow& dc,FXint x,FXint y);
-  void drawDownMarker(FXDCWindow& dc,FXint x,FXint y);
-protected:
-  enum{
-    MOUSE_NONE,         // No mouse operation
-    MOUSE_MARG_LOWER,   // Drag lower margin
-    MOUSE_MARG_UPPER,   // Drag upper margin
-    MOUSE_PARA_FIRST,   // Drag first indent
-    MOUSE_PARA_LOWER,   // Drag lower indent
-    MOUSE_PARA_UPPER    // Drag upper indent
-    };
-private:
-  FXRuler(const FXRuler&);
-  FXRuler &operator=(const FXRuler&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-  long onCmdSetHelp(FXObject*,FXSelector,void*);
-  long onCmdGetHelp(FXObject*,FXSelector,void*);
-  long onCmdSetTip(FXObject*,FXSelector,void*);
-  long onCmdGetTip(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-public:
-  enum{
-    ID_ARROW=FXFrame::ID_LAST,
-    ID_LAST
-    };
-public:
-
-  /// Construct label with given text and icon
-  FXRuler(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=RULER_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Set the current position
-  void setPosition(FXint pos,FXbool notify=FALSE);
-
-  /// Return the current position
-  FXint getPosition() const { return pos; }
-
-  /// Change/return content size
-  void setContentSize(FXint size,FXbool notify=FALSE);
-  FXint getContentSize() const;
-
-  /// Get lower edge of document
-  FXint getDocumentLower() const;
-
-  /// Get upper edge of document
-  FXint getDocumentUpper() const;
-
-  /// Change/return document size
-  void setDocumentSize(FXint size,FXbool notify=FALSE);
-  FXint getDocumentSize() const { return documentSize; }
-
-  /// Change/return document edge spacing
-  void setEdgeSpacing(FXint space,FXbool notify=FALSE);
-  FXint getEdgeSpacing() const { return edgeSpacing; }
-
-  /// Change/return lower document margin
-  void setMarginLower(FXint mgn,FXbool notify=FALSE);
-  FXint getMarginLower() const { return marginLower; }
-
-  /// Change/return upper document margin
-  void setMarginUpper(FXint mgn,FXbool notify=FALSE);
-  FXint getMarginUpper() const { return marginUpper; }
-
-  /// Change/return first line indent
-  void setIndentFirst(FXint ind,FXbool notify=FALSE);
-  FXint getIndentFirst() const { return indentFirst; }
-
-  /// Change/return lower indent
-  void setIndentLower(FXint ind,FXbool notify=FALSE);
-  FXint getIndentLower() const { return indentLower; }
-
-  /// Change/return upper indent
-  void setIndentUpper(FXint ind,FXbool notify=FALSE);
-  FXint getIndentUpper() const { return indentUpper; }
-
-  /// Change/return document number placement
-  void setNumberTicks(FXint ticks,FXbool notify=FALSE);
-  FXint getNumberTicks() const { return numberTicks; }
-
-  /// Change/return document major ticks
-  void setMajorTicks(FXint ticks,FXbool notify=FALSE);
-  FXint getMajorTicks() const { return majorTicks; }
-
-  /// Change/return document medium ticks
-  void setMediumTicks(FXint ticks,FXbool notify=FALSE);
-  FXint getMediumTicks() const { return mediumTicks; }
-
-  /// Change/return document tiny ticks
-  void setTinyTicks(FXint ticks,FXbool notify=FALSE);
-  FXint getTinyTicks() const { return tinyTicks; }
-
-  /// Change/return pixel per tick spacing
-  void setPixelPerTick(FXdouble space,FXbool notify=FALSE);
-  FXdouble getPixelPerTick() const { return pixelPerTick; }
-
-  /// Set the text font
-  void setFont(FXFont *fnt,FXbool notify=FALSE);
-
-  /// Get the text font
-  FXFont* getFont() const { return font; }
-
-  /// Change arrow value, relative to document position
-  void setValue(FXint value);
-
-  /// Return arrow value in document
-  FXint getValue() const { return arrowPos; }
-
-  /// Set ruler style
-  void setRulerStyle(FXuint style);
-
-  /// Get ruler style
-  FXuint getRulerStyle() const;
-
-  /// Set ruler alignment
-  void setRulerAlignment(FXuint alignment,FXbool notify=FALSE);
-
-  /// Get ruler alignment
-  FXuint getRulerAlignment() const;
-
-  /// Get the current text color
-  FXColor getTextColor() const { return textColor; }
-
-  /// Set the current text color
-  void setTextColor(FXColor clr);
-
-  /// Set the status line help text for the ruler
-  void setHelpText(const FXString& text){ help=text; }
-
-  /// Get the status line help text for the ruler
-  const FXString& getHelpText() const { return help; }
-
-  /// Set the tool tip message for the ruler
-  void setTipText(const FXString& text){ tip=text; }
-
-  /// Get the tool tip message for the ruler
-  const FXString& getTipText() const { return tip; }
-
-  /// Save label to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load label from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXRuler();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXRulerView.h b/fox-includes/FXRulerView.h
deleted file mode 100644
index b4577b66..00000000
--- a/fox-includes/FXRulerView.h
+++ /dev/null
@@ -1,270 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                         R u l e r V i e w   W i d g e t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2005,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXRulerView.h 2401 2006-04-27 00:46:49Z lyle $                       *
-********************************************************************************/
-#ifndef FXRULERVIEW_H
-#define FXRULERVIEW_H
-
-#ifndef FXSCROLLAREA_H
-#include "FXScrollArea.h"
-#endif
-
-
-namespace FX {
-
-
-class FXRuler;
-class FXFrame;
-
-
-/**
-* The Ruler View provides viewing of a document with rulers.
-* It is intended to be subclassed in order to draw actual contents
-* and provide editing behavior for the document.
-* The ruler view itself simply manages the geometry of the document
-* being edited, and coordinates the movement of the ruler displays
-* as the document is being scrolled.
-*/
-class FXRulerView : public FXScrollArea {
-  FXDECLARE(FXRulerView)
-protected:
-  FXRuler *hruler;      // Horizontal ruler
-  FXRuler *vruler;      // Vertical ruler
-  FXFrame *filler;      // Corner thingy
-  FXColor  docColor;    // Color of document
-  FXString tip;         // Tooltip text
-  FXString help;        // Help text
-protected:
-  FXRulerView();
-  virtual void moveContents(FXint x,FXint y);
-  virtual void drawBackground(FXDCWindow& dc);
-  virtual void drawContents(FXDCWindow& dc);
-private:
-  FXRulerView(const FXRulerView&);
-  FXRulerView &operator=(const FXRulerView&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onCmdSetHelp(FXObject*,FXSelector,void*);
-  long onCmdGetHelp(FXObject*,FXSelector,void*);
-  long onCmdSetTip(FXObject*,FXSelector,void*);
-  long onCmdGetTip(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-  long onDocChanged(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_HRULER=FXScrollArea::ID_LAST,
-    ID_VRULER,
-    ID_LAST
-    };
-public:
-
-  /// Construct a rulerview window
-  FXRulerView(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Return viewport height
-  virtual FXint getViewportHeight();
-
-  /// Return viewport width
-  virtual FXint getViewportWidth();
-
-  /// Return content width
-  virtual FXint getContentWidth();
-
-  /// Return content height
-  virtual FXint getContentHeight();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return a pointer to the horizontal ruler
-  FXRuler* horizontalRuler() const { return hruler; }
-
-  /// Return a pointer to the vertical ruler
-  FXRuler* verticalRuler() const { return vruler; }
-
-  /// Get document position X
-  FXint getDocumentX() const;
-
-  /// Get document position Y
-  FXint getDocumentY() const;
-
-  /// Set document width
-  void setDocumentWidth(FXint w,FXbool notify=FALSE);
-
-  /// Get document width
-  FXint getDocumentWidth() const;
-
-  /// Set document height
-  void setDocumentHeight(FXint h,FXbool notify=FALSE);
-
-  /// Get document height
-  FXint getDocumentHeight() const;
-
-  /// Set the current document color
-  void setDocumentColor(FXColor clr);
-
-  /// Get the current document color
-  FXColor getDocumentColor() const { return docColor; }
-
-  /// Change edge spacing around document
-  void setHEdgeSpacing(FXint es,FXbool notify=FALSE);
-  void setVEdgeSpacing(FXint es,FXbool notify=FALSE);
-
-  /// Return edge spacing
-  FXint getHEdgeSpacing() const;
-  FXint getVEdgeSpacing() const;
-
-  /// Change horizontal lower margin
-  void setHMarginLower(FXint marg,FXbool notify=FALSE);
-
-  /// Change horizontal upper margin
-  void setHMarginUpper(FXint marg,FXbool notify=FALSE);
-
-  /// Get horizontal lower margin
-  FXint getHMarginLower() const;
-
-  /// Get horizontal upper margin
-  FXint getHMarginUpper() const;
-
-  /// Change vertical lower margin
-  void setVMarginLower(FXint marg,FXbool notify=FALSE);
-
-  /// Change vertical upper margin
-  void setVMarginUpper(FXint marg,FXbool notify=FALSE);
-
-  /// Get vertical lower margin
-  FXint getVMarginLower() const;
-
-  /// Get vertical upper margin
-  FXint getVMarginUpper() const;
-
-  /// Set horizontal alignment; the default is RULER_ALIGN_NORMAL
-  void setHAlignment(FXuint align,FXbool notify=FALSE);
-
-  /// Return horizontal alignment
-  FXuint getHAlignment() const;
-
-  /// Set vertical alignment; the default is RULER_ALIGN_NORMAL
-  void setVAlignment(FXuint align,FXbool notify=FALSE);
-
-  /// Return vertical alignment
-  FXuint getVAlignment() const;
-
-  /// Set X arrow position, relative to document position
-  void setArrowPosX(FXint x);
-
-  /// Set X arrow position, relative to document position
-  void setArrowPosY(FXint y);
-
-  /// Get X arrow position in document
-  FXint getArrowPosX() const;
-
-  /// Get Y arrow position in document
-  FXint getArrowPosY() const;
-
-  /// Set the horizontal ruler font
-  void setHRulerFont(FXFont *fnt,FXbool notify=FALSE);
-
-  /// Get the horizontal ruler font
-  FXFont* getHRulerFont() const;
-
-  /// Set the vertical ruler font
-  void setVRulerFont(FXFont *fnt,FXbool notify=FALSE);
-
-  /// Get the vertical ruler font
-  FXFont* getVRulerFont() const;
-
-  /// Change document number placement
-  void setHNumberTicks(FXint ticks,FXbool notify=FALSE);
-  void setVNumberTicks(FXint ticks,FXbool notify=FALSE);
-
-  /// Return document number placement
-  FXint getHNumberTicks() const;
-  FXint getVNumberTicks() const;
-
-  /// Change document major ticks
-  void setHMajorTicks(FXint ticks,FXbool notify=FALSE);
-  void setVMajorTicks(FXint ticks,FXbool notify=FALSE);
-
-  /// Return document major ticks
-  FXint getHMajorTicks() const;
-  FXint getVMajorTicks() const;
-
-  /// Change document medium ticks
-  void setHMediumTicks(FXint ticks,FXbool notify=FALSE);
-  void setVMediumTicks(FXint ticks,FXbool notify=FALSE);
-
-  /// Return document medium ticks
-  FXint getHMediumTicks() const;
-  FXint getVMediumTicks() const;
-
-  /// Change document tiny ticks
-  void setHTinyTicks(FXint ticks,FXbool notify=FALSE);
-  void setVTinyTicks(FXint ticks,FXbool notify=FALSE);
-
-  /// Return document tiny ticks
-  FXint getHTinyTicks() const;
-  FXint getVTinyTicks() const;
-
-  /// Change pixel per tick spacing
-  void setHPixelPerTick(FXdouble space,FXbool notify=FALSE);
-  void setVPixelPerTick(FXdouble space,FXbool notify=FALSE);
-
-  /// Return pixel per tick spacing
-  FXdouble getHPixelPerTick() const;
-  FXdouble getVPixelPerTick() const;
-
-  /// Set ruler style
-  void setHRulerStyle(FXuint style);
-  void setVRulerStyle(FXuint style);
-
-  /// Get ruler style
-  FXuint getHRulerStyle() const;
-  FXuint getVRulerStyle() const;
-
-  /// Set the status line help text for the ruler view
-  void setHelpText(const FXString& text){ help=text; }
-
-  /// Get the status line help text for the ruler view
-  const FXString& getHelpText() const { return help; }
-
-  /// Set the tool tip message for the ruler view
-  void setTipText(const FXString& text){ tip=text; }
-
-  /// Get the tool tip message for the ruler view
-  const FXString& getTipText() const { return tip; }
-
-  /// Save list to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load list from a stream
-  virtual void load(FXStream& store);
-
-  /// Destroy
-  virtual ~FXRulerView();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXScrollArea.h b/fox-includes/FXScrollArea.h
deleted file mode 100755
index 00293507..00000000
--- a/fox-includes/FXScrollArea.h
+++ /dev/null
@@ -1,154 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       S c r o l l A r e a   W i d g e t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2003 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXScrollArea.h 1788 2003-11-11 21:10:44Z lyle $                      *
-********************************************************************************/
-#ifndef FXSCROLLAREA_H
-#define FXSCROLLAREA_H
-
-#ifndef FXCOMPOSITE_H
-#include "FXComposite.h"
-#endif
-
-namespace FX {
-
-
-/// Scrollbar options
-enum {
-  SCROLLERS_NORMAL     = 0,                                 /// Show the scrollbars when needed
-  HSCROLLER_ALWAYS     = 0x00008000,                        /// Always show horizontal scrollers
-  HSCROLLER_NEVER      = 0x00010000,                        /// Never show horizontal scrollers
-  VSCROLLER_ALWAYS     = 0x00020000,                        /// Always show vertical scrollers
-  VSCROLLER_NEVER      = 0x00040000,                        /// Never show vertical scrollers
-  HSCROLLING_ON        = 0,                                 /// Horizontal scrolling turned on (default)
-  HSCROLLING_OFF       = HSCROLLER_NEVER|HSCROLLER_ALWAYS,  /// Horizontal scrolling turned off
-  VSCROLLING_ON        = 0,                                 /// Vertical scrolling turned on (default)
-  VSCROLLING_OFF       = VSCROLLER_NEVER|VSCROLLER_ALWAYS,  /// Vertical scrolling turned off
-  SCROLLERS_TRACK      = 0,                                 /// Scrollers track continuously for smooth scrolling
-  SCROLLERS_DONT_TRACK = 0x00080000                         /// Scrollers don't track continuously
-  };
-
-
-class FXScrollBar;
-class FXScrollCorner;
-
-
-/**
-* The scroll area widget manages a content area and a viewport
-* area through which the content is viewed.  When the content area
-* becomes larger than the viewport area, scrollbars are placed to
-* permit viewing of the entire content by scrolling the content.
-* Depending on the mode, scrollbars may be displayed on an as-needed
-* basis, always, or never.
-* Normally, the scroll area's size and the content's size are independent;
-* however, it is possible to disable scrolling in the horizontal
-* (vertical) direction.  In this case, the content width (height)
-* will influence the width (height) of the scroll area widget.
-* For content which is time-consuming to repaint, continuous
-* scrolling may be turned off.
-*/
-class FXAPI FXScrollArea : public FXComposite {
-  FXDECLARE(FXScrollArea)
-protected:
-  FXScrollBar    *horizontal;   // Horizontal scroll bar
-  FXScrollBar    *vertical;     // Vertical scroll bar
-  FXScrollCorner *corner;       // Scroll corner
-  FXint           viewport_w;   // Viewport width
-  FXint           viewport_h;   // Viewport height
-  FXint           pos_x;        // X scroll position (pos_x<=0)
-  FXint           pos_y;        // Y scroll position (pos_y<=0)
-protected:
-  FXScrollArea();
-  FXbool startAutoScroll(FXEvent *event,FXbool onlywheninside=FALSE);
-  void stopAutoScroll();
-  FXScrollArea(FXComposite* p,FXuint opts,FXint x,FXint y,FXint w,FXint h);
-  virtual void moveContents(FXint x,FXint y);
-private:
-  FXScrollArea(const FXScrollArea&);
-  FXScrollArea &operator=(const FXScrollArea&);
-public:
-  long onHMouseWheel(FXObject*,FXSelector,void*);
-  long onVMouseWheel(FXObject*,FXSelector,void*);
-  long onHScrollerChanged(FXObject*,FXSelector,void*);
-  long onVScrollerChanged(FXObject*,FXSelector,void*);
-  long onHScrollerDragged(FXObject*,FXSelector,void*);
-  long onVScrollerDragged(FXObject*,FXSelector,void*);
-  long onAutoScroll(FXObject*,FXSelector,void*);
-public:
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return viewport height
-  virtual FXint getViewportHeight();
-
-  /// Return viewport width
-  virtual FXint getViewportWidth();
-
-  /// Return content width
-  virtual FXint getContentWidth();
-
-  /// Return content height
-  virtual FXint getContentHeight();
-
-  /// Change scroll style
-  void setScrollStyle(FXuint style);
-
-  /// Return scroll style
-  FXuint getScrollStyle() const;
-
-  /// Return TRUE if horizontally scrollable
-  FXbool isHorizontalScrollable() const;
-
-  /// Return TRUE if vertically scrollable
-  FXbool isVerticalScrollable() const;
-
-  /// Return a pointer to the horizontal scrollbar
-  FXScrollBar* horizontalScrollBar() const { return horizontal; }
-
-  /// Return a pointer to the vertical scrollbar
-  FXScrollBar* verticalScrollBar() const { return vertical; }
-
-  /// Return the current x-position
-  FXint getXPosition() const { return pos_x; }
-
-  /// Return the current y-position
-  FXint getYPosition() const { return pos_y; }
-
-  /// Set the current position
-  void setPosition(FXint x,FXint y);
-
-  /// Get the current position
-  void getPosition(FXint& x,FXint& y) const { x=pos_x; y=pos_y; }
-
-  /// Destructor
-  virtual ~FXScrollArea();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXScrollBar.h b/fox-includes/FXScrollBar.h
deleted file mode 100755
index 2fbf0118..00000000
--- a/fox-includes/FXScrollBar.h
+++ /dev/null
@@ -1,233 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       S c r o l l   B a r   W i d g e t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXScrollBar.h 2273 2005-12-02 02:18:50Z lyle $                       *
-********************************************************************************/
-#ifndef FXSCROLLBAR_H
-#define FXSCROLLBAR_H
-
-#ifndef FXWINDOW_H
-#include "FXWindow.h"
-#endif
-
-
-namespace FX {
-
-
-
-/// ScrollBar styles
-enum {
-  SCROLLBAR_VERTICAL   = 0,             /// Vertically oriented
-  SCROLLBAR_HORIZONTAL = 0x00020000,    /// Horizontally oriented
-  SCROLLBAR_WHEELJUMP  = 0x00040000     /// Mouse wheel jumps instead of sliding smoothly
-  };
-
-
-
-/**
-* The scroll bar is used when a document has a larger content than may be made
-* visible.  The range is the total size of the document, the page is the part
-* of the document which is visible.  The size of the scrollbar thumb is adjusted
-* to give feedback of the relative sizes of each.
-* The scroll bar may be manipulated by the left mouse button (normal scrolling), by the
-* middle mouse button (same as the left mouse only the scroll position can jump to the
-* place where the click is made), or by the right mouse button (vernier- or fine-scrolling).
-* Holding down the control key while scrolling with the left or middle mouse button also
-* enables vernier-scrolling mode.  The vernier-scrolling mode is very useful for accurate
-* positioning in large documents.
-* Finally, if the mouse sports a wheel, the scroll bar can be manipulated by means
-* of the mouse wheel as well.  Holding down the Control-key during wheel motion
-* will cause the scrolling to go faster than normal.
-* While moving the scroll bar, a message of type SEL_CHANGED will be sent to the
-* target, and the message data will reflect the current position of type FXint.
-* At the end of the interaction, the scroll bar will send a message of type
-* SEL_COMMAND to notify the target of the final position.
-*/
-class FXAPI FXScrollBar : public FXWindow {
-  FXDECLARE(FXScrollBar)
-protected:
-  FXint      range;           // Scrollable range
-  FXint      page;            // Page size
-  FXint      line;            // Line size
-  FXint      pos;             // Position
-  FXint      barsize;         // Bar size
-  FXint      thumbsize;       // Thumb size
-  FXint      thumbpos;        // Thumb position
-  FXColor    hiliteColor;     // Hightlight color
-  FXColor    shadowColor;     // Shadow color
-  FXColor    borderColor;     // Border color
-  FXColor    arrowColor;      // Arrow color
-  FXint      dragpoint;       // Point where grabbed
-  FXuchar    mode;            // Current mode of control
-protected:
-  FXScrollBar();
-  void drawButton(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h,FXbool down);
-  void drawLeftArrow(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h,FXbool down);
-  void drawRightArrow(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h,FXbool down);
-  void drawUpArrow(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h,FXbool down);
-  void drawDownArrow(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h,FXbool down);
-protected:
-  enum {
-    MODE_NONE,
-    MODE_INC,
-    MODE_DEC,
-    MODE_PAGE_INC,
-    MODE_PAGE_DEC,
-    MODE_DRAG,
-    MODE_FINE_DRAG
-    };
-private:
-  FXScrollBar(const FXScrollBar&);
-  FXScrollBar &operator=(const FXScrollBar&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onMouseWheel(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onMiddleBtnPress(FXObject*,FXSelector,void*);
-  long onMiddleBtnRelease(FXObject*,FXSelector,void*);
-  long onRightBtnPress(FXObject*,FXSelector,void*);
-  long onRightBtnRelease(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onTimeWheel(FXObject*,FXSelector,void*);
-  long onAutoScroll(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntRange(FXObject*,FXSelector,void*);
-  long onCmdGetIntRange(FXObject*,FXSelector,void*);
-public:
-  enum{
-    ID_TIMEWHEEL=FXWindow::ID_LAST,
-    ID_AUTOSCROLL,
-    ID_LAST
-    };
-public:
-
-  /// Construct scroll bar
-  FXScrollBar(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=SCROLLBAR_VERTICAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Set content size range
-  void setRange(FXint r);
-
-  /// Return content size range
-  FXint getRange() const { return range; }
-
-  /// Set viewport page size
-  void setPage(FXint p);
-
-  /// Return page size
-  FXint getPage() const { return page; }
-
-  /// Set scoll increment for line
-  void setLine(FXint l);
-
-  /// Return line increment
-  FXint getLine() const { return line; }
-
-  /// Change scroll position
-  void setPosition(FXint p);
-
-  /// Return current scroll position
-  FXint getPosition() const { return pos; }
-
-  /// Change highlight color
-  void setHiliteColor(FXColor clr);
-
-  /// Return highlight color
-  FXColor getHiliteColor() const { return hiliteColor; }
-
-  /// Change the shadow color
-  void setShadowColor(FXColor clr);
-
-  /// Return the shadow color
-  FXColor getShadowColor() const { return shadowColor; }
-
-  /// Change the border color
-  void setBorderColor(FXColor clr);
-
-  /// Return the border color
-  FXColor getBorderColor() const { return borderColor; }
-
-  /// Change the arrow color
-  void setArrowColor(FXColor clr);
-
-  /// Return the arrow color
-  FXColor getArrowColor() const { return arrowColor; }
-
-  /// Change the scrollbar style
-  void setScrollBarStyle(FXuint style);
-
-  /// Return the scrollbar style
-  FXuint getScrollBarStyle() const;
-
-  /// Change the bar size
-  void setBarSize(FXint size);
-
-  /// Return the bar size
-  FXint getBarSize() const { return barsize; }
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXScrollBar();
-  };
-
-
-/// Corner between scroll bars
-class FXAPI FXScrollCorner : public FXWindow {
-  FXDECLARE(FXScrollCorner)
-protected:
-  FXScrollCorner();
-private:
-  FXScrollCorner(const FXScrollCorner&);
-  FXScrollCorner &operator=(const FXScrollCorner&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-public:
-
-  /// Constructor
-  FXScrollCorner(FXComposite* p);
-
-  /// Can not be enabled
-  virtual void enable();
-
-  /// Can not be disabled
-  virtual void disable();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXScrollPane.h b/fox-includes/FXScrollPane.h
deleted file mode 100755
index e6e40ac3..00000000
--- a/fox-includes/FXScrollPane.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*               S c r o l l i n g   M e n u   P a n e   W i d g e t             *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXScrollPane.h 2235 2005-11-09 13:33:24Z lyle $                       *
-********************************************************************************/
-#ifndef FXSCROLLPANE_H
-#define FXSCROLLPANE_H
-
-#ifndef FXMENUPANE_H
-#include "FXMenuPane.h"
-#endif
-
-namespace FX {
-
-class FXArrowButton;
-
-/**
-* A Scroll Pane is a menu pane which provides scrolling of menu entries.
-* It is useful when menus are populated programmatically and it is not
-* known in advance how many entries will be added.
-*/
-class FXAPI FXScrollPane : public FXMenuPane {
-  FXDECLARE(FXScrollPane)
-protected:
-  FXArrowButton *dn;            // Button to scroll down
-  FXArrowButton *up;            // Button to scroll up
-  FXint          visible;       // Visible entries
-  FXint          top;           // Top visible entry
-protected:
-  FXScrollPane();
-private:
-  FXScrollPane(const FXScrollPane&);
-  FXScrollPane &operator=(const FXScrollPane&);
-public:
-  long onCmdIncrement(FXObject*,FXSelector,void*);
-  long onCmdDecrement(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_SCROLL_DN=FXMenuPane::ID_LAST,
-    ID_SCROLL_UP,
-    ID_LAST
-    };
-public:
-
-  /// Construct menu pane
-  FXScrollPane(FXWindow* owner,FXint nvis,FXuint opts=0);
-
-  /// Return the default width of this window
-  virtual FXint getDefaultWidth();
-
-  /// Return the default height of this window
-  virtual FXint getDefaultHeight();
-
-  /// Show this window
-  virtual void show();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return number of visible items
-  FXint getNumVisible() const { return visible; }
-
-  /// Change the number of visible items
-  void setNumVisible(FXint nvis);
-
-  /// Get index of top most menu item
-  FXint getTopItem() const { return top; }
-
-  /// Scroll item to top
-  void setTopItem(FXint t);
-
-  /// Destroy
-  virtual ~FXScrollPane();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXScrollWindow.h b/fox-includes/FXScrollWindow.h
deleted file mode 100755
index 4e91b972..00000000
--- a/fox-includes/FXScrollWindow.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                     S c r o l l W i n d o w   W i d g e t                     *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2003 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXScrollWindow.h 1788 2003-11-11 21:10:44Z lyle $                    *
-********************************************************************************/
-#ifndef FXSCROLLWINDOW_H
-#define FXSCROLLWINDOW_H
-
-#ifndef FXSCROLLAREA_H
-#include "FXScrollArea.h"
-#endif
-
-namespace FX {
-
-
-/**
-* The scroll window widget scrolls an arbitrary child window.
-* Use the scroll window when parts of the user interface itself
-* need to be scrolled, for example when applications need to run
-* on small screens.  The scroll window observes some layout hints of
-* its content-window; it observes LAYOUT_FIX_WIDTH, LAYOUT_FIX_HEIGHT
-* at all times.  The hints LAYOUT_FILL_X, LAYOUT_LEFT, LAYOUT_RIGHT,
-* LAYOUT_CENTER_X, as well as LAYOUT_FILL_Y, LAYOUT_TOP, LAYOUT_BOTTOM,
-* LAYOUT_CENTER_Y are however only interpreted if the content size
-* is smaller than the viewport size, because if the content size is
-* larger than the viewport size, then content must be scrolled.
-* Note that this means that the content window's position is not
-* necessarily equal to the scroll position of the scroll window!
-*/
-class FXAPI FXScrollWindow : public FXScrollArea {
-  FXDECLARE(FXScrollWindow)
-protected:
-  FXScrollWindow(){}
-  virtual void moveContents(FXint x,FXint y);
-private:
-  FXScrollWindow(const FXScrollWindow&);
-  FXScrollWindow &operator=(const FXScrollWindow&);
-public:
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onFocusSelf(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct a scroll window
-  FXScrollWindow(FXComposite* p,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return a pointer to the contents window
-  FXWindow* contentWindow() const;
-
-  /// Return the width of the contents
-  virtual FXint getContentWidth();
-
-  /// Return the height of the contents
-  virtual FXint getContentHeight();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXSearchDialog.h b/fox-includes/FXSearchDialog.h
deleted file mode 100755
index 497c661f..00000000
--- a/fox-includes/FXSearchDialog.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       T e x t   S e a r c h   D i a l o g                     *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2000,2002 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXSearchDialog.h 809 2002-07-11 17:28:15Z lyle $                    *
-********************************************************************************/
-#ifndef FXSEARCHDIALOG_H
-#define FXSEARCHDIALOG_H
-
-#ifndef FXREPLACEDIALOG_H
-#include "FXReplaceDialog.h"
-#endif
-
-namespace FX {
-
-
-/// Text search dialog
-class FXAPI FXSearchDialog : public FXReplaceDialog {
-  FXDECLARE(FXSearchDialog)
-protected:
-  FXSearchDialog(){}
-private:
-  FXSearchDialog(const FXSearchDialog&);
-  FXSearchDialog &operator=(const FXSearchDialog&);
-public:
-
-  /// Construct search dialog box
-  FXSearchDialog(FXWindow* owner,const FXString& caption,FXIcon* ic=NULL,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Destructor
-  virtual ~FXSearchDialog();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXSeparator.h b/fox-includes/FXSeparator.h
deleted file mode 100755
index 02ba7603..00000000
--- a/fox-includes/FXSeparator.h
+++ /dev/null
@@ -1,111 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                      S e p a r a t o r   W i d g e t s                        *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXSeparator.h 2127 2005-08-07 20:21:35Z lyle $                       *
-********************************************************************************/
-#ifndef FXSEPARATOR_H
-#define FXSEPARATOR_H
-
-#ifndef FXFRAME_H
-#include "FXFrame.h"
-#endif
-
-namespace FX {
-
-
-/// Separator Options
-enum {
-  SEPARATOR_NONE       = 0,               /// Nothing visible
-  SEPARATOR_GROOVE     = 0x00008000,      /// Etched-in looking groove
-  SEPARATOR_RIDGE      = 0x00010000,      /// Embossed looking ridge
-  SEPARATOR_LINE       = 0x00020000       /// Simple line
-  };
-
-
-/**
-* A Separator widget is used to draw a horizontal or vertical divider between
-* groups of controls.  It is purely decorative.  The separator may be drawn
-* in various styles as determined by the SEPARATOR_NONE, SEPARATOR_GROOVE,
-* SEPARATOR_RIDGE, and SEPARATOR_LINE options.  Since its derived from Frame,
-* it can also have the frame's border styles.
-*/
-class FXAPI FXSeparator : public FXFrame {
-  FXDECLARE(FXSeparator)
-protected:
-  FXSeparator(){}
-private:
-  FXSeparator(const FXSeparator&);
-  FXSeparator &operator=(const FXSeparator&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-public:
-
-  /// Constructor
-  FXSeparator(FXComposite* p,FXuint opts=SEPARATOR_GROOVE|LAYOUT_FILL_X,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=0,FXint pr=0,FXint pt=0,FXint pb=0);
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Change separator style
-  void setSeparatorStyle(FXuint style);
-
-  /// Get separator style
-  FXuint getSeparatorStyle() const;
-  };
-
-
-
-/// Horizontal separator widget
-class FXAPI FXHorizontalSeparator : public FXSeparator {
-  FXDECLARE(FXHorizontalSeparator)
-protected:
-  FXHorizontalSeparator(){}
-private:
-  FXHorizontalSeparator(const FXHorizontalSeparator&);
-  FXHorizontalSeparator &operator=(const FXHorizontalSeparator&);
-public:
-
-  /// Constructor
-  FXHorizontalSeparator(FXComposite* p,FXuint opts=SEPARATOR_GROOVE|LAYOUT_FILL_X,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=1,FXint pr=1,FXint pt=0,FXint pb=0);
-  };
-
-
-
-/// Vertical separator widget
-class FXAPI FXVerticalSeparator : public FXSeparator {
-  FXDECLARE(FXVerticalSeparator)
-protected:
-  FXVerticalSeparator(){}
-private:
-  FXVerticalSeparator(const FXVerticalSeparator&);
-  FXVerticalSeparator &operator=(const FXVerticalSeparator&);
-public:
-
-  /// Constructor
-  FXVerticalSeparator(FXComposite* p,FXuint opts=SEPARATOR_GROOVE|LAYOUT_FILL_Y,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=0,FXint pr=0,FXint pt=1,FXint pb=1);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXSettings.h b/fox-includes/FXSettings.h
deleted file mode 100755
index aa752fa8..00000000
--- a/fox-includes/FXSettings.h
+++ /dev/null
@@ -1,148 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                           S e t t i n g s   C l a s s                         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXSettings.h 2345 2006-02-14 03:07:05Z lyle $                        *
-********************************************************************************/
-#ifndef FXSETTINGS_H
-#define FXSETTINGS_H
-
-#ifndef FXDICT_H
-#include "FXDict.h"
-#endif
-
-namespace FX {
-
-
-class FXStringDict;
-
-
-/**
-* The Settings class manages a key-value database.  This is normally used as
-* part of Registry, but can also be used separately in applications that need
-* to maintain a key-value database in a file of their own.
-* String values can contain any character, and will be escaped when written
-* to the file.
-*/
-class FXAPI FXSettings : public FXDict {
-  FXDECLARE(FXSettings)
-protected:
-  bool modified;
-protected:
-  virtual void *createData(const void*);
-  virtual void deleteData(void*);
-  FXchar* dequote(FXchar* text) const;
-  FXchar* enquote(FXchar* result,const FXchar* text);
-  FXStringDict* insert(const FXchar* ky){ return (FXStringDict*)FXDict::insert(ky,NULL); }
-  FXStringDict* replace(const FXchar* ky,FXStringDict* section){ return (FXStringDict*)FXDict::replace(ky,section,true); }
-  FXStringDict* remove(const FXchar* ky){ return (FXStringDict*)FXDict::remove(ky); }
-public:
-
-  /// Construct settings database.
-  FXSettings();
-
-  /// Construct copy of existing database.
-  FXSettings(const FXSettings& orig);
-
-  /// Assignment operator
-  FXSettings &operator=(const FXSettings& orig);
-
-  /// Parse a file containing a settings database.
-  bool parseFile(const FXString& filename,bool mark);
-
-  /// Unparse settings database into given file.
-  bool unparseFile(const FXString& filename);
-
-  /// Obtain the string dictionary for the given section
-  FXStringDict* data(FXuint pos) const { return (FXStringDict*)FXDict::data(pos); }
-
-  /// Find string dictionary for the given section; may be NULL
-  FXStringDict* find(const FXchar *section) const { return (FXStringDict*)FXDict::find(section); }
-
-  /// Read a formatted registry entry, using scanf-style format
-  FXint readFormatEntry(const FXchar *section,const FXchar *key,const FXchar *fmt,...) FX_SCANF(4,5) ;
-
-  /// Read a string registry entry; if no value is found, the default value def is returned
-  const FXchar *readStringEntry(const FXchar *section,const FXchar *key,const FXchar *def=NULL);
-
-  /// Read a integer registry entry; if no value is found, the default value def is returned
-  FXint readIntEntry(const FXchar *section,const FXchar *key,FXint def=0);
-
-  /// Read a unsigned integer registry entry; if no value is found, the default value def is returned
-  FXuint readUnsignedEntry(const FXchar *section,const FXchar *key,FXuint def=0);
-
-  /// Read a double-precision floating point registry entry; if no value is found, the default value def is returned
-  FXdouble readRealEntry(const FXchar *section,const FXchar *key,FXdouble def=0.0);
-
-  /// Read a color value registry entry; if no value is found, the default value def is returned
-  FXColor readColorEntry(const FXchar *section,const FXchar *key,FXColor def=0);
-
-  /// Read a boolean registry entry
-  FXbool readBoolEntry(const FXchar *section,const FXchar *key,FXbool def=FALSE);
-
-  /// Write a formatted registry entry, using printf-style format
-  FXint writeFormatEntry(const FXchar *section,const FXchar *key,const FXchar *fmt,...) FX_PRINTF(4,5) ;
-
-  /// Write a string registry entry
-  bool writeStringEntry(const FXchar *section,const FXchar *key,const FXchar *val);
-
-  /// Write a integer registry entry
-  bool writeIntEntry(const FXchar *section,const FXchar *key,FXint val);
-
-  /// Write a unsigned integer registry entry
-  bool writeUnsignedEntry(const FXchar *section,const FXchar *key,FXuint val);
-
-  /// Write a double-precision floating point registry entry
-  bool writeRealEntry(const FXchar *section,const FXchar *key,FXdouble val);
-
-  /// Write a color value entry
-  bool writeColorEntry(const FXchar *section,const FXchar *key,FXColor val);
-
-  /// Write a boolean value entry
-  bool writeBoolEntry(const FXchar *section,const FXchar *key,FXbool val);
-
-  /// Delete a registry entry
-  bool deleteEntry(const FXchar *section,const FXchar *key);
-
-  /// See if entry exists
-  bool existingEntry(const FXchar *section,const FXchar *key);
-
-  /// Delete section
-  bool deleteSection(const FXchar *section);
-
-  /// See if section exists
-  bool existingSection(const FXchar *section);
-
-  /// Clear all sections
-  bool clear();
-
-  /// Mark as changed
-  void setModified(bool mdfy=true){ modified=mdfy; }
-
-  /// Is it modified
-  bool isModified() const { return modified; }
-
-  /// Cleanup
-  virtual ~FXSettings();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXShell.h b/fox-includes/FXShell.h
deleted file mode 100755
index 0c5c3d05..00000000
--- a/fox-includes/FXShell.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                     S h e l l   W i n d o w   W i d g e t                     *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXShell.h 2127 2005-08-07 20:21:35Z lyle $                           *
-********************************************************************************/
-#ifndef FXSHELL_H
-#define FXSHELL_H
-
-#ifndef FXCOMPOSITE_H
-#include "FXComposite.h"
-#endif
-
-namespace FX {
-
-
-/**
-* The Shell widget is used as the base class for top level windows, i.e.
-* windows which are direct children of the root window.
-*/
-class FXAPI FXShell : public FXComposite {
-  FXDECLARE(FXShell)
-protected:
-  FXShell(){}
-  FXShell(FXApp* a,FXuint opts,FXint x,FXint y,FXint w,FXint h);
-  FXShell(FXWindow* own,FXuint opts,FXint x,FXint y,FXint w,FXint h);
-private:
-  FXShell(const FXShell&);
-  FXShell &operator=(const FXShell&);
-public:
-  long onLayout(FXObject*,FXSelector,void*);
-  long onConfigure(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onFocusNext(FXObject*,FXSelector,void*);
-  long onFocusPrev(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_LAYOUT=FXComposite::ID_LAST,
-    ID_LAST
-    };
-public:
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Mark this window's layout as dirty
-  virtual void recalc();
-
-  /// Move the focus to this window
-  virtual void setFocus();
-
-  /// Remove the focus from this window
-  virtual void killFocus();
-
-  /// Destroy shell
-  virtual ~FXShell();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXShutter.h b/fox-includes/FXShutter.h
deleted file mode 100755
index 88d12c71..00000000
--- a/fox-includes/FXShutter.h
+++ /dev/null
@@ -1,151 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                 S h u t t e r   C o n t a i n e r   W i d g e t               *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2005 by Charles W. Warren.   All Rights Reserved.          *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXShutter.h 2236 2005-11-09 13:35:17Z lyle $                         *
-********************************************************************************/
-#ifndef FXSHUTTER_H
-#define FXSHUTTER_H
-
-#ifndef FXVERTICALFRAME_H
-#include "FXVerticalFrame.h"
-#endif
-
-namespace FX {
-
-
-class FXShutter;
-class FXButton;
-class FXScrollWindow;
-class FXShutterItem;
-
-
-/**
-* A Shutter Item is a panel which is embedded inside a Shutter Widget.
-* It can contain other user interface widgets which can be added under
-* the content widget.  The content widget is itself embedded in a scroll
-* window to allow unlimited room for all the contents.
-*/
-class FXAPI FXShutterItem : public FXVerticalFrame {
-  FXDECLARE(FXShutterItem)
-  friend class FXShutter;
-protected:
-  FXButton         *button;
-  FXScrollWindow   *scrollWindow;
-  FXVerticalFrame  *content;
-protected:
-  FXShutterItem(){}
-private:
-  FXShutterItem(const FXShutterItem&);
-  FXShutterItem &operator=(const FXShutterItem&);
-public:
-  long onFocusUp(FXObject*,FXSelector,void*);
-  long onFocusDown(FXObject*,FXSelector,void*);
-  long onCmdButton(FXObject*,FXSelector,void*);
-public:
-  enum{
-    ID_SHUTTERITEM_BUTTON=FXVerticalFrame::ID_LAST,
-    ID_LAST
-    };
-public:
-  /// Constructor
-  FXShutterItem(FXShutter *p,const FXString& text=FXString::null,FXIcon* icon=NULL,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_SPACING,FXint pr=DEFAULT_SPACING,FXint pt=DEFAULT_SPACING,FXint pb=DEFAULT_SPACING,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING);
-
-  /// Return a pointer to the button for this item
-  FXButton* getButton() const { return button; }
-
-  /// Return a pointer to the contents for this item
-  FXVerticalFrame* getContent() const { return content; }
-
-  /// Set the status line help text for this item
-  void setHelpText(const FXString& text);
-
-  /// Get the status line help text for this item
-  FXString getHelpText() const;
-
-  /// Set the tool tip message for this item
-  void setTipText(const FXString&  text);
-
-  /// Get the tool tip message for this item
-  FXString getTipText() const;
-
-  /// Destructor
-  virtual ~FXShutterItem();
-  };
-
-
-/**
-* The Shutter widget provides a set of foldable sub panels.  Each subpanel
-* consists of a Shutter Item which contains a button and some contents.
-* A sub panel can be unfolded by pressing on that panel's button.
-*/
-class FXAPI FXShutter : public FXVerticalFrame {
-  FXDECLARE(FXShutter)
-  friend class FXShutterItem;
-protected:
-  FXint          current;               // Item currently open
-  FXint          closing;               // Item closing down
-  FXint          heightIncrement;       // Height delta
-  FXint          closingHeight;         // Closing items current height
-  FXbool         closingHadScrollbar;   // Closing item had a scroll bar
-protected:
-  FXShutter(){}
-private:
-  FXShutter(const FXShutter&);
-  FXShutter &operator=(const FXShutter&);
-public:
-  long onFocusUp(FXObject*,FXSelector,void*);
-  long onFocusDown(FXObject*,FXSelector,void*);
-  long onTimeout(FXObject*,FXSelector,void*);
-  long onOpenItem(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-  long onCmdOpen(FXObject*,FXSelector,void*);
-  long onUpdOpen(FXObject*,FXSelector,void*);
-public:
-  enum{
-    ID_SHUTTER_TIMEOUT=FXVerticalFrame::ID_LAST,
-    ID_OPEN_SHUTTERITEM,
-    ID_OPEN_FIRST,
-    ID_OPEN_LAST=ID_OPEN_FIRST+1000,
-    ID_LAST
-    };
-public:
-
-  /// Constructor
-  FXShutter(FXComposite *p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_SPACING,FXint pr=DEFAULT_SPACING,FXint pt=DEFAULT_SPACING,FXint pb=DEFAULT_SPACING,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING);
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Set the currently displayed item (panel = 0, 1, 2, ..., npanels-1)
-  virtual void setCurrent(FXint panel);
-
-  /// Return the index of the currently displayed item
-  FXint getCurrent() const { return current; }
-
-  /// Destructor
-  virtual ~FXShutter();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXSize.h b/fox-includes/FXSize.h
deleted file mode 100755
index 35859e60..00000000
--- a/fox-includes/FXSize.h
+++ /dev/null
@@ -1,108 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                               S i z e    C l a s s                            *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1994,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXSize.h 2345 2006-02-14 03:07:05Z lyle $                            *
-********************************************************************************/
-#ifndef FXSIZE_H
-#define FXSIZE_H
-
-
-namespace FX {
-
-
-/// Size
-class FXAPI FXSize {
-public:
-  FXshort w;
-  FXshort h;
-public:
-
-  /// Constructors
-  FXSize(){ }
-  FXSize(const FXSize& s):w(s.w),h(s.h){ }
-  FXSize(FXshort ww,FXshort hh):w(ww),h(hh){ }
-
-  /// Test if empty
-  bool empty() const { return w<=0 || h<=0; }
-
-  /// Test if zero
-  bool operator!() const { return w==0 && h==0; }
-
-  /// Equality
-  bool operator==(const FXSize& s) const { return w==s.w && h==s.h; }
-  bool operator!=(const FXSize& s) const { return w!=s.w || h!=s.h; }
-
-  /// Grow by amount
-  FXSize& grow(FXshort margin);
-  FXSize& grow(FXshort hormargin,FXshort vermargin);
-  FXSize& grow(FXshort leftmargin,FXshort rightmargin,FXshort topmargin,FXshort bottommargin);
-
-  /// Shrink by amount
-  FXSize& shrink(FXshort margin);
-  FXSize& shrink(FXshort hormargin,FXshort vermargin);
-  FXSize& shrink(FXshort leftmargin,FXshort rightmargin,FXshort topmargin,FXshort bottommargin);
-
-  /// Assignment
-  FXSize& operator=(const FXSize& s){ w=s.w; h=s.h; return *this; }
-
-  /// Set value from another size
-  FXSize& set(const FXSize& s){ w=s.w; h=s.h; return *this; }
-
-  /// Set value from components
-  FXSize& set(FXshort ww,FXshort hh){ w=ww; h=hh; return *this; }
-
-  /// Assignment operators
-  FXSize& operator+=(const FXSize& s){ w+=s.w; h+=s.h; return *this; }
-  FXSize& operator-=(const FXSize& s){ w-=s.w; h-=s.h; return *this; }
-  FXSize& operator*=(FXshort c){ w*=c; h*=c; return *this; }
-  FXSize& operator/=(FXshort c){ w/=c; h/=c; return *this; }
-
-  /// Negation
-  FXSize operator-(){ return FXSize(-w,-h); }
-
-  /// Addition operators
-  FXSize operator+(const FXSize& s) const { return FXSize(w+s.w,h+s.h); }
-  FXSize operator-(const FXSize& s) const { return FXSize(w-s.w,h-s.h); }
-
-  /// Scale operators
-  friend inline FXSize operator*(const FXSize& s,FXshort c);
-  friend inline FXSize operator*(FXshort c,const FXSize& s);
-  friend inline FXSize operator/(const FXSize& s,FXshort c);
-  friend inline FXSize operator/(FXshort c,const FXSize& s);
-
-  /// Save object to a stream
-  friend FXAPI FXStream& operator<<(FXStream& store,const FXSize& s);
-
-  /// Load object from a stream
-  friend FXAPI FXStream& operator>>(FXStream& store,FXSize& s);
-  };
-
-inline FXSize operator*(const FXSize& s,FXshort c){ return FXSize(s.w*c,s.h*c); }
-inline FXSize operator*(FXshort c,const FXSize& s){ return FXSize(c*s.w,c*s.h); }
-inline FXSize operator/(const FXSize& s,FXshort c){ return FXSize(s.w/c,s.h/c); }
-inline FXSize operator/(FXshort c,const FXSize& s){ return FXSize(c/s.w,c/s.h); }
-
-extern FXAPI FXStream& operator<<(FXStream& store,const FXSize& s);
-extern FXAPI FXStream& operator>>(FXStream& store,FXSize& s);
-
-}
-
-#endif
diff --git a/fox-includes/FXSlider.h b/fox-includes/FXSlider.h
deleted file mode 100755
index 2729daac..00000000
--- a/fox-includes/FXSlider.h
+++ /dev/null
@@ -1,209 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                           S l i d e r   W i d g e t                           *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXSlider.h 2343 2006-02-12 20:26:26Z lyle $                          *
-********************************************************************************/
-#ifndef FXSLIDER_H
-#define FXSLIDER_H
-
-#ifndef FXFRAME_H
-#include "FXFrame.h"
-#endif
-
-namespace FX {
-
-
-/// Slider Control styles
-enum {
-  SLIDER_HORIZONTAL   = 0,                        /// Slider shown horizontally
-  SLIDER_VERTICAL     = 0x00008000,               /// Slider shown vertically
-  SLIDER_ARROW_UP     = 0x00010000,               /// Slider has arrow head pointing up
-  SLIDER_ARROW_DOWN   = 0x00020000,               /// Slider has arrow head pointing down
-  SLIDER_ARROW_LEFT   = SLIDER_ARROW_UP,          /// Slider has arrow head pointing left
-  SLIDER_ARROW_RIGHT  = SLIDER_ARROW_DOWN,        /// Slider has arrow head pointing right
-  SLIDER_INSIDE_BAR   = 0x00040000,               /// Slider is inside the slot rather than overhanging
-  SLIDER_TICKS_TOP    = 0x00080000,               /// Ticks on the top of horizontal slider
-  SLIDER_TICKS_BOTTOM = 0x00100000,               /// Ticks on the bottom of horizontal slider
-  SLIDER_TICKS_LEFT   = SLIDER_TICKS_TOP,         /// Ticks on the left of vertical slider
-  SLIDER_TICKS_RIGHT  = SLIDER_TICKS_BOTTOM,      /// Ticks on the right of vertical slider
-  SLIDER_NORMAL       = SLIDER_HORIZONTAL
-  };
-
-
-/**
-* The slider widget is a valuator widget which provides simple linear value range.
-* Two visual appearances are supported:- the sunken look, which is enabled with
-* the SLIDER_INSIDE_BAR option and the regular look.  The latter may have optional
-* arrows on the slider thumb.
-* While being moved, the slider sends a SEL_CHANGED message to its target;
-* at the end of the interaction, a SEL_COMMAND message is sent.
-* The message data represents the current slider value, of type FXint.
-*/
-class FXAPI FXSlider : public FXFrame {
-  FXDECLARE(FXSlider)
-protected:
-  FXint         range[2];                 // Reported data range
-  FXint         pos;                      // Reported data position
-  FXint         incr;                     // Increment when auto-sliding
-  FXint         delta;                    // Interval between ticks
-  FXint         headpos;                  // Head position
-  FXint         headsize;                 // Head size
-  FXint         slotsize;                 // Slot size
-  FXColor       slotColor;                // Color of slot the head moves in
-  FXint         dragpoint;                // Where the head is grabbed
-  FXString      help;                     // Help string
-  FXString      tip;                      // Tip string
-protected:
-  FXSlider();
-  void drawSliderHead(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawHorzTicks(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawVertTicks(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-private:
-  FXSlider(const FXSlider&);
-  FXSlider &operator=(const FXSlider&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onMouseWheel(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onMiddleBtnPress(FXObject*,FXSelector,void*);
-  long onMiddleBtnRelease(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onAutoSlide(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-  long onCmdSetRealValue(FXObject*,FXSelector,void*);
-  long onCmdGetRealValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntRange(FXObject*,FXSelector,void*);
-  long onCmdGetIntRange(FXObject*,FXSelector,void*);
-  long onCmdSetRealRange(FXObject*,FXSelector,void*);
-  long onCmdGetRealRange(FXObject*,FXSelector,void*);
-  long onCmdSetHelp(FXObject*,FXSelector,void*);
-  long onCmdGetHelp(FXObject*,FXSelector,void*);
-  long onCmdSetTip(FXObject*,FXSelector,void*);
-  long onCmdGetTip(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-public:
-  enum{
-    ID_AUTOSLIDE=FXFrame::ID_LAST,
-    ID_LAST
-    };
-public:
-
-  /// Construct a slider widget
-  FXSlider(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=SLIDER_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=0,FXint pr=0,FXint pt=0,FXint pb=0);
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Returns true because a slider can receive focus
-  virtual bool canFocus() const;
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Enable the slider
-  virtual void enable();
-
-  /// Disable the slider
-  virtual void disable();
-
-  /// Change slider value
-  void setValue(FXint value,FXbool notify=FALSE);
-
-  /// Return slider value
-  FXint getValue() const { return pos; }
-
-  /// Change the slider's range
-  void setRange(FXint lo,FXint hi,FXbool notify=FALSE);
-
-  /// Get the slider's current range
-  void getRange(FXint& lo,FXint& hi) const { lo=range[0]; hi=range[1]; }
-
-  /// Change the slider style
-  FXuint getSliderStyle() const;
-
-  /// Get the current slider style
-  void setSliderStyle(FXuint style);
-
-  /// Get the slider's head size
-  FXint getHeadSize() const { return headsize; }
-
-  /// Change the slider's head size
-  void setHeadSize(FXint hs);
-
-  /// Get the slider's current slot size
-  FXint getSlotSize() const { return slotsize; }
-
-  /// Change the slider's slot size
-  void setSlotSize(FXint bs);
-
-  /// Get the slider's auto-increment/decrement value
-  FXint getIncrement() const { return incr; }
-
-  /// Change the slider's auto-increment/decrement value
-  void setIncrement(FXint inc);
-
-  /// Change the delta between ticks
-  void setTickDelta(FXint dist);
-
-  /// Get delta between ticks
-  FXint getTickDelta() const { return delta; }
-
-  /// Change the color of the slot the slider head moves in
-  void setSlotColor(FXColor clr);
-
-  /// Get the current slot color
-  FXColor getSlotColor() const { return slotColor; }
-
-  /// Set the help text to be displayed on the status line
-  void setHelpText(const FXString& text){ help=text; }
-
-  /// Get the current help text
-  const FXString& getHelpText() const { return help; }
-
-  /// Set the tip text to be displayed in the tooltip
-  void setTipText(const FXString& text){ tip=text; }
-
-  /// Get the current tooltip text value
-  const FXString& getTipText() const { return tip; }
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destroy the slider
-  virtual ~FXSlider();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXSocket.h b/fox-includes/FXSocket.h
deleted file mode 100644
index a7f5f46a..00000000
--- a/fox-includes/FXSocket.h
+++ /dev/null
@@ -1,71 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                           S o c k e t   C l a s s                             *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2005,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXSocket.h 2343 2006-02-12 20:26:26Z lyle $                           *
-********************************************************************************/
-#ifndef FXSOCKET_H
-#define FXSOCKET_H
-
-#ifndef FXIO_H
-#include "FXIO.h"
-#endif
-
-
-////////////////////////////  UNDER DEVELOPMENT  ////////////////////////////////
-
-
-namespace FX {
-
-
-/**
-* Socket i/o device.
-*/
-class FXAPI FXSocket : public FXIO {
-private:
-  FXSocket(const FXSocket&);
-  FXSocket &operator=(const FXSocket&);
-public:
-
-  /// Construct socket
-  FXSocket(){ }
-
-  /// Construct file and attach existing handle h
-  FXSocket(FXInputHandle handle,FXuint mode);
-
-  /// Open device with access mode and handle
-  virtual bool open(FXInputHandle handle,FXuint mode);
-
-  /// Read block of bytes, returning number of bytes read
-  virtual FXival readBlock(void* data,FXival count);
-
-  /// Write block of bytes, returning number of bytes written
-  virtual FXival writeBlock(const void* data,FXival count);
-
-  /// Close socket
-  virtual bool close();
-
-  /// Destroy
-  virtual ~FXSocket();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXSphered.h b/fox-includes/FXSphered.h
deleted file mode 100755
index ae356278..00000000
--- a/fox-includes/FXSphered.h
+++ /dev/null
@@ -1,146 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*           D o u b l e - P r e c i s i o n    S p h e r e    C l a s s         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2004,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXSphered.h 2345 2006-02-14 03:07:05Z lyle $                         *
-********************************************************************************/
-#ifndef FXSPHERED_H
-#define FXSPHERED_H
-
-
-namespace FX {
-
-
-class FXRanged;
-
-
-/// Spherical bounds
-class FXAPI FXSphered {
-public:
-  FXVec3d  center;
-  FXdouble radius;
-public:
-
-  /// Default constructor
-  FXSphered(){}
-
-  /// Copy constructor
-  FXSphered(const FXSphered& sphere):center(sphere.center),radius(sphere.radius){}
-
-  /// Initialize from center and radius
-  FXSphered(const FXVec3d& cen,FXdouble rad=0.0):center(cen),radius(rad){}
-
-  /// Initialize from center and radius
-  FXSphered(FXdouble x,FXdouble y,FXdouble z,FXdouble rad=0.0):center(x,y,z),radius(rad){}
-
-  /// Initialize sphere to fully contain the given bounding box
-  FXSphered(const FXRanged& bounds);
-
-  /// Assignment
-  FXSphered& operator=(const FXSphered& sphere){ center=sphere.center; radius=sphere.radius; return *this; }
-
-  /// Set value from another sphere
-  FXSphered& set(const FXSphered& sphere){ center=sphere.center; radius=sphere.radius; return *this; }
-
-  /// Set value from center and radius
-  FXSphered& set(const FXVec3d& cen,FXdouble rad){ center=cen; radius=rad; return *this; }
-
-  /// Set value from center and radius
-  FXSphered& set(FXdouble x,FXdouble y,FXdouble z,FXdouble rad){ center.set(x,y,z); radius=rad; return *this; }
-
-  /// Comparison
-  bool operator==(const FXSphered& s) const { return center==s.center && radius==s.radius;}
-  bool operator!=(const FXSphered& s) const { return center!=s.center || radius!=s.radius;}
-
-  /// Diameter of sphere
-  FXdouble diameter() const { return radius*2.0; }
-
-  /// Test if empty
-  bool empty() const { return radius<0.0; }
-
-  /// Test if sphere contains point x,y,z
-  bool contains(FXdouble x,FXdouble y,FXdouble z) const;
-
-  /// Test if sphere contains point p
-  bool contains(const FXVec3d& p) const;
-
-  /// Test if sphere contains another box
-  bool contains(const FXRanged& box) const;
-
-  /// Test if sphere contains another sphere
-  bool contains(const FXSphered& sphere) const;
-
-  /// Include point
-  FXSphered& include(FXdouble x,FXdouble y,FXdouble z);
-
-  /// Include point
-  FXSphered& include(const FXVec3d& p);
-
-  /// Expand radius to include point
-  FXSphered& includeInRadius(FXdouble x,FXdouble y,FXdouble z);
-
-  /// Expand radius to include point
-  FXSphered& includeInRadius(const FXVec3d& p);
-
-  /// Include given range into this one
-  FXSphered& include(const FXRanged& box);
-
-  /// Expand radius to include box
-  FXSphered& includeInRadius(const FXRanged& box);
-
-  /// Include given sphere into this one
-  FXSphered& include(const FXSphered& sphere);
-
-  /// Expand radius to include sphere
-  FXSphered& includeInRadius(const FXSphered& sphere);
-
-  /// Intersect sphere with normalized plane ax+by+cz+w; returns -1,0,+1
-  FXint intersect(const FXVec4d& plane) const;
-
-  /// Intersect sphere with ray u-v
-  bool intersect(const FXVec3d& u,const FXVec3d& v) const;
-
-  /// Test if box overlaps with sphere
-  friend FXAPI bool overlap(const FXRanged& a,const FXSphered& b);
-
-  /// Test if sphere overlaps with box
-  friend FXAPI bool overlap(const FXSphered& a,const FXRanged& b);
-
-  /// Test if spheres overlap
-  friend FXAPI bool overlap(const FXSphered& a,const FXSphered& b);
-
-  /// Save object to a stream
-  friend FXAPI FXStream& operator<<(FXStream& store,const FXSphered& sphere);
-
-  /// Load object from a stream
-  friend FXAPI FXStream& operator>>(FXStream& store,FXSphered& sphere);
-  };
-
-
-extern FXAPI bool overlap(const FXRanged& a,const FXSphered& b);
-extern FXAPI bool overlap(const FXSphered& a,const FXRanged& b);
-extern FXAPI bool overlap(const FXSphered& a,const FXSphered& b);
-
-extern FXAPI FXStream& operator<<(FXStream& store,const FXSphered& sphere);
-extern FXAPI FXStream& operator>>(FXStream& store,FXSphered& sphere);
-
-}
-
-#endif
diff --git a/fox-includes/FXSpheref.h b/fox-includes/FXSpheref.h
deleted file mode 100755
index f153df7b..00000000
--- a/fox-includes/FXSpheref.h
+++ /dev/null
@@ -1,146 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*           S i n g l e - P r e c i s i o n    S p h e r e    C l a s s         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2004,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXSpheref.h 2345 2006-02-14 03:07:05Z lyle $                         *
-********************************************************************************/
-#ifndef FXSPHEREF_H
-#define FXSPHEREF_H
-
-
-namespace FX {
-
-
-class FXRangef;
-
-
-/// Spherical bounds
-class FXAPI FXSpheref {
-public:
-  FXVec3f center;
-  FXfloat radius;
-public:
-
-  /// Default constructor
-  FXSpheref(){}
-
-  /// Copy constructor
-  FXSpheref(const FXSpheref& sphere):center(sphere.center),radius(sphere.radius){}
-
-  /// Initialize from center and radius
-  FXSpheref(const FXVec3f& cen,FXfloat rad=0.0f):center(cen),radius(rad){}
-
-  /// Initialize from center and radius
-  FXSpheref(FXfloat x,FXfloat y,FXfloat z,FXfloat rad=0.0f):center(x,y,z),radius(rad){}
-
-  /// Initialize sphere to fully contain the given bounding box
-  FXSpheref(const FXRangef& bounds);
-
-  /// Assignment
-  FXSpheref& operator=(const FXSpheref& sphere){ center=sphere.center; radius=sphere.radius; return *this; }
-
-  /// Set value from another sphere
-  FXSpheref& set(const FXSpheref& sphere){ center=sphere.center; radius=sphere.radius; return *this; }
-
-  /// Set value from center and radius
-  FXSpheref& set(const FXVec3f& cen,FXfloat rad){ center=cen; radius=rad; return *this; }
-
-  /// Set value from center and radius
-  FXSpheref& set(FXfloat x,FXfloat y,FXfloat z,FXfloat rad){ center.set(x,y,z); radius=rad; return *this; }
-
-  /// Comparison
-  bool operator==(const FXSpheref& s) const { return center==s.center && radius==s.radius;}
-  bool operator!=(const FXSpheref& s) const { return center!=s.center || radius!=s.radius;}
-
-  /// Diameter of sphere
-  FXfloat diameter() const { return radius*2.0f; }
-
-  /// Test if empty
-  bool empty() const { return radius<0.0f; }
-
-  /// Test if sphere contains point x,y,z
-  bool contains(FXfloat x,FXfloat y,FXfloat z) const;
-
-  /// Test if sphere contains point p
-  bool contains(const FXVec3f& p) const;
-
-  /// Test if sphere properly contains another box
-  bool contains(const FXRangef& box) const;
-
-  /// Test if sphere properly contains another sphere
-  bool contains(const FXSpheref& sphere) const;
-
-  /// Include point
-  FXSpheref& include(FXfloat x,FXfloat y,FXfloat z);
-
-  /// Include point
-  FXSpheref& include(const FXVec3f& p);
-
-  /// Expand radius to include point
-  FXSpheref& includeInRadius(FXfloat x,FXfloat y,FXfloat z);
-
-  /// Expand radius to include point
-  FXSpheref& includeInRadius(const FXVec3f& p);
-
-  /// Include given range into this one
-  FXSpheref& include(const FXRangef& box);
-
-  /// Expand radius to include box
-  FXSpheref& includeInRadius(const FXRangef& box);
-
-  /// Include given sphere into this one
-  FXSpheref& include(const FXSpheref& sphere);
-
-  /// Expand radius to include sphere
-  FXSpheref& includeInRadius(const FXSpheref& sphere);
-
-  /// Intersect sphere with normalized plane ax+by+cz+w; returns -1,0,+1
-  FXint intersect(const FXVec4f& plane) const;
-
-  /// Intersect sphere with ray u-v
-  bool intersect(const FXVec3f& u,const FXVec3f& v) const;
-
-  /// Test if box overlaps with sphere
-  friend FXAPI bool overlap(const FXRangef& a,const FXSpheref& b);
-
-  /// Test if sphere overlaps with box
-  friend FXAPI bool overlap(const FXSpheref& a,const FXRangef& b);
-
-  /// Test if spheres overlap
-  friend FXAPI bool overlap(const FXSpheref& a,const FXSpheref& b);
-
-  /// Save object to a stream
-  friend FXAPI FXStream& operator<<(FXStream& store,const FXSpheref& sphere);
-
-  /// Load object from a stream
-  friend FXAPI FXStream& operator>>(FXStream& store,FXSpheref& sphere);
-  };
-
-
-extern FXAPI bool overlap(const FXRangef& a,const FXSpheref& b);
-extern FXAPI bool overlap(const FXSpheref& a,const FXRangef& b);
-extern FXAPI bool overlap(const FXSpheref& a,const FXSpheref& b);
-
-extern FXAPI FXStream& operator<<(FXStream& store,const FXSpheref& sphere);
-extern FXAPI FXStream& operator>>(FXStream& store,FXSpheref& sphere);
-
-}
-
-#endif
diff --git a/fox-includes/FXSpinner.h b/fox-includes/FXSpinner.h
deleted file mode 100755
index 1e92ee64..00000000
--- a/fox-includes/FXSpinner.h
+++ /dev/null
@@ -1,232 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        S p i n   B u t t o n   W i d g e t                    *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2006 by Lyle Johnson.   All Rights Reserved.               *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXSpinner.h 2343 2006-02-12 20:26:26Z lyle $                         *
-********************************************************************************/
-#ifndef FXSPINNER_H
-#define FXSPINNER_H
-
-#ifndef FXPACKER_H
-#include "FXPacker.h"
-#endif
-
-namespace FX {
-
-
-/// Spinner Options
-enum {
-  SPIN_NORMAL  =  0,                /// Normal, non-cyclic
-  SPIN_CYCLIC  =  0x00020000,       /// Cyclic spinner
-  SPIN_NOTEXT  =  0x00040000,       /// No text visible
-  SPIN_NOMAX   =  0x00080000,       /// Spin all the way up to infinity
-  SPIN_NOMIN   =  0x00100000        /// Spin all the way down to -infinity
-  };
-
-
-class FXTextField;
-class FXArrowButton;
-
-
-/// Spinner control
-class FXAPI FXSpinner : public FXPacker {
-  FXDECLARE(FXSpinner)
-protected:
-  FXTextField   *textField;         // Text field
-  FXArrowButton *upButton;          // The up button
-  FXArrowButton *downButton;        // The down button
-  FXint          range[2];          // Reported data range
-  FXint          incr;              // Increment
-  FXint          pos;               // Current position
-protected:
-  FXSpinner();
-private:
-  FXSpinner(const FXSpinner&);
-  FXSpinner& operator=(const FXSpinner&);
-public:
-  long onUpdIncrement(FXObject*,FXSelector,void*);
-  long onCmdIncrement(FXObject*,FXSelector,void*);
-  long onUpdDecrement(FXObject*,FXSelector,void*);
-  long onCmdDecrement(FXObject*,FXSelector,void*);
-  long onCmdEntry(FXObject*,FXSelector,void*);
-  long onChgEntry(FXObject*,FXSelector,void*);
-  long onWheelEntry(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntRange(FXObject*,FXSelector,void*);
-  long onCmdGetIntRange(FXObject*,FXSelector,void*);
-  long onFocusSelf(FXObject*,FXSelector,void*);
-public:
-  enum{
-    ID_INCREMENT=FXPacker::ID_LAST,
-    ID_DECREMENT,
-    ID_ENTRY,
-    ID_LAST
-    };
-public:
-
-  /// Construct a spinner
-  FXSpinner(FXComposite *p,FXint cols,FXObject *tgt=NULL,FXSelector sel=0,FXuint opts=SPIN_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Disable spinner
-  virtual void disable();
-
-  /// Enable spinner
-  virtual void enable();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Increment spinner
-  void increment(FXbool notify=FALSE);
-
-  /// Increment spinner by certain amount
-  void incrementByAmount(FXint amount,FXbool notify=FALSE);
-
-  /// Decrement spinner
-  void decrement(FXbool notify=FALSE);
-
-  /// Decrement spinner by certain amount
-  void decrementByAmount(FXint amount, FXbool notify=FALSE);
-
-  /// Return TRUE if in cyclic mode
-  FXbool isCyclic() const;
-
-  /// Set to cyclic mode, i.e. wrap around at maximum/minimum
-  void setCyclic(FXbool cyclic);
-
-  /// Return TRUE if text is visible
-  FXbool isTextVisible() const;
-
-  /// Set text visible flag
-  void setTextVisible(FXbool shown);
-
-  /// Change current value
-  virtual void setValue(FXint value,FXbool notify=FALSE);
-
-  /// Return current value
-  FXint getValue() const { return pos; }
-
-  /// Change the spinner's range
-  void setRange(FXint lo,FXint hi,FXbool notify=FALSE);
-
-  /// Get the spinner's current range
-  void getRange(FXint& lo,FXint& hi) const { lo=range[0]; hi=range[1]; }
-
-  /// Change spinner increment
-  void setIncrement(FXint increment);
-
-  /// Return spinner increment
-  FXint getIncrement() const { return incr; }
-
-  /// Set the text font
-  void setFont(FXFont *fnt);
-
-  /// Get the text font
-  FXFont *getFont() const;
-
-  /// Set the status line help text for this spinner
-  void setHelpText(const FXString& text);
-
-  /// Get the status line help text for this spinner
-  const FXString& getHelpText() const;
-
-  /// Set the tool tip message for this spinner
-  void setTipText(const FXString& text);
-
-  /// Get the tool tip message for this spinner
-  const FXString& getTipText() const;
-
-  /// Change spinner style
-  void setSpinnerStyle(FXuint style);
-
-  /// Return current spinner style
-  FXuint getSpinnerStyle() const;
-
-  /// Allow editing of the text field
-  void setEditable(FXbool edit=TRUE);
-
-  /// Return TRUE if text field is editable
-  FXbool isEditable() const;
-
-  /// Change color of the up arrow
-  void setUpArrowColor(FXColor clr);
-
-  /// Return color of the up arrow
-  FXColor getUpArrowColor() const;
-
-  /// Change color of the down arrow
-  void setDownArrowColor(FXColor clr);
-
-  /// Return color of the the down arrow
-  FXColor getDownArrowColor() const;
-
-  /// Change text color
-  void setTextColor(FXColor clr);
-
-  /// Return text color
-  FXColor getTextColor() const;
-
-  /// Change selected background color
-  void setSelBackColor(FXColor clr);
-
-  /// Return selected background color
-  FXColor getSelBackColor() const;
-
-  /// Change selected text color
-  void setSelTextColor(FXColor clr);
-
-  /// Return selected text color
-  FXColor getSelTextColor() const;
-
-  /// Changes the cursor color
-  void setCursorColor(FXColor clr);
-
-  /// Return the cursor color
-  FXColor getCursorColor() const;
-
-  /// Change width of text field in terms of number of columns * `m'
-  void setNumColumns(FXint cols);
-
-  /// Return number of columns
-  FXint getNumColumns() const;
-
-  /// Save spinner to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load spinner from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXSpinner();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXSplashWindow.h b/fox-includes/FXSplashWindow.h
deleted file mode 100644
index 296c5fd0..00000000
--- a/fox-includes/FXSplashWindow.h
+++ /dev/null
@@ -1,114 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                            S p l a s h    W i n d o w                         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2004,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXSplashWindow.h 2135 2005-08-14 00:32:54Z lyle $                     *
-********************************************************************************/
-#ifndef FXSPLASHWINDOW_H
-#define FXSPLASHWINDOW_H
-
-#ifndef FXTOPWINDOW_H
-#include "FXTopWindow.h"
-#endif
-
-namespace FX {
-
-
-/// Splash Window options
-enum {
-  SPLASH_SIMPLE    = 0,                 /// Simple rectangular splash window
-  SPLASH_SHAPED    = 0x02000000,        /// Shaped splash window
-  SPLASH_OWNS_ICON = 0x04000000,        /// Splash window will own the icon and destroy it
-  SPLASH_DESTROY   = 0x08000000         /// Splash window will destroy itself when timer expires
-  };
-
-
-/**
-* The Splash Window is a window typically shown during startup
-* of an application.  It comprises a large icon, which is also
-* used as the shape of the window if SPLASH_SHAPED is passed;
-* with the SPLASH_SIMPLE option the window will be simply rectangular.
-*/
-class FXAPI FXSplashWindow : public FXTopWindow {
-  FXDECLARE(FXSplashWindow)
-protected:
-  FXIcon *icon;         // Really big icon
-  FXuint  delay;        // Delay before hiding
-protected:
-  FXSplashWindow();
-private:
-  FXSplashWindow(const FXSplashWindow&);
-  FXSplashWindow &operator=(const FXSplashWindow&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct splash window
-  FXSplashWindow(FXApp* ap,FXIcon* ic,FXuint opts=SPLASH_SIMPLE,FXuint ms=5000);
-
-  /// Construct splash window
-  FXSplashWindow(FXWindow* ow,FXIcon* ic,FXuint opts=SPLASH_SIMPLE,FXuint ms=5000);
-
-  /// Create
-  virtual void create();
-
-  /// Detach
-  virtual void detach();
-
-  /// Show splash window
-  virtual void show();
-
-  /// Show splash window with a given placement
-  virtual void show(FXuint placement);
-
-  /// Hide splash window
-  virtual void hide();
-
-  /// Return the default width of this window
-  virtual FXint getDefaultWidth();
-
-  /// Return the default height of this window
-  virtual FXint getDefaultHeight();
-
-  /// Set the icon for the splash window
-  void setIcon(FXIcon* ic);
-
-  /// Get the icon for this splash window
-  FXIcon* getIcon() const { return icon; }
-
-  /// Set or change delay
-  void setDelay(FXuint ms);
-
-  /// Return delay
-  FXuint getDelay() const { return delay; }
-
-  /// Save label to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load label from a stream
-  virtual void load(FXStream& store);
-
-  /// Destroy splash window
-  virtual ~FXSplashWindow();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXSplitter.h b/fox-includes/FXSplitter.h
deleted file mode 100755
index 2f4f4ece..00000000
--- a/fox-includes/FXSplitter.h
+++ /dev/null
@@ -1,142 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                S p l i t t e r   W i n d o w   W i d g e t                    *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXSplitter.h 2127 2005-08-07 20:21:35Z lyle $                        *
-********************************************************************************/
-#ifndef FXSPLITTER_H
-#define FXSPLITTER_H
-
-#ifndef FXCOMPOSITE_H
-#include "FXComposite.h"
-#endif
-
-namespace FX {
-
-
-/// Splitter options
-enum {
-  SPLITTER_HORIZONTAL = 0,                  /// Split horizontally
-  SPLITTER_VERTICAL   = 0x00008000,         /// Split vertically
-  SPLITTER_REVERSED   = 0x00010000,         /// Reverse-anchored
-  SPLITTER_TRACKING   = 0x00020000,         /// Track continuous during split
-  SPLITTER_NORMAL     = SPLITTER_HORIZONTAL
-  };
-
-
-
-/**
-* Splitter window is used to interactively repartition
-* two or more subpanels.
-* Space may be subdivided horizontally (SPLITTER_HORIZONTAL, which
-* the default) or vertically (SPLITTER_VERTICAL option).
-* When the splitter is itself resized, the right-most (bottom-most)
-* child window will be resized unless the splitter window is reversed;
-* if the splitter is reversed, the left-most (top-most) child window
-* will be resized instead.
-* The splitter widget sends a SEL_CHANGED to its target
-* during the resizing of the panels; at the end of the resize interaction,
-* it sends a SEL_COMMAND to signify that the resize operation is complete.
-* Normally, children are resizable from 0 upwards; however, if the child
-* in a horizontally oriented splitter has LAYOUT_FILL_X in combination with
-* LAYOUT_FIX_WIDTH, it will not be made smaller than its default width,
-* except when the child is the last visible widget (or first when the option
-* SPLITTER_REVERSED has been passed to the splitter).
-* In a vertically oriented splitter, children with LAYOUT_FILL_Y and
-* LAYOUT_FIX_HEIGHT behave analogously.
-*/
-class FXAPI FXSplitter : public FXComposite {
-  FXDECLARE(FXSplitter)
-private:
-  FXWindow *window;         // Window being resized
-  FXint     split;          // Split value
-  FXint     offset;         // Mouse offset
-  FXint     barsize;        // Size of the splitter bar
-protected:
-  FXSplitter();
-  void adjustHLayout();
-  void adjustVLayout();
-  void moveHSplit(FXint amount);
-  void moveVSplit(FXint amount);
-  void drawHSplit(FXint pos);
-  void drawVSplit(FXint pos);
-  FXWindow* findHSplit(FXint pos);
-  FXWindow* findVSplit(FXint pos);
-private:
-  FXSplitter(const FXSplitter&);
-  FXSplitter& operator=(const FXSplitter&);
-public:
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onFocusNext(FXObject*,FXSelector,void*);
-  long onFocusPrev(FXObject*,FXSelector,void*);
-  long onFocusUp(FXObject*,FXSelector,void*);
-  long onFocusDown(FXObject*,FXSelector,void*);
-  long onFocusLeft(FXObject*,FXSelector,void*);
-  long onFocusRight(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct new splitter widget
-  FXSplitter(FXComposite* p,FXuint opts=SPLITTER_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Construct new splitter widget, which will notify target about size changes
-  FXSplitter(FXComposite* p,FXObject* tgt,FXSelector sel,FXuint opts=SPLITTER_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Get default width
-  virtual FXint getDefaultWidth();
-
-  /// Get default height
-  virtual FXint getDefaultHeight();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return size of the panel at index
-  FXint getSplit(FXint index) const;
-
-  /// Change the size of panel at the given index
-  void setSplit(FXint index,FXint size);
-
-  /// Change splitter style
-  void setSplitterStyle(FXuint style);
-
-  /// Return current splitter style
-  FXuint getSplitterStyle() const;
-
-  /// Change splitter bar size
-  void setBarSize(FXint bs);
-
-  /// Return current bar size
-  FXint getBarSize() const { return barsize; }
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destroy splitter
-  virtual ~FXSplitter();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXSpring.h b/fox-includes/FXSpring.h
deleted file mode 100755
index f1dcdfa0..00000000
--- a/fox-includes/FXSpring.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                S p r i n g   C o n t a i n e r   W i d g e t                  *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2003 by Jeroen van der Zijp.   All Rights Reserved.             *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXSpring.h 1829 2003-12-18 16:40:13Z lyle $                           *
-********************************************************************************/
-#ifndef FXSPRING_H
-#define FXSPRING_H
-
-#ifndef FXPACKER_H
-#include "FXPacker.h"
-#endif
-
-namespace FX {
-
-
-/**
-* The spring widgets, when properly embedded side by side in a horizontal
-* frame or vertical frame widget, behave like a set of connected springs
-* of various lengths (hence the name!).  The parameters relw (or relh)
-* determines the length of the spring.  The actual length is not really
-* important; the only thing that counts is the relative length of one
-* spring widget to that of another, although the length does determine
-* the default size.  The special value zero may be given for relw (or relh)
-* to cause the spring to calculate its default width (height) normally,
-* just like the Packer base class does.
-* In a typical scenario, either the relative width or height is set to
-* zero, an the flag LAYOUT_FILL_X or LAYOUT_FILL_Y is passed. When
-* placed inside a horizontal frame, the LAYOUT_FILL_X together with
-* the relative widths of the springs will cause a fixed width-ratio
-* between the springs.
-* You also can mix normal controls and springs together in a horizontal
-* or vertical frames to provide arbitrary stretchable spacing between
-* widgets; in this case, the springs do not need to have any children.
-* Since the spring widget is derived from the packer layout manager,
-* it provides the same layout behavior as packer.
-*/
-class FXAPI FXSpring : public FXPacker {
-  FXDECLARE(FXSpring)
-protected:
-  FXint   relWidth;     // Relative width
-  FXint   relHeight;    // Relative height
-protected:
-  FXSpring(){}
-private:
-  FXSpring(const FXSpring&);
-  FXSpring &operator=(const FXSpring&);
-public:
-
-  /// Construct packer layout manager
-  FXSpring(FXComposite *p,FXuint opts=0,FXint relw=0,FXint relh=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_SPACING,FXint pr=DEFAULT_SPACING,FXint pt=DEFAULT_SPACING,FXint pb=DEFAULT_SPACING,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING);
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Change relative width
-  void setRelativeWidth(FXint relw);
-
-  /// Return relative width
-  FXint  getRelativeWidth() const { return relWidth; }
-
-  /// Change relative height
-  void setRelativeHeight(FXint relh);
-
-  /// Return relative height
-  FXint getRelativeHeight() const { return relHeight; }
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXStat.h b/fox-includes/FXStat.h
deleted file mode 100644
index 8aeef850..00000000
--- a/fox-includes/FXStat.h
+++ /dev/null
@@ -1,270 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        F i l e   S t a t i s t i c s                          *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2005 by Jeroen van der Zijp.   All Rights Reserved.             *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXStat.h 2291 2005-12-05 03:37:36Z lyle $                            *
-********************************************************************************/
-#ifndef FXSTAT_H
-#define FXSTAT_H
-
-
-namespace FX {
-
-
-class FXFile;
-
-
-/// Statistics about a file or directory
-class FXAPI FXStat {
-  friend class FXFile;
-private:
-  FXuint  modeFlags;            /// Mode bits
-  FXuint  userNumber;           /// User number
-  FXuint  groupNumber;          /// Group number
-  FXTime  createTime;           /// Create time
-  FXTime  accessTime;           /// Access time
-  FXTime  modifyTime;           /// Modify time
-  FXlong  fileSize;             /// File size
-public:
-
-  /// Get statistics of the file into the stat buffer info
-  static bool statFile(const FXString& file,FXStat& info);
-
-  /// Get statistice of the link into the stat buffer info
-  static bool statLink(const FXString& file,FXStat& info);
-
-  /// Get statistics of already open file into stat buffer info
-  static bool stat(const FXFile& file,FXStat& info);
-
-  /// Return the mode flags for this file
-  FXuint mode() const { return modeFlags; }
-
-  /// Return file size in bytes
-  FXlong size() const { return fileSize; }
-
-  /// Return user number
-  FXuint user() const { return userNumber; }
-
-  /// Return group number
-  FXuint group() const { return groupNumber; }
-
-  /// Return time when last modified
-  FXTime modified() const { return modifyTime; }
-
-  /// Return time when last accessed
-  FXTime accessed() const { return accessTime; }
-
-  /// Return time when file was created
-  FXTime created() const { return createTime; }
-
-  /// Return time anything was changed
-  FXTime touched() const;
-
-  /// Return true if it is a hidden file (Windows-only)
-  bool isHidden() const;
-
-  /// Return true if it is a regular file
-  bool isFile() const;
-
-  /// Return true if it is a link
-  bool isLink() const;
-
-  /// Return true if character device
-  bool isCharacter() const;
-
-  /// Return true if block device
-  bool isBlock() const;
-
-  /// Return true if socket device
-  bool isSocket() const;
-
-  /// Return true if fifo (pipe) device
-  bool isFifo() const;
-
-  /// Return true if input path is a directory
-  bool isDirectory() const;
-
-  /// Return true if file is readable
-  bool isReadable() const;
-
-  /// Return true if file is writable
-  bool isWritable() const;
-
-  /// Return true if file is executable
-  bool isExecutable() const;
-
-  /// Return true if owner has read-write-execute permissions
-  bool isOwnerReadWriteExecute() const;
-
-  /// Return true if owner has read permissions
-  bool isOwnerReadable() const;
-
-  /// Return true if owner has write permissions
-  bool isOwnerWritable() const;
-
-  /// Return true if owner has execute permissions
-  bool isOwnerExecutable() const;
-
-  /// Return true if group has read-write-execute permissions
-  bool isGroupReadWriteExecute() const;
-
-  /// Return true if group has read permissions
-  bool isGroupReadable() const;
-
-  /// Return true if group has write permissions
-  bool isGroupWritable() const;
-
-  /// Return true if group has execute permissions
-  bool isGroupExecutable() const;
-
-  /// Return true if others have read-write-execute permissions
-  bool isOtherReadWriteExecute() const;
-
-  /// Return true if others have read permissions
-  bool isOtherReadable() const;
-
-  /// Return true if others have write permissions
-  bool isOtherWritable() const;
-
-  /// Return true if others have execute permissions
-  bool isOtherExecutable() const;
-
-  /// Return true if the file sets the user id on execution
-  bool isSetUid() const;
-
-  /// Return true if the file sets the group id on execution
-  bool isSetGid() const;
-
-  /// Return true if the file has the sticky bit set
-  bool isSetSticky() const;
-
-  /// Return the mode flags for this file
-  static FXuint mode(const FXString& file);
-
-  /// Change the mode flags for this file
-  static bool mode(const FXString& file,FXuint perm);
-
-  /// Return true if file exists
-  static bool exists(const FXString& file);
-
-  /// Return file size in bytes
-  static FXlong size(const FXString& file);
-
-  /**
-  * Return last modified time for this file, on filesystems
-  * where this is supported.  This is the time when any data
-  * in the file was last modified.
-  */
-  static FXTime modified(const FXString& file);
-
-  /**
-  * Return last accessed time for this file, on filesystems
-  * where this is supported.
-  */
-  static FXTime accessed(const FXString& file);
-
-  /**
-  * Return created time for this file, on filesystems
-  * where this is supported.  This is also the time when
-  * ownership, permissions, links, and other meta-data may
-  * have changed.
-  */
-  static FXTime created(const FXString& file);
-
-  /**
-  * Return touched time for this file, on filesystems
-  * where this is supported.  This is the time when anything
-  * at all, either contents or meta-data, about the file was
-  * changed.
-  */
-  static FXTime touched(const FXString& file);
-
-  /// Return true if file is hidden
-  static bool isHidden(const FXString& file);
-
-  /// Return true if input path is a file name
-  static bool isFile(const FXString& file);
-
-  /// Return true if input path is a link
-  static bool isLink(const FXString& file);
-
-  /// Return true if input path is a directory
-  static bool isDirectory(const FXString& file);
-
-  /// Return true if file is readable
-  static bool isReadable(const FXString& file);
-
-  /// Return true if file is writable
-  static bool isWritable(const FXString& file);
-
-  /// Return true if file is executable
-  static bool isExecutable(const FXString& file);
-
-  /// Return true if owner has read-write-execute permissions
-  static bool isOwnerReadWriteExecute(const FXString& file);
-
-  /// Return true if owner has read permissions
-  static bool isOwnerReadable(const FXString& file);
-
-  /// Return true if owner has write permissions
-  static bool isOwnerWritable(const FXString& file);
-
-  /// Return true if owner has execute permissions
-  static bool isOwnerExecutable(const FXString& file);
-
-  /// Return true if group has read-write-execute permissions
-  static bool isGroupReadWriteExecute(const FXString& file);
-
-  /// Return true if group has read permissions
-  static bool isGroupReadable(const FXString& file);
-
-  /// Return true if group has write permissions
-  static bool isGroupWritable(const FXString& file);
-
-  /// Return true if group has execute permissions
-  static bool isGroupExecutable(const FXString& file);
-
-  /// Return true if others have read-write-execute permissions
-  static bool isOtherReadWriteExecute(const FXString& file);
-
-  /// Return true if others have read permissions
-  static bool isOtherReadable(const FXString& file);
-
-  /// Return true if others have write permissions
-  static bool isOtherWritable(const FXString& file);
-
-  /// Return true if others have execute permissions
-  static bool isOtherExecutable(const FXString& file);
-
-  /// Return true if the file sets the user id on execution
-  static bool isSetUid(const FXString& file);
-
-  /// Return true if the file sets the group id on execution
-  static bool isSetGid(const FXString& file);
-
-  /// Return true if the file has the sticky bit set
-  static bool isSetSticky(const FXString& file);
-
-  };
-
-
-}
-
-#endif
diff --git a/fox-includes/FXStatusBar.h b/fox-includes/FXStatusBar.h
deleted file mode 100755
index 2c04c083..00000000
--- a/fox-includes/FXStatusBar.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       S t a t u s B a r   W i d g e t                         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2003 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXStatusBar.h 1536 2003-05-14 21:41:00Z lyle $                        *
-********************************************************************************/
-#ifndef FXSTATUSBAR_H
-#define FXSTATUSBAR_H
-
-#ifndef FXHORIZONTALFRAME_H
-#include "FXHorizontalFrame.h"
-#endif
-
-namespace FX {
-
-
-/// StatusBar options
-enum {
-  STATUSBAR_WITH_DRAGCORNER = 0x00020000    /// Causes the DragCorner to be shown
-  };
-
-
-class FXDragCorner;
-class FXStatusLine;
-
-
-/// Status bar
-class FXAPI FXStatusBar : public FXHorizontalFrame {
-  FXDECLARE(FXStatusBar)
-protected:
-  FXDragCorner *corner;
-  FXStatusLine *status;
-protected:
-  FXStatusBar(){}
-private:
-  FXStatusBar(const FXStatusBar&);
-  FXStatusBar& operator=(const FXStatusBar&);
-public:
-
-  /// Construct status bar with or without a drag corner
-  FXStatusBar(FXComposite* p,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=3,FXint pr=3,FXint pt=2,FXint pb=2,FXint hs=4,FXint vs=0);
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Show or hide the drag corner
-  void setCornerStyle(FXbool withcorner=TRUE);
-
-  /// Return TRUE if drag corner shown
-  FXbool getCornerStyle() const;
-
-  /// Acess the status line widget
-  FXStatusLine *getStatusLine() const { return status; }
-
-  /// Access the drag corner widget
-  FXDragCorner *getDragCorner() const { return corner; }
-
-  /// Save status bar to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load status bar from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXStatusBar();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXStatusLine.h b/fox-includes/FXStatusLine.h
deleted file mode 100755
index a9fd8fce..00000000
--- a/fox-includes/FXStatusLine.h
+++ /dev/null
@@ -1,125 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       S t a t u s L i n e   W i d g e t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1999,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXStatusLine.h 2239 2005-11-09 13:42:43Z lyle $                       *
-********************************************************************************/
-#ifndef FXSTATUSLINE_H
-#define FXSTATUSLINE_H
-
-#ifndef FXFRAME_H
-#include "FXFrame.h"
-#endif
-
-namespace FX {
-
-
-/**
-* The status line normally shows its permanent message; when
-* moving the mouse over a Widget which has status-line help, the status line
-* temporarily replaces its normal message with the help information; the status
-* line obtains the help message by sending the Widget a ID_QUERY_HELP message
-* with type SEL_UPDATE.
-* If this query does not result in a new status string, the target of
-* the status line is tried via an ordinary SEL_UPDATE message.
-* If none of the above work then the status line will display the normal text,
-* i.e. the string set via setNormalText().
-* If the message contains a newline (\n), then the part before the newline
-* will be displayed in the highlight color, while the part after the newline
-* is shown using the normal text color.
-*/
-class FXAPI FXStatusLine : public FXFrame {
-  FXDECLARE(FXStatusLine)
-protected:
-  FXString  status;             // Current status message
-  FXString  normal;             // Normally displayed message
-  FXFont   *font;               // Font
-  FXColor   textColor;          // Status text color
-  FXColor   textHighlightColor; // Status text highlight color
-protected:
-  FXStatusLine();
-private:
-  FXStatusLine(const FXStatusLine&);
-  FXStatusLine& operator=(const FXStatusLine&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onUpdate(FXObject*,FXSelector,void*);
-  long onCmdGetStringValue(FXObject*,FXSelector,void*);
-  long onCmdSetStringValue(FXObject*,FXSelector,void*);
-public:
-
-  /// Constructor
-  FXStatusLine(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Change the temporary status message
-  void setText(const FXString& text);
-
-  /// Return the temporary status message
-  FXString getText() const { return status; }
-
-  /// Change the permanent status message
-  void setNormalText(const FXString& text);
-
-  /// Return the permanent status message
-  FXString getNormalText() const { return normal; }
-
-  /// Change the font
-  void setFont(FXFont* fnt);
-
-  /// Return the current font
-  FXFont* getFont() const { return font; }
-
-  /// Return the text color
-  FXColor getTextColor() const { return textColor; }
-
-  /// Change the text color
-  void setTextColor(FXColor clr);
-
-  /// Return the highlight text color
-  FXColor getTextHighlightColor() const { return textHighlightColor; }
-
-  /// Change the highlight text color
-  void setTextHighlightColor(FXColor clr);
-
-  /// Save status line to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load status line from stream
-  virtual void load(FXStream& store);
-
-  /// Destroy
-  virtual ~FXStatusLine();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXStream.h b/fox-includes/FXStream.h
deleted file mode 100755
index 887b5493..00000000
--- a/fox-includes/FXStream.h
+++ /dev/null
@@ -1,246 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*       P e r s i s t e n t   S t o r a g e   S t r e a m   C l a s s e s       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXStream.h 2345 2006-02-14 03:07:05Z lyle $                          *
-********************************************************************************/
-#ifndef FXSTREAM_H
-#define FXSTREAM_H
-
-
-namespace FX {
-
-
-/// Stream data flow direction
-enum FXStreamDirection {
-  FXStreamDead=0,               /// Unopened stream
-  FXStreamSave=1,               /// Saving stuff to stream
-  FXStreamLoad=2                /// Loading stuff from stream
-  };
-
-
-/// Stream status codes
-enum FXStreamStatus {
-  FXStreamOK=0,                 /// OK
-  FXStreamEnd=1,                /// Try read past end of stream
-  FXStreamFull=2,               /// Filled up stream buffer or disk full
-  FXStreamNoWrite=3,            /// Unable to open for write
-  FXStreamNoRead=4,             /// Unable to open for read
-  FXStreamFormat=5,             /// Stream format error
-  FXStreamUnknown=6,            /// Trying to read unknown class
-  FXStreamAlloc=7,              /// Alloc failed
-  FXStreamFailure=8             /// General failure
-  };
-
-
-/// Stream seeking
-enum FXWhence {
-  FXFromStart=0,                /// Seek from start position
-  FXFromCurrent=1,              /// Seek from current position
-  FXFromEnd=2                   /// Seek from end position
-  };
-
-
-/**
-* A stream is a way to serialize data and objects into a byte stream.
-* Each item of data that is saved or loaded from the stream may be byte-swapped,
-* thus allowing little-endian machines to read data produced on big endian ones
-* and vice-versa.
-* Data is serialized exactly as-is.  There are no tags or other markers
-* inserted into the stream; thus, the stream may be used to save or load arbitrary
-* binary data.
-* Objects derived from FXObjects may be serialized also; whenever a reference to an
-* object is serialized, a table is consulted to determine if the same object has
-* been encountered previously; if not, the object is added to the table and then
-* its contents are serialized.  If the object has been encountered before, only a
-* reference to the object is serialized.
-* When loading back a serialized object, new instances are constructed using
-* the default constructor, and subsequently the object's contents are loaded.
-* A special container object may be passed in which is placed in the table
-* as if it had been encountered before; this will cause only references to this
-* object to be saved.  The container object is typically the top-level document
-* object which manages all objects contained by it.  Additional objects may be
-* added using addObject(); these will not be actually saved or loaded.
-*/
-class FXAPI FXStream {
-protected:
-  FXHash             hash;      // Hash table
-  const FXObject    *parent;    // Parent object
-  FXuchar           *begptr;    // Begin of buffer
-  FXuchar           *endptr;    // End of buffer
-  FXuchar           *wrptr;     // Write pointer
-  FXuchar           *rdptr;     // Read pointer
-  FXlong             pos;       // Position
-  FXStreamDirection  dir;       // Direction of current transfer
-  FXStreamStatus     code;      // Status code
-  FXuint             seq;       // Sequence number
-  bool               owns;      // Stream owns buffer
-  bool               swap;      // Swap bytes on readin
-protected:
-
-  /**
-  * Write at least count bytes from the buffer;
-  * returns number of bytes available to be written.
-  */
-  virtual FXuval writeBuffer(FXuval count);
-
-  /**
-  * Read at least count bytes into the buffer;
-  * returns number of bytes available to be read.
-  */
-  virtual FXuval readBuffer(FXuval count);
-
-public:
-
-  /**
-  * Construct stream with given container object.  The container object
-  * is an object that will itself not be saved to or loaded from the stream,
-  * but which may be referenced by other objects.  These references will be
-  * properly saved and restored.
-  */
-  FXStream(const FXObject* cont=NULL);
-
-  /**
-  * Open stream for reading (FXStreamLoad) or for writing (FXStreamSave).
-  * An initial buffer size may be given, which must be at least 16 bytes.
-  * If data is not NULL, it is expected to point to an external data buffer
-  * of length size; otherwise stream will use an internally managed buffer.
-  */
-  bool open(FXStreamDirection save_or_load,FXuval size=8192,FXuchar* data=NULL);
-
-  /// Flush buffer
-  virtual bool flush();
-
-  /// Close; return true if OK
-  virtual bool close();
-
-  /// Get available buffer space
-  FXuval getSpace() const;
-
-  /// Set available buffer space
-  void setSpace(FXuval sp);
-
-  /// Get status code
-  FXStreamStatus status() const { return code; }
-
-  /// Return true if at end of file or error
-  bool eof() const { return code!=FXStreamOK; }
-
-  /// Set status code
-  void setError(FXStreamStatus err);
-
-  /// Obtain stream direction
-  FXStreamDirection direction() const { return dir; }
-
-  /// Get parent object
-  const FXObject* container() const { return parent; }
-
-  /// Get position
-  FXlong position() const { return pos; }
-
-  /// Move to position relative to head, tail, or current location
-  virtual bool position(FXlong offset,FXWhence whence=FXFromStart);
-
-  /**
-  * Change swap bytes flag.
-  */
-  void swapBytes(bool s){ swap=s; }
-
-  /**
-  * Get state of the swap bytes flag.
-  */
-  bool swapBytes() const { return swap; }
-
-  /**
-  * Set stream to big endian mode if true.  Byte swapping will
-  * be enabled if the machine native byte order is not equal to
-  * the desired byte order.
-  */
-  void setBigEndian(bool big);
-
-  /**
-  * Return true if big endian mode.
-  */
-  bool isBigEndian() const;
-
-  /// Save single items to stream
-  FXStream& operator<<(const FXuchar& v);
-  FXStream& operator<<(const FXchar& v){ return *this << reinterpret_cast<const FXuchar&>(v); }
-  FXStream& operator<<(const FXushort& v);
-  FXStream& operator<<(const FXshort& v){ return *this << reinterpret_cast<const FXushort&>(v); }
-  FXStream& operator<<(const FXuint& v);
-  FXStream& operator<<(const FXint& v){ return *this << reinterpret_cast<const FXuint&>(v); }
-  FXStream& operator<<(const FXfloat& v){ return *this << reinterpret_cast<const FXuint&>(v); }
-  FXStream& operator<<(const FXdouble& v);
-  FXStream& operator<<(const FXlong& v){ return *this << reinterpret_cast<const FXdouble&>(v); }
-  FXStream& operator<<(const FXulong& v){ return *this << reinterpret_cast<const FXdouble&>(v); }
-
-  /// Save arrays of items to stream
-  FXStream& save(const FXuchar* p,FXuval n);
-  FXStream& save(const FXchar* p,FXuval n){ return save(reinterpret_cast<const FXuchar*>(p),n); }
-  FXStream& save(const FXushort* p,FXuval n);
-  FXStream& save(const FXshort* p,FXuval n){ return save(reinterpret_cast<const FXushort*>(p),n); }
-  FXStream& save(const FXuint* p,FXuval n);
-  FXStream& save(const FXint* p,FXuval n){ return save(reinterpret_cast<const FXuint*>(p),n); }
-  FXStream& save(const FXfloat* p,FXuval n){ return save(reinterpret_cast<const FXuint*>(p),n); }
-  FXStream& save(const FXdouble* p,FXuval n);
-  FXStream& save(const FXlong* p,FXuval n){ return save(reinterpret_cast<const FXdouble*>(p),n); }
-  FXStream& save(const FXulong* p,FXuval n){ return save(reinterpret_cast<const FXdouble*>(p),n); }
-
-  /// Load single items from stream
-  FXStream& operator>>(FXuchar& v);
-  FXStream& operator>>(FXchar& v){ return *this >> reinterpret_cast<FXuchar&>(v); }
-  FXStream& operator>>(FXushort& v);
-  FXStream& operator>>(FXshort& v){ return *this >> reinterpret_cast<FXushort&>(v); }
-  FXStream& operator>>(FXuint& v);
-  FXStream& operator>>(FXint& v){ return *this >> reinterpret_cast<FXuint&>(v); }
-  FXStream& operator>>(FXfloat& v){ return *this >> reinterpret_cast<FXuint&>(v); }
-  FXStream& operator>>(FXdouble& v);
-  FXStream& operator>>(FXlong& v){ return *this >> reinterpret_cast<FXdouble&>(v); }
-  FXStream& operator>>(FXulong& v){ return *this >> reinterpret_cast<FXdouble&>(v); }
-
-  /// Load arrays of items from stream
-  FXStream& load(FXuchar* p,FXuval n);
-  FXStream& load(FXchar* p,FXuval n){ return load(reinterpret_cast<FXuchar*>(p),n); }
-  FXStream& load(FXushort* p,FXuval n);
-  FXStream& load(FXshort* p,FXuval n){ return load(reinterpret_cast<FXushort*>(p),n); }
-  FXStream& load(FXuint* p,FXuval n);
-  FXStream& load(FXint* p,FXuval n){ return load(reinterpret_cast<FXuint*>(p),n); }
-  FXStream& load(FXfloat* p,FXuval n){ return load(reinterpret_cast<FXuint*>(p),n); }
-  FXStream& load(FXdouble* p,FXuval n);
-  FXStream& load(FXlong* p,FXuval n){ return load(reinterpret_cast<FXdouble*>(p),n); }
-  FXStream& load(FXulong* p,FXuval n){ return load(reinterpret_cast<FXdouble*>(p),n); }
-
-  /// Save object
-  FXStream& saveObject(const FXObject* v);
-
-  /// Load object
-  FXStream& loadObject(FXObject*& v);
-
-  /// Add object without saving or loading
-  FXStream& addObject(const FXObject* v);
-
-  /// Destructor
-  virtual ~FXStream();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXString.h b/fox-includes/FXString.h
deleted file mode 100755
index 12d80f0b..00000000
--- a/fox-includes/FXString.h
+++ /dev/null
@@ -1,729 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                           S t r i n g   O b j e c t                           *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXString.h 2360 2006-03-29 04:10:56Z lyle $                         *
-********************************************************************************/
-#ifndef FXSTRING_H
-#define FXSTRING_H
-
-namespace FX {
-
-
-/**
-* FXString provides essential string manipulation capabilities.
-*/
-class FXAPI FXString {
-private:
-  FXchar* str;
-public:
-  static const FXchar null[];
-  static const FXchar hex[17];
-  static const FXchar HEX[17];
-public:
-  static const signed char utfBytes[256];
-public:
-
-  /// Create empty string
-  FXString();
-
-  /// Copy construct
-  FXString(const FXString& s);
-
-  /// Construct and init from string
-  FXString(const FXchar* s);
-
-  /// Construct and init from wide character string
-  FXString(const FXwchar* s);
-
-  /// Construct and init from narrow character string
-  FXString(const FXnchar* s);
-
-  /// Construct and init with substring
-  FXString(const FXchar* s,FXint n);
-
-  /// Construct and init with wide character substring
-  FXString(const FXwchar* s,FXint n);
-
-  /// Construct and init with narrow character substring
-  FXString(const FXnchar* s,FXint n);
-
-  /// Construct and fill with constant
-  FXString(FXchar c,FXint n);
-
-  /// Length of text in bytes
-  FXint length() const { return *(((FXint*)str)-1); }
-
-  /// Change the length of the string to len
-  void length(FXint len);
-
-  /// Count number of utf8 characters
-  FXint count() const;
-
-  /// Count number of utf8 characters in subrange
-  FXint count(FXint pos,FXint len) const;
-
-  /// Return byte offset of utf8 character at index
-  FXint offset(FXint indx) const;
-
-  /// Return index of utf8 character at byte offset
-  FXint index(FXint offs) const;
-
-  /// Validate position to point to begin of utf8 character
-  FXint validate(FXint p) const;
-
-  /// Return extent of utf8 character at position
-  FXint extent(FXint p) const { return utfBytes[(FXuchar)str[p]]; }
-
-  /// Return start of next utf8 character
-  FXint inc(FXint p) const;
-
-  /// Return start of previous utf8 character
-  FXint dec(FXint p) const;
-
-  /// Get text contents
-  const FXchar* text() const { return (const FXchar*)str; }
-
-  /// See if string is empty
-  bool empty() const { return (((FXint*)str)[-1]==0); }
-
-  /// See if string is empty
-  bool operator!() const { return (((FXint*)str)[-1]==0); }
-
-  /// Return a non-const reference to the ith character
-  FXchar& operator[](FXint i){ return str[i]; }
-
-  /// Return a const reference to the ith character
-  const FXchar& operator[](FXint i) const { return str[i]; }
-
-  /// Return a non-const reference to the ith character
-  FXchar& at(FXint i){ return str[i]; }
-
-  /// Return a const reference to the ith character
-  const FXchar& at(FXint i) const { return str[i]; }
-
-  /// Return wide character starting at offset i
-  FXwchar wc(FXint i) const;
-
-  /// Assign a string to this
-  FXString& operator=(const FXchar* s);
-
-  /// Assign a wide character string to this
-  FXString& operator=(const FXwchar* s);
-
-  /// Assign a narrow character string to this
-  FXString& operator=(const FXnchar* s);
-
-  /// Assign another string to this
-  FXString& operator=(const FXString& s);
-
-  /// Convert to lower case
-  FXString& lower();
-
-  /// Convert to upper case
-  FXString& upper();
-
-  /// Return num partition(s) beginning at start from a string separated by delimiters delim.
-  FXString section(FXchar delim,FXint start,FXint num=1) const;
-
-  /// Return num partition(s) beginning at start from a string separated by set of delimiters from delim of size n
-  FXString section(const FXchar* delim,FXint n,FXint start,FXint num) const;
-
-  /// Return num partition(s) beginning at start from a string separated by set of delimiters from delim.
-  FXString section(const FXchar* delim,FXint start,FXint num=1) const;
-
-  /// Return num partition(s) beginning at start from a string separated by set of delimiters from delim.
-  FXString section(const FXString& delim,FXint start,FXint num=1) const;
-
-  /// Adopt string s, leaving s empty
-  FXString& adopt(FXString& s);
-
-  /// Assign character c to this string
-  FXString& assign(FXchar c);
-
-  /// Assign n characters c to this string
-  FXString& assign(FXchar c,FXint n);
-
-  /// Assign first n characters of string s to this string
-  FXString& assign(const FXchar *s,FXint n);
-
-  /// Assign first n characters of wide character string s to this string
-  FXString& assign(const FXwchar *s,FXint n);
-
-  /// Assign first n characters of narrow character string s to this string
-  FXString& assign(const FXnchar *s,FXint n);
-
-  /// Assign string s to this string
-  FXString& assign(const FXchar* s);
-
-  /// Assign wide character string s to this string
-  FXString& assign(const FXwchar* s);
-
-  /// Assign narrow character string s to this string
-  FXString& assign(const FXnchar* s);
-
-  /// Assign string s to this string
-  FXString& assign(const FXString& s);
-
-  /// Insert character at specified position
-  FXString& insert(FXint pos,FXchar c);
-
-  /// Insert n characters c at specified position
-  FXString& insert(FXint pos,FXchar c,FXint n);
-
-  /// Insert first n characters of string at specified position
-  FXString& insert(FXint pos,const FXchar* s,FXint n);
-
-  /// Insert first n characters of wide character string at specified position
-  FXString& insert(FXint pos,const FXwchar* s,FXint n);
-
-  /// Insert first n characters of narrow character string at specified position
-  FXString& insert(FXint pos,const FXnchar* s,FXint n);
-
-  /// Insert string at specified position
-  FXString& insert(FXint pos,const FXchar* s);
-
-  /// Insert wide character string at specified position
-  FXString& insert(FXint pos,const FXwchar* s);
-
-  /// Insert narrow character string at specified position
-  FXString& insert(FXint pos,const FXnchar* s);
-
-  /// Insert string at specified position
-  FXString& insert(FXint pos,const FXString& s);
-
-  /// Prepend string with input character
-  FXString& prepend(FXchar c);
-
-  /// Prepend string with n characters c
-  FXString& prepend(FXchar c,FXint n);
-
-  /// Prepend first n characters of string s
-  FXString& prepend(const FXchar* s,FXint n);
-
-  /// Prepend first n characters of wide character string s
-  FXString& prepend(const FXwchar* s,FXint n);
-
-  /// Prepend first n characters of narrow character string s
-  FXString& prepend(const FXnchar* s,FXint n);
-
-  /// Prepend string with string s
-  FXString& prepend(const FXchar* s);
-
-  /// Prepend string with wide character string
-  FXString& prepend(const FXwchar* s);
-
-  /// Prepend string with narrow character string
-  FXString& prepend(const FXnchar* s);
-
-  /// Prepend string with string s
-  FXString& prepend(const FXString& s);
-
-  /// Append character c to this string
-  FXString& append(FXchar c);
-
-  /// Append n characters c to this string
-  FXString& append(FXchar c,FXint n);
-
-  /// Append first n characters of string s to this string
-  FXString& append(const FXchar* s,FXint n);
-
-  /// Append first n characters of wide character string s to this string
-  FXString& append(const FXwchar* s,FXint n);
-
-  /// Append first n characters of narrow character string s to this string
-  FXString& append(const FXnchar* s,FXint n);
-
-  /// Append string s to this string
-  FXString& append(const FXchar* s);
-
-  /// Append wide character string s to this string
-  FXString& append(const FXwchar* s);
-
-  /// Append narrow character string s to this string
-  FXString& append(const FXnchar* s);
-
-  /// Append string s to this string
-  FXString& append(const FXString& s);
-
-  /// Replace a single character
-  FXString& replace(FXint pos,FXchar c);
-
-  /// Replace the m characters at pos with n characters c
-  FXString& replace(FXint pos,FXint m,FXchar c,FXint n);
-
-  /// Replaces the m characters at pos with first n characters of string s
-  FXString& replace(FXint pos,FXint m,const FXchar* s,FXint n);
-
-  /// Replaces the m characters at pos with first n characters of wide character string s
-  FXString& replace(FXint pos,FXint m,const FXwchar* s,FXint n);
-
-  /// Replaces the m characters at pos with first n characters of narrow character string s
-  FXString& replace(FXint pos,FXint m,const FXnchar* s,FXint n);
-
-  /// Replace the m characters at pos with string s
-  FXString& replace(FXint pos,FXint m,const FXchar* s);
-
-  /// Replace the m characters at pos with wide character string s
-  FXString& replace(FXint pos,FXint m,const FXwchar* s);
-
-  /// Replace the m characters at pos with narrow character string s
-  FXString& replace(FXint pos,FXint m,const FXnchar* s);
-
-  /// Replace the m characters at pos with string s
-  FXString& replace(FXint pos,FXint m,const FXString& s);
-
-  /// Move range of m characters from src position to dst position
-  FXString& move(FXint dst,FXint src,FXint n);
-
-  /// Remove one character
-  FXString& erase(FXint pos);
-
-  /// Remove substring
-  FXString& erase(FXint pos,FXint n);
-
-  /// Return number of occurrences of ch in string
-  FXint contains(FXchar ch) const;
-
-  /// Return number of occurrences of string sub in string
-  FXint contains(const FXchar* sub,FXint n) const;
-
-  /// Return number of occurrences of string sub in string
-  FXint contains(const FXchar* sub) const;
-
-  /// Return number of occurrences of string sub in string
-  FXint contains(const FXString& sub) const;
-
-  /// Substitute one character by another
-  FXString& substitute(FXchar org,FXchar sub,bool all=true);
-
-  /// Substitute one string by another
-  FXString& substitute(const FXchar* org,FXint olen,const FXchar *rep,FXint rlen,bool all=true);
-
-  /// Substitute one string by another
-  FXString& substitute(const FXchar* org,const FXchar *rep,bool all=true);
-
-  /// Substitute one string by another
-  FXString& substitute(const FXString& org,const FXString& rep,bool all=true);
-
-  /// Simplify whitespace in string
-  FXString& simplify();
-
-  /// Remove leading and trailing whitespace
-  FXString& trim();
-
-  /// Remove leading whitespace
-  FXString& trimBegin();
-
-  /// Remove trailing whitespace
-  FXString& trimEnd();
-
-  /// Truncate string at pos
-  FXString& trunc(FXint pos);
-
-  /// Clear
-  FXString& clear();
-
-  /// Get left most part
-  FXString left(FXint n) const;
-
-  /// Get right most part
-  FXString right(FXint n) const;
-
-  /// Get some part in the middle
-  FXString mid(FXint pos,FXint n) const;
-
-  /**
-  * Return all characters before the n-th occurrence of ch,
-  * searching from the beginning of the string. If the character
-  * is not found, return the entire string.  If n<=0, return
-  * the empty string.
-  */
-  FXString before(FXchar ch,FXint n=1) const;
-
-  /**
-  * Return all characters before the n-th occurrence of ch,
-  * searching from the end of the string. If the character
-  * is not found, return the empty string. If n<=0, return
-  * the entire string.
-  */
-  FXString rbefore(FXchar ch,FXint n=1) const;
-
-  /**
-  * Return all characters after the nth occurrence of ch,
-  * searching from the beginning of the string. If the character
-  * is not found, return the empty string.  If n<=0, return
-  * the entire string.
-  */
-  FXString after(FXchar ch,FXint n=1) const;
-
-  /**
-  * Return all characters after the nth occurrence of ch,
-  * searching from the end of the string. If the character
-  * is not found, return the entire string. If n<=0, return
-  * the empty string.
-  */
-  FXString rafter(FXchar ch,FXint n=1) const;
-
-  /// Find a character, searching forward; return position or -1
-  FXint find(FXchar c,FXint pos=0) const;
-
-  /// Find a character, searching backward; return position or -1
-  FXint rfind(FXchar c,FXint pos=2147483647) const;
-
-  /// Find n-th occurrence of character, searching forward; return position or -1
-  FXint find(FXchar c,FXint pos,FXint n) const;
-
-  /// Find n-th occurrence of character, searching backward; return position or -1
-  FXint rfind(FXchar c,FXint pos,FXint n) const;
-
-  /// Find a substring of length n, searching forward; return position or -1
-  FXint find(const FXchar* substr,FXint n,FXint pos) const;
-
-  /// Find a substring of length n, searching backward; return position or -1
-  FXint rfind(const FXchar* substr,FXint n,FXint pos) const;
-
-  /// Find a substring, searching forward; return position or -1
-  FXint find(const FXchar* substr,FXint pos=0) const;
-
-  /// Find a substring, searching backward; return position or -1
-  FXint rfind(const FXchar* substr,FXint pos=2147483647) const;
-
-  /// Find a substring, searching forward; return position or -1
-  FXint find(const FXString& substr,FXint pos=0) const;
-
-  /// Find a substring, searching backward; return position or -1
-  FXint rfind(const FXString& substr,FXint pos=2147483647) const;
-
-  /// Find first character in the set of size n, starting from pos; return position or -1
-  FXint find_first_of(const FXchar* set,FXint n,FXint pos) const;
-
-  /// Find first character in the set, starting from pos; return position or -1
-  FXint find_first_of(const FXchar* set,FXint pos=0) const;
-
-  /// Find first character in the set, starting from pos; return position or -1
-  FXint find_first_of(const FXString& set,FXint pos=0) const;
-
-  /// Find first character, starting from pos; return position or -1
-  FXint find_first_of(FXchar c,FXint pos=0) const;
-
-  /// Find last character in the set of size n, starting from pos; return position or -1
-  FXint find_last_of(const FXchar* set,FXint n,FXint pos) const;
-
-  /// Find last character in the set, starting from pos; return position or -1
-  FXint find_last_of(const FXchar* set,FXint pos=2147483647) const;
-
-  /// Find last character in the set, starting from pos; return position or -1
-  FXint find_last_of(const FXString& set,FXint pos=2147483647) const;
-
-  /// Find last character, starting from pos; return position or -1
-  FXint find_last_of(FXchar c,FXint pos=0) const;
-
-  /// Find first character NOT in the set of size n, starting from pos; return position or -1
-  FXint find_first_not_of(const FXchar* set,FXint n,FXint pos) const;
-
-  /// Find first character NOT in the set, starting from pos; return position or -1
-  FXint find_first_not_of(const FXchar* set,FXint pos=0) const;
-
-  /// Find first character NOT in the set, starting from pos; return position or -1
-  FXint find_first_not_of(const FXString& set,FXint pos=0) const;
-
-  /// Find first character NOT equal to c, starting from pos; return position or -1
-  FXint find_first_not_of(FXchar c,FXint pos=0) const;
-
-  /// Find last character NOT in the set of size n, starting from pos; return position or -1
-  FXint find_last_not_of(const FXchar* set,FXint n,FXint pos) const;
-
-  /// Find last character NOT in the set, starting from pos; return position or -1
-  FXint find_last_not_of(const FXchar* set,FXint pos=2147483647) const;
-
-  /// Find last character NOT in the set, starting from pos; return position or -1
-  FXint find_last_not_of(const FXString& set,FXint pos=2147483647) const;
-
-  /// Find last character NOT equal to c, starting from pos; return position or -1
-  FXint find_last_not_of(FXchar c,FXint pos=0) const;
-
-  /// Format a string a-la printf
-  FXString& format(const FXchar* fmt,...) FX_PRINTF(2,3) ;
-  FXString& vformat(const FXchar* fmt,va_list args);
-
-  /// Scan a string a-la scanf
-  FXint scan(const FXchar* fmt,...) const FX_SCANF(2,3) ;
-  FXint vscan(const FXchar* fmt,va_list args) const;
-
-  /// Get hash value
-  FXuint hash() const;
-
-  /// Compare
-  friend FXAPI FXint compare(const FXchar* s1,const FXchar* s2);
-  friend FXAPI FXint compare(const FXchar* s1,const FXString& s2);
-  friend FXAPI FXint compare(const FXString& s1,const FXchar* s2);
-  friend FXAPI FXint compare(const FXString& s1,const FXString& s2);
-
-  /// Compare up to n
-  friend FXAPI FXint compare(const FXchar* s1,const FXchar* s2,FXint n);
-  friend FXAPI FXint compare(const FXchar* s1,const FXString& s2,FXint n);
-  friend FXAPI FXint compare(const FXString& s1,const FXchar* s2,FXint n);
-  friend FXAPI FXint compare(const FXString& s1,const FXString& s2,FXint n);
-
-  /// Compare case insensitive
-  friend FXAPI FXint comparecase(const FXchar* s1,const FXchar* s2);
-  friend FXAPI FXint comparecase(const FXchar* s1,const FXString& s2);
-  friend FXAPI FXint comparecase(const FXString& s1,const FXchar* s2);
-  friend FXAPI FXint comparecase(const FXString& s1,const FXString& s2);
-
-  /// Compare case insensitive up to n
-  friend FXAPI FXint comparecase(const FXchar* s1,const FXchar* s2,FXint n);
-  friend FXAPI FXint comparecase(const FXchar* s1,const FXString& s2,FXint n);
-  friend FXAPI FXint comparecase(const FXString& s1,const FXchar* s2,FXint n);
-  friend FXAPI FXint comparecase(const FXString& s1,const FXString& s2,FXint n);
-
-  /// Compare with numeric interpretation
-  friend FXAPI FXint compareversion(const FXchar* s1,const FXchar* s2);
-  friend FXAPI FXint compareversion(const FXchar* s1,const FXString& s2);
-  friend FXAPI FXint compareversion(const FXString& s1,const FXchar* s2);
-  friend FXAPI FXint compareversion(const FXString& s1,const FXString& s2);
-
-  /// Comparison operators
-  friend FXAPI bool operator==(const FXString& s1,const FXString& s2);
-  friend FXAPI bool operator==(const FXString& s1,const FXchar* s2);
-  friend FXAPI bool operator==(const FXchar* s1,const FXString& s2);
-
-  friend FXAPI bool operator!=(const FXString& s1,const FXString& s2);
-  friend FXAPI bool operator!=(const FXString& s1,const FXchar* s2);
-  friend FXAPI bool operator!=(const FXchar* s1,const FXString& s2);
-
-  friend FXAPI bool operator<(const FXString& s1,const FXString& s2);
-  friend FXAPI bool operator<(const FXString& s1,const FXchar* s2);
-  friend FXAPI bool operator<(const FXchar* s1,const FXString& s2);
-
-  friend FXAPI bool operator<=(const FXString& s1,const FXString& s2);
-  friend FXAPI bool operator<=(const FXString& s1,const FXchar* s2);
-  friend FXAPI bool operator<=(const FXchar* s1,const FXString& s2);
-
-  friend FXAPI bool operator>(const FXString& s1,const FXString& s2);
-  friend FXAPI bool operator>(const FXString& s1,const FXchar* s2);
-  friend FXAPI bool operator>(const FXchar* s1,const FXString& s2);
-
-  friend FXAPI bool operator>=(const FXString& s1,const FXString& s2);
-  friend FXAPI bool operator>=(const FXString& s1,const FXchar* s2);
-  friend FXAPI bool operator>=(const FXchar* s1,const FXString& s2);
-
-  /// Append operators
-  FXString& operator+=(const FXString& s);
-  FXString& operator+=(const FXchar* s);
-  FXString& operator+=(const FXwchar* s);
-  FXString& operator+=(const FXnchar* s);
-  FXString& operator+=(FXchar c);
-
-  /// Concatenate one FXString with another
-  friend FXAPI FXString operator+(const FXString& s1,const FXString& s2);
-
-  /// Concatenate FXString and a string
-  friend FXAPI FXString operator+(const FXString& s1,const FXchar* s2);
-  friend FXAPI FXString operator+(const FXString& s1,const FXwchar* s2);
-  friend FXAPI FXString operator+(const FXString& s1,const FXnchar* s2);
-
-  /// Concatenate string and FXString
-  friend FXAPI FXString operator+(const FXchar* s1,const FXString& s2);
-  friend FXAPI FXString operator+(const FXwchar* s1,const FXString& s2);
-  friend FXAPI FXString operator+(const FXnchar* s1,const FXString& s2);
-
-  /// Concatenate string and single character
-  friend FXAPI FXString operator+(const FXString& s,FXchar c);
-  friend FXAPI FXString operator+(FXchar c,const FXString& s);
-
-  /// Saving to a stream
-  friend FXAPI FXStream& operator<<(FXStream& store,const FXString& s);
-
-  /// Load from a stream
-  friend FXAPI FXStream& operator>>(FXStream& store,FXString& s);
-
-  /// Format a string a-la printf
-  friend FXAPI FXString FXStringFormat(const FXchar* fmt,...) FX_PRINTF(1,2) ;
-  friend FXAPI FXString FXStringVFormat(const FXchar* fmt,va_list args);
-
-  /**
-  * Convert integer number to a string, using the given number
-  * base, which must be between 2 and 16.
-  */
-  friend FXAPI FXString FXStringVal(FXint num,FXint base);
-  friend FXAPI FXString FXStringVal(FXuint num,FXint base);
-
-  /**
-  * Convert long integer number to a string, using the given number
-  * base, which must be between 2 and 16.
-  */
-  friend FXAPI FXString FXStringVal(FXlong num,FXint base);
-  friend FXAPI FXString FXStringVal(FXulong num,FXint base);
-
-  /**
-  * Convert real number to a string, using the given procision and
-  * exponential notation mode, which may be FALSE (never), TRUE (always), or
-  * MAYBE (when needed).
-  */
-  friend FXAPI FXString FXStringVal(FXfloat num,FXint prec,FXint exp);
-  friend FXAPI FXString FXStringVal(FXdouble num,FXint prec,FXint exp);
-
-  /// Convert string to a integer number, assuming given number base
-  friend FXAPI FXint FXIntVal(const FXString& s,FXint base);
-  friend FXAPI FXuint FXUIntVal(const FXString& s,FXint base);
-
-  /// Convert string to long integer number, assuming given number base
-  friend FXAPI FXlong FXLongVal(const FXString& s,FXint base);
-  friend FXAPI FXulong FXULongVal(const FXString& s,FXint base);
-
-  /// Convert string into real number
-  friend FXAPI FXfloat FXFloatVal(const FXString& s);
-  friend FXAPI FXdouble FXDoubleVal(const FXString& s);
-
-  /// Return utf8 from ascii containing unicode escapes
-  friend FXAPI FXString fromAscii(const FXString& s);
-
-  /// Return ascii containing unicode escapes from utf8
-  friend FXAPI FXString toAscii(const FXString& s);
-
-  /// Escape special characters in a string
-  friend FXAPI FXString escape(const FXString& s);
-
-  /// Unescape special characters in a string
-  friend FXAPI FXString unescape(const FXString& s);
-
-  /// Return normalized string, i.e. reordering of diacritical marks
-  friend FXAPI FXString normalize(const FXString& s);
-
-  /// Return normalized decomposition of string
-  friend FXAPI FXString decompose(const FXString& s,FXuint kind);
-
-  /// Return normalized composition of string; this first performs normalized decomposition
-  friend FXAPI FXString compose(const FXString& s,FXuint kind);
-
-  /// Swap two strings
-  friend inline void swap(FXString& a,FXString& b);
-
-  /// Convert to and from dos
-  friend FXAPI FXString& unixToDos(FXString& str);
-  friend FXAPI FXString& dosToUnix(FXString& str);
-
-  /// Delete
- ~FXString();
-  };
-
-
-inline void swap(FXString& a,FXString& b){ FXchar *t=a.str; a.str=b.str; b.str=t; }
-
-extern FXAPI FXint compare(const FXchar* s1,const FXchar* s2);
-extern FXAPI FXint compare(const FXchar* s1,const FXString& s2);
-extern FXAPI FXint compare(const FXString& s1,const FXchar* s2);
-extern FXAPI FXint compare(const FXString& s1,const FXString& s2);
-
-extern FXAPI FXint compare(const FXchar* s1,const FXchar* s2,FXint n);
-extern FXAPI FXint compare(const FXchar* s1,const FXString& s2,FXint n);
-extern FXAPI FXint compare(const FXString& s1,const FXchar* s2,FXint n);
-extern FXAPI FXint compare(const FXString& s1,const FXString& s2,FXint n);
-
-extern FXAPI FXint comparecase(const FXchar* s1,const FXchar* s2);
-extern FXAPI FXint comparecase(const FXchar* s1,const FXString& s2);
-extern FXAPI FXint comparecase(const FXString& s1,const FXchar* s2);
-extern FXAPI FXint comparecase(const FXString& s1,const FXString& s2);
-
-extern FXAPI FXint comparecase(const FXchar* s1,const FXchar* s2,FXint n);
-extern FXAPI FXint comparecase(const FXchar* s1,const FXString& s2,FXint n);
-extern FXAPI FXint comparecase(const FXString& s1,const FXchar* s2,FXint n);
-extern FXAPI FXint comparecase(const FXString& s1,const FXString& s2,FXint n);
-
-extern FXAPI FXint compareversion(const FXchar* s1,const FXchar* s2);
-extern FXAPI FXint compareversion(const FXchar* s1,const FXString& s2);
-extern FXAPI FXint compareversion(const FXString& s1,const FXchar* s2);
-extern FXAPI FXint compareversion(const FXString& s1,const FXString& s2);
-
-extern FXAPI bool operator==(const FXString& s1,const FXString& s2);
-extern FXAPI bool operator==(const FXString& s1,const FXchar* s2);
-extern FXAPI bool operator==(const FXchar* s1,const FXString& s2);
-
-extern FXAPI bool operator!=(const FXString& s1,const FXString& s2);
-extern FXAPI bool operator!=(const FXString& s1,const FXchar* s2);
-extern FXAPI bool operator!=(const FXchar* s1,const FXString& s2);
-
-extern FXAPI bool operator<(const FXString& s1,const FXString& s2);
-extern FXAPI bool operator<(const FXString& s1,const FXchar* s2);
-extern FXAPI bool operator<(const FXchar* s1,const FXString& s2);
-
-extern FXAPI bool operator<=(const FXString& s1,const FXString& s2);
-extern FXAPI bool operator<=(const FXString& s1,const FXchar* s2);
-extern FXAPI bool operator<=(const FXchar* s1,const FXString& s2);
-
-extern FXAPI bool operator>(const FXString& s1,const FXString& s2);
-extern FXAPI bool operator>(const FXString& s1,const FXchar* s2);
-extern FXAPI bool operator>(const FXchar* s1,const FXString& s2);
-
-extern FXAPI bool operator>=(const FXString& s1,const FXString& s2);
-extern FXAPI bool operator>=(const FXString& s1,const FXchar* s2);
-extern FXAPI bool operator>=(const FXchar* s1,const FXString& s2);
-
-extern FXAPI FXString operator+(const FXString& s1,const FXString& s2);
-
-extern FXAPI FXString operator+(const FXString& s1,const FXchar* s2);
-extern FXAPI FXString operator+(const FXString& s1,const FXwchar* s2);
-extern FXAPI FXString operator+(const FXString& s1,const FXnchar* s2);
-
-extern FXAPI FXString operator+(const FXchar* s1,const FXString& s2);
-extern FXAPI FXString operator+(const FXwchar* s1,const FXString& s2);
-extern FXAPI FXString operator+(const FXnchar* s1,const FXString& s2);
-
-extern FXAPI FXString operator+(const FXString& s,FXchar c);
-extern FXAPI FXString operator+(FXchar c,const FXString& s);
-
-extern FXAPI FXStream& operator<<(FXStream& store,const FXString& s);
-extern FXAPI FXStream& operator>>(FXStream& store,FXString& s);
-
-extern FXAPI FXString FXStringFormat(const FXchar* fmt,...) FX_PRINTF(1,2) ;
-extern FXAPI FXString FXStringVFormat(const FXchar* fmt,va_list args);
-
-extern FXAPI FXString FXStringVal(FXint num,FXint base=10);
-extern FXAPI FXString FXStringVal(FXuint num,FXint base=10);
-extern FXAPI FXString FXStringVal(FXlong num,FXint base=10);
-extern FXAPI FXString FXStringVal(FXulong num,FXint base=10);
-extern FXAPI FXString FXStringVal(FXfloat num,FXint prec=6,FXint exp=MAYBE);
-extern FXAPI FXString FXStringVal(FXdouble num,FXint prec=6,FXint exp=MAYBE);
-
-extern FXAPI FXint FXIntVal(const FXString& s,FXint base=10);
-extern FXAPI FXuint FXUIntVal(const FXString& s,FXint base=10);
-extern FXAPI FXlong FXLongVal(const FXString& s,FXint base=10);
-extern FXAPI FXulong FXULongVal(const FXString& s,FXint base=10);
-extern FXAPI FXfloat FXFloatVal(const FXString& s);
-extern FXAPI FXdouble FXDoubleVal(const FXString& s);
-
-extern FXAPI FXString fromAscii(const FXString& s);
-extern FXAPI FXString toAscii(const FXString& s);
-
-extern FXAPI FXString escape(const FXString& s);
-extern FXAPI FXString unescape(const FXString& s);
-
-extern FXAPI FXString normalize(const FXString& s);
-extern FXAPI FXString decompose(const FXString& s,FXuint kind);
-extern FXAPI FXString compose(const FXString& s,FXuint kind);
-
-extern FXAPI FXString& unixToDos(FXString& str);
-extern FXAPI FXString& dosToUnix(FXString& str);
-
-}
-
-#endif
diff --git a/fox-includes/FXStringDict.h b/fox-includes/FXStringDict.h
deleted file mode 100755
index b9672977..00000000
--- a/fox-includes/FXStringDict.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                  S t r i n g   D i c t i o n a r y    C l a s s               *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXStringDict.h 2345 2006-02-14 03:07:05Z lyle $                      *
-********************************************************************************/
-#ifndef FXSTRINGDICT_H
-#define FXSTRINGDICT_H
-
-#ifndef FXDICT_H
-#include "FXDict.h"
-#endif
-
-namespace FX {
-
-/**
-* String dictionary maps a character string to a character string.
-* The inserted strings are copied when they're inserted.
-*/
-class FXAPI FXStringDict : public FXDict {
-  FXDECLARE(FXStringDict)
-protected:
-  virtual void *createData(const void*);
-  virtual void deleteData(void*);
-public:
-
-  /// Construct a string dictionary
-  FXStringDict();
-
-  /// Copy constructor
-  FXStringDict(const FXStringDict& orig);
-
-  /// Assignment operator
-  FXStringDict &operator=(const FXStringDict& orig);
-
-  /// Insert a new string indexed by key, with given mark flag
-  const FXchar* insert(const FXchar* ky,const FXchar* str,bool mrk=false){ return (const FXchar*)FXDict::insert(ky,str,mrk); }
-
-  /// Replace or insert a new string indexed by key, unless given mark is lower that the existing mark
-  const FXchar* replace(const FXchar* ky,const FXchar* str,bool mrk=false){ return (const FXchar*)FXDict::replace(ky,str,mrk); }
-
-  /// Remove entry indexed by key
-  const FXchar* remove(const FXchar* ky){ return (const FXchar*)FXDict::remove(ky); }
-
-  /// Return the entry indexed by key, or return NULL if the key does not exist
-  const FXchar* find(const FXchar* ky) const { return (const FXchar*)FXDict::find(ky); }
-
-  /// Return the string at position pos
-  const FXchar* data(FXuint pos) const { return (const FXchar*)dict[pos].data; }
-
-  /// Destructor
-  virtual ~FXStringDict();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXSwitcher.h b/fox-includes/FXSwitcher.h
deleted file mode 100755
index 73484ce0..00000000
--- a/fox-includes/FXSwitcher.h
+++ /dev/null
@@ -1,121 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                  S w i t c h   C o n t a i n e r   W i d g e t                *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2003 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXSwitcher.h 1536 2003-05-14 21:41:00Z lyle $                        *
-********************************************************************************/
-#ifndef FXSWITCHER_H
-#define FXSWITCHER_H
-
-#ifndef FXPACKER_H
-#include "FXPacker.h"
-#endif
-
-namespace FX {
-
-/// Switcher options
-enum {
-  SWITCHER_HCOLLAPSE = 0x00020000,  /// Collapse horizontally to width of current child
-  SWITCHER_VCOLLAPSE = 0x00040000   /// Collapse vertically to height of current child
-  };
-
-
-/**
-* The Switcher layout manager automatically arranges its child
-* windows such that one of them is placed on top; all other
-* child windows are hidden.
-* Switcher provides a convenient method to conserve screen
-* real-estate by arranging several GUI panels to appear in the
-* same space, depending on context.
-* Switcher ignores all layout hints from its children:- all
-* children are stretched according to the switcher layout
-* managers own size.
-* When the SWITCHER_HCOLLAPSE or SWITCHER_VCOLLAPSE options
-* are used, Switcher's default size is based on the width or
-* height of the current child, instead of the maximum width
-* or height of all of the children.
-*/
-class FXAPI FXSwitcher : public FXPacker {
-  FXDECLARE(FXSwitcher)
-protected:
-  FXint  current;
-protected:
-  FXSwitcher(){}
-private:
-  FXSwitcher(const FXSwitcher&);
-  FXSwitcher& operator=(const FXSwitcher&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-  long onCmdOpen(FXObject*,FXSelector,void*);
-  long onUpdOpen(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_OPEN_FIRST=FXPacker::ID_LAST,
-    ID_OPEN_SECOND,
-    ID_OPEN_THIRD,
-    ID_OPEN_FOURTH,
-    ID_OPEN_FIFTH,
-    ID_OPEN_SIXTH,
-    ID_OPEN_SEVENTH,
-    ID_OPEN_EIGHTH,
-    ID_OPEN_NINETH,
-    ID_OPEN_TENTH,
-    ID_OPEN_LAST=ID_OPEN_FIRST+100,
-    ID_LAST
-    };
-public:
-
-  /// Construct a switcher layout manager
-  FXSwitcher(FXComposite *p,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_SPACING,FXint pr=DEFAULT_SPACING,FXint pt=DEFAULT_SPACING,FXint pb=DEFAULT_SPACING);
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Bring the child window at index to the top
-  void setCurrent(FXint index,FXbool notify=FALSE);
-
-  /// Return the index of the child window currently on top
-  FXint getCurrent() const { return current; }
-
-  /// Set the switcher style flags
-  void setSwitcherStyle(FXuint style);
-
-  /// Get the switcher style flags
-  FXuint getSwitcherStyle() const;
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXSystem.h b/fox-includes/FXSystem.h
deleted file mode 100644
index 9229490f..00000000
--- a/fox-includes/FXSystem.h
+++ /dev/null
@@ -1,124 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*         M i s c e l l a n e o u s   S y s t e m   F u n c t i o n s           *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2005,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXSystem.h 2343 2006-02-12 20:26:26Z lyle $                           *
-********************************************************************************/
-#ifndef FXSYSTEM_H
-#define FXSYSTEM_H
-
-
-
-namespace FX {
-
-
-
-namespace FXSystem {
-
-
-/// Return current time
-FXTime FXAPI now();
-
-/// Convert time value to date-string
-FXString FXAPI time(FXTime value);
-
-/**
-* Convert time value to date-string as per strftime.
-* Format characters supported by most systems are:
-*
-*  %a %A %b %B %c %d %H %I %j %m %M %p %S %U %w %W %x %X %y %Y %Z %%
-*
-* Some systems support additional conversions.
-*/
-FXString FXAPI time(const FXchar *format,FXTime value);
-
-
-
-/// Get effective user id
-FXuint FXAPI user();
-
-/// Get effective group id
-FXuint FXAPI group();
-
-/// Return owner name from uid if available
-FXString FXAPI userName(FXuint uid);
-
-/// Return group name from gid if available
-FXString FXAPI groupName(FXuint gid);
-
-/// Get current effective user name
-FXString FXAPI currentUserName();
-
-/// Get current effective group name
-FXString FXAPI currentGroupName();
-
-
-/// Get permissions string
-FXString FXAPI modeString(FXuint mode);
-
-
-
-/// Return value of environment variable name
-FXString FXAPI getEnvironment(const FXString& name);
-
-/// Change value of environment variable name, return true if success
-bool FXAPI setEnvironment(const FXString& name,const FXString& value);
-
-
-
-/// Get the current working directory
-FXString FXAPI getCurrentDirectory();
-
-/// Set the current working directory
-FXbool FXAPI setCurrentDirectory(const FXString& path);
-
-/// Return the current drive (for Win32 systems)
-FXString FXAPI getCurrentDrive();
-
-/// Set the current drive (for Win32 systems)
-FXbool FXAPI setCurrentDrive(const FXString& prefix);
-
-
-
-/// Get executable path
-FXString FXAPI getExecPath();
-
-/// Return the home directory for the current user
-FXString FXAPI getHomeDirectory();
-
-/// Return the home directory for a given user
-FXString FXAPI getUserDirectory(const FXString& user);
-
-/// Return temporary directory
-FXString FXAPI getTempDirectory();
-
-
-
-/**
-* Get DLL name for given base name; for example "png"
-* becomes "libpng.so" on Linux, and "png.dll" on Windows.
-*/
-FXString FXAPI dllName(const FXString& name);
-
-}
-
-}
-
-#endif
diff --git a/fox-includes/FXTGAIcon.h b/fox-includes/FXTGAIcon.h
deleted file mode 100755
index 65f3865a..00000000
--- a/fox-includes/FXTGAIcon.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                     T A R G A   I c o n   O b j e c t                         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2001,2006 by Janusz Ganczarski.   All Rights Reserved.          *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXTGAIcon.h 2343 2006-02-12 20:26:26Z lyle $                         *
-********************************************************************************/
-#ifndef FXTGAICON_H
-#define FXTGAICON_H
-
-#ifndef FXICON_H
-#include "FXIcon.h"
-#endif
-
-namespace FX {
-
-
-/// TARGA image format icon
-class FXAPI FXTGAIcon : public FXIcon {
-  FXDECLARE(FXTGAIcon)
-protected:
-  FXTGAIcon(){}
-private:
-  FXTGAIcon(const FXTGAIcon&);
-  FXTGAIcon &operator=(const FXTGAIcon&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct icon from memory stream formatted in TARGA format
-  FXTGAIcon(FXApp* a,const void *pix=NULL,FXColor clr=FXRGB(192,192,192),FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Save pixels into stream in TARGA format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in TARGA format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy icon
-  virtual ~FXTGAIcon();
-  };
-
-
-/**
-* Check if stream contains a TARGA, return TRUE if so.
-*/
-extern FXAPI bool fxcheckTGA(FXStream& store);
-
-
-/**
-* Load an TARGA file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadTGA(FXStream& store,FXColor*& data,FXint& width,FXint& height);
-
-
-/**
-* Save an TARGA file to a stream.
-*/
-extern FXAPI bool fxsaveTGA(FXStream& store,const FXColor *data,FXint width,FXint height);
-
-}
-
-#endif
diff --git a/fox-includes/FXTGAImage.h b/fox-includes/FXTGAImage.h
deleted file mode 100755
index 6710de2c..00000000
--- a/fox-includes/FXTGAImage.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       T A R G A  I m a g e   O b j e c t                      *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2001,2006 by Janusz Ganczarski.   All Rights Reserved.          *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXTGAImage.h 2343 2006-02-12 20:26:26Z lyle $                        *
-********************************************************************************/
-#ifndef FXTGAIMAGE_H
-#define FXTGAIMAGE_H
-
-#ifndef FXIMAGE_H
-#include "FXImage.h"
-#endif
-
-namespace FX {
-
-
-/// TARGA graphics file
-class FXAPI FXTGAImage : public FXImage {
-  FXDECLARE(FXTGAImage)
-protected:
-  FXTGAImage(){}
-private:
-  FXTGAImage(const FXTGAImage&);
-  FXTGAImage &operator=(const FXTGAImage&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct image from memory stream formatted in TARGA file
-  FXTGAImage(FXApp* a,const void *pix=NULL,FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Save pixels into stream in TARGA file
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in TARGA format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy image
-  virtual ~FXTGAImage();
-  };
-
-
-/**
-* Check if stream contains a TARGA, return TRUE if so.
-*/
-extern FXAPI bool fxcheckTGA(FXStream& store);
-
-
-/**
-* Load an TARGA file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadTGA(FXStream& store,FXColor*& data,FXint& width,FXint& height);
-
-
-/**
-* Save an TARGA file to a stream.
-*/
-extern FXAPI bool fxsaveTGA(FXStream& store,const FXColor *data,FXint width,FXint height);
-
-}
-
-#endif
diff --git a/fox-includes/FXTIFIcon.h b/fox-includes/FXTIFIcon.h
deleted file mode 100755
index d6ba9b46..00000000
--- a/fox-includes/FXTIFIcon.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                          T I F F   I c o n   O b j e c t                      *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2001,2006 Eric Gillet.   All Rights Reserved.                   *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXTIFIcon.h 2343 2006-02-12 20:26:26Z lyle $                         *
-********************************************************************************/
-#ifndef FXTIFICON_H
-#define FXTIFICON_H
-
-#ifndef FXICON_H
-#include "FXIcon.h"
-#endif
-
-namespace FX {
-
-
-/// TIFF Icon class
-class FXAPI FXTIFIcon : public FXIcon {
-  FXDECLARE(FXTIFIcon)
-protected:
-  FXushort codec;
-protected:
-  FXTIFIcon(){}
-private:
-  FXTIFIcon(const FXTIFIcon&);
-  FXTIFIcon &operator=(const FXTIFIcon&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct an icon from memory stream formatted in TIFF format
-  FXTIFIcon(FXApp *a,const void *pix=NULL,FXColor clr=FXRGB(192,192,192),FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// True if format is supported
-  static const bool supported;
-
-  /// Set codec to save with
-  void setCodec(FXuint c){ codec=c; }
-
-  /// Get codec setting
-  FXuint getCodec() const { return codec; }
-
-  /// Save pixels into stream in TIFF format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in TIFF format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy
-  virtual ~FXTIFIcon();
-  };
-
-
-/**
-* Check if stream contains a TIFF, return TRUE if so.
-*/
-extern FXAPI bool fxcheckTIF(FXStream& store);
-
-
-/**
-* Load an TIFF (Tagged Image File Format) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadTIF(FXStream& store,FXColor*& data,FXint& width,FXint& height,FXushort& codec);
-
-
-/**
-* Save an TIFF (Tagged Image File Format) file to a stream.
-*/
-extern FXAPI bool fxsaveTIF(FXStream& store,const FXColor* data,FXint width,FXint height,FXushort codec);
-
-}
-
-#endif
diff --git a/fox-includes/FXTIFImage.h b/fox-includes/FXTIFImage.h
deleted file mode 100755
index 0e8a4fd7..00000000
--- a/fox-includes/FXTIFImage.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                          T I F F   I m a g e   O b j e c t                    *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2001,2006 Eric Gillet.   All Rights Reserved.                   *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXTIFImage.h 2343 2006-02-12 20:26:26Z lyle $                        *
-********************************************************************************/
-#ifndef FXTIFIMAGE_H
-#define FXTIFIMAGE_H
-
-#ifndef FXIMAGE_H
-#include "FXImage.h"
-#endif
-
-namespace FX {
-
-
-/// TIFF Image class
-class FXAPI FXTIFImage : public FXImage {
-  FXDECLARE(FXTIFImage)
-protected:
-  FXushort codec;
-protected:
-  FXTIFImage(){}
-private:
-  FXTIFImage(const FXTIFImage&);
-  FXTIFImage &operator=(const FXTIFImage&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct an image from memory stream formatted in TIFF format
-  FXTIFImage(FXApp *a,const void *pix=NULL,FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// True if format is supported
-  static const bool supported;
-
-  /// Set codec to save with
-  void setCodec(FXuint c){ codec=c; }
-
-  /// Get codec setting
-  FXuint getCodec() const { return codec; }
-
-  /// Load pixels into stream in TIFF format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Save pixels from stream in TIFF format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Destroy
-  virtual ~FXTIFImage();
-  };
-
-
-/**
-* Check if stream contains a TIFF, return TRUE if so.
-*/
-extern FXAPI bool fxcheckTIF(FXStream& store);
-
-
-/**
-* Load an TIFF (Tagged Image File Format) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadTIF(FXStream& store,FXColor*& data,FXint& width,FXint& height,FXushort& codec);
-
-
-/**
-* Save an TIFF (Tagged Image File Format) file to a stream.
-*/
-extern FXAPI bool fxsaveTIF(FXStream& store,const FXColor* data,FXint width,FXint height,FXushort codec);
-
-}
-
-#endif
diff --git a/fox-includes/FXTabBar.h b/fox-includes/FXTabBar.h
deleted file mode 100755
index 30b2b527..00000000
--- a/fox-includes/FXTabBar.h
+++ /dev/null
@@ -1,135 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                           T a b  B a r   W i d g e t                          *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXTabBar.h 2241 2005-11-09 13:51:59Z lyle $                          *
-********************************************************************************/
-#ifndef FXTABBAR_H
-#define FXTABBAR_H
-
-#ifndef FXPACKER_H
-#include "FXPacker.h"
-#endif
-
-namespace FX {
-
-
-/// Tab Book options
-enum {
-  TABBOOK_TOPTABS    = 0,                                   /// Tabs on top (default)
-  TABBOOK_BOTTOMTABS = 0x00020000,                          /// Tabs on bottom
-  TABBOOK_SIDEWAYS   = 0x00040000,                          /// Tabs on left
-  TABBOOK_LEFTTABS   = TABBOOK_SIDEWAYS|TABBOOK_TOPTABS,    /// Tabs on left
-  TABBOOK_RIGHTTABS  = TABBOOK_SIDEWAYS|TABBOOK_BOTTOMTABS, /// Tabs on right
-  TABBOOK_NORMAL     = TABBOOK_TOPTABS                      /// Normal tabs
-  };
-
-
-
-/**
-* The tab bar layout manager arranges tab items side by side,
-* and raises the active tab item above the neighboring tab items.
-* In a the horizontal arrangement, the tab bar can have the tab
-* items on the top or on the bottom.  In the vertical arrangement,
-* the tabs can be on the left or on the right.
-* When one of the tab items is pressed, the tab bar's setCurrent()
-* is called with notify=TRUE.  Thus causes the tab bar to send a
-* SEL_COMMAND message to its target.
-*/
-class FXAPI FXTabBar : public FXPacker {
-  FXDECLARE(FXTabBar)
-protected:
-  FXint current;        // Current tab index
-  FXint shift;          // Shift amount
-protected:
-  FXTabBar(){}
-private:
-  FXTabBar(const FXTabBar&);
-  FXTabBar& operator=(const FXTabBar&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onFocusNext(FXObject*,FXSelector,void*);
-  long onFocusPrev(FXObject*,FXSelector,void*);
-  long onFocusUp(FXObject*,FXSelector,void*);
-  long onFocusDown(FXObject*,FXSelector,void*);
-  long onFocusLeft(FXObject*,FXSelector,void*);
-  long onFocusRight(FXObject*,FXSelector,void*);
-  long onCmdOpenItem(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-  long onCmdOpen(FXObject*,FXSelector,void*);
-  long onUpdOpen(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_OPEN_ITEM=FXPacker::ID_LAST,   /// Sent from one of the FXTabItems
-    ID_OPEN_FIRST,                    /// Switch to panel ID_OPEN_FIRST+i
-    ID_OPEN_SECOND,
-    ID_OPEN_THIRD,
-    ID_OPEN_FOURTH,
-    ID_OPEN_FIFTH,
-    ID_OPEN_SIXTH,
-    ID_OPEN_SEVENTH,
-    ID_OPEN_EIGHTH,
-    ID_OPEN_NINETH,
-    ID_OPEN_TENTH,
-    ID_OPEN_LAST=ID_OPEN_FIRST+100,
-    ID_LAST
-    };
-public:
-
-  /// Construct a tab bar
-  FXTabBar(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=TABBOOK_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_SPACING,FXint pr=DEFAULT_SPACING,FXint pt=DEFAULT_SPACING,FXint pb=DEFAULT_SPACING);
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Perform layout
-  virtual void layout();
-
-  /**
-  * Change currently active tab item; this raises the active tab item
-  * slightly above the neighboring tab items.  If notify=TRUE then the
-  * tab bar will also send a SEL_COMMAND message to its target.
-  */
-  virtual void setCurrent(FXint panel,FXbool notify=FALSE);
-
-  /// Return the currently active tab item
-  FXint getCurrent() const { return current; }
-
-  /// Return tab bar style
-  FXuint getTabStyle() const;
-
-  /// Change tab tab style
-  void setTabStyle(FXuint style);
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXTabBook.h b/fox-includes/FXTabBook.h
deleted file mode 100755
index 4c1b396a..00000000
--- a/fox-includes/FXTabBook.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                         T a b   B o o k   W i d g e t                         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXTabBook.h 2241 2005-11-09 13:51:59Z lyle $                          *
-********************************************************************************/
-#ifndef FXTABBOOK_H
-#define FXTABBOOK_H
-
-#ifndef FXTABBAR_H
-#include "FXTabBar.h"
-#endif
-
-namespace FX {
-
-
-/**
-* The tab book layout manager arranges pairs of children;
-* the even numbered children (0,2,4,...) are usually tab items,
-* and are placed on the top.  The odd numbered children are
-* usually layout managers, and are placed below; all the odd
-* numbered children are placed on top of each other, similar
-* to the switcher widget.  When the user presses one of the
-* tab items, the tab item is raised above the neighboring tabs,
-* and the corresponding panel is raised to the top.
-* Thus, a tab book can be used to present many GUI controls
-* in a small space by placing several panels on top of each
-* other and using tab items to select the desired panel.
-* When one of the tab items is pressed, the tab book's setCurrent()
-* is called with notify=TRUE.  Thus causes the tab book to send a
-* SEL_COMMAND message to its target.
-*/
-class FXAPI FXTabBook : public FXTabBar {
-  FXDECLARE(FXTabBook)
-protected:
-  FXTabBook(){}
-private:
-  FXTabBook(const FXTabBook&);
-  FXTabBook& operator=(const FXTabBook&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onFocusNext(FXObject*,FXSelector,void*);
-  long onFocusPrev(FXObject*,FXSelector,void*);
-  long onFocusUp(FXObject*,FXSelector,void*);
-  long onFocusDown(FXObject*,FXSelector,void*);
-  long onFocusLeft(FXObject*,FXSelector,void*);
-  long onFocusRight(FXObject*,FXSelector,void*);
-  long onCmdOpenItem(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct tab book
-  FXTabBook(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=TABBOOK_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_SPACING,FXint pr=DEFAULT_SPACING,FXint pt=DEFAULT_SPACING,FXint pb=DEFAULT_SPACING);
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXTabItem.h b/fox-includes/FXTabItem.h
deleted file mode 100755
index 7ae26f90..00000000
--- a/fox-includes/FXTabItem.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                           T a b   I t e m    W i d g e t                      *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXTabItem.h 2343 2006-02-12 20:26:26Z lyle $                          *
-********************************************************************************/
-#ifndef FXTABITEM_H
-#define FXTABITEM_H
-
-#ifndef FXLABEL_H
-#include "FXLabel.h"
-#endif
-
-namespace FX {
-
-
-/// Tab Item orientations which affect border
-enum {
-  TAB_TOP          = 0,           // Top side tabs
-  TAB_LEFT         = 0x00800000,  // Left side tabs
-  TAB_RIGHT        = 0x01000000,  // Right side tabs
-  TAB_BOTTOM       = 0x01800000,  // Bottom side tabs
-  TAB_TOP_NORMAL   = JUSTIFY_NORMAL|ICON_BEFORE_TEXT|TAB_TOP|FRAME_RAISED|FRAME_THICK,
-  TAB_BOTTOM_NORMAL= JUSTIFY_NORMAL|ICON_BEFORE_TEXT|TAB_BOTTOM|FRAME_RAISED|FRAME_THICK,
-  TAB_LEFT_NORMAL  = JUSTIFY_LEFT|JUSTIFY_CENTER_Y|ICON_BEFORE_TEXT|TAB_LEFT|FRAME_RAISED|FRAME_THICK,
-  TAB_RIGHT_NORMAL = JUSTIFY_LEFT|JUSTIFY_CENTER_Y|ICON_BEFORE_TEXT|TAB_RIGHT|FRAME_RAISED|FRAME_THICK
-  };
-
-
-class FXTabBar;
-
-
-/**
-* A tab item is placed in a tab bar or tab book.
-* When selected, the tab item sends a message to its
-* parent, and causes itself to become the active tab,
-* and raised slightly above the other tabs.
-* In the tab book, activating a tab item also causes
-* the corresponding panel to be raised to the top.
-*/
-class FXAPI FXTabItem : public FXLabel {
-  FXDECLARE(FXTabItem)
-protected:
-  FXTabItem(){}
-private:
-  FXTabItem(const FXTabItem&);
-  FXTabItem& operator=(const FXTabItem&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onFocusIn(FXObject*,FXSelector,void*);
-  long onFocusOut(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onHotKeyPress(FXObject*,FXSelector,void*);
-  long onHotKeyRelease(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct a tab item
-  FXTabItem(FXTabBar* p,const FXString& text,FXIcon* ic=0,FXuint opts=TAB_TOP_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Returns true because a tab item can receive focus
-  virtual bool canFocus() const;
-
-  /// Return current tab item orientation
-  FXuint getTabOrientation() const;
-
-  /// Change tab item orientation
-  void setTabOrientation(FXuint style);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXTable.h b/fox-includes/FXTable.h
deleted file mode 100755
index 752d98e2..00000000
--- a/fox-includes/FXTable.h
+++ /dev/null
@@ -1,1009 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                            T a b l e   W i d g e t                            *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1999,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXTable.h 2360 2006-03-29 04:10:56Z lyle $                          *
-********************************************************************************/
-#ifndef FXTABLE_H
-#define FXTABLE_H
-
-#ifndef FXSCROLLAREA_H
-#include "FXScrollArea.h"
-#endif
-
-namespace FX {
-
-
-class FXIcon;
-class FXFont;
-class FXTable;
-class FXHeader;
-class FXButton;
-
-
-/// Default cell margin
-enum { DEFAULT_MARGIN = 2 };
-
-
-
-/// Table options
-enum {
-  TABLE_COL_SIZABLE     = 0x00100000,   /// Columns are resizable
-  TABLE_ROW_SIZABLE     = 0x00200000,   /// Rows are resizable
-  TABLE_NO_COLSELECT    = 0x00400000,   /// Disallow column selections
-  TABLE_NO_ROWSELECT    = 0x00800000,   /// Disallow row selections
-  TABLE_READONLY        = 0x01000000,   /// Table is NOT editable
-  TABLE_COL_RENUMBER    = 0x02000000,   /// Renumber columns
-  TABLE_ROW_RENUMBER    = 0x04000000    /// Renumber rows
-  };
-
-
-/// Position in table
-struct FXTablePos {
-  FXint  row;
-  FXint  col;
-  };
-
-
-/// Range of table cells
-struct FXTableRange {
-  FXTablePos fm;
-  FXTablePos to;
-  };
-
-
-/// Item in table
-class FXAPI FXTableItem : public FXObject {
-  FXDECLARE(FXTableItem)
-  friend class FXTable;
-protected:
-  FXString    label;
-  FXIcon     *icon;
-  void       *data;
-  FXuint      state;
-private:
-  FXTableItem(const FXTableItem&);
-  FXTableItem& operator=(const FXTableItem&);
-protected:
-  FXTableItem():icon(NULL),data(NULL),state(0){}
-  FXint textWidth(const FXTable* table) const;
-  FXint textHeight(const FXTable* table) const;
-  virtual void draw(const FXTable* table,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const;
-  virtual void drawBorders(const FXTable* table,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const;
-  virtual void drawContent(const FXTable* table,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const;
-  virtual void drawPattern(const FXTable* table,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const;
-  virtual void drawBackground(const FXTable* table,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const;
-public:
-  enum{
-    SELECTED   = 0x00000001,    /// Selected
-    FOCUS      = 0x00000002,    /// Focus
-    DISABLED   = 0x00000004,    /// Disabled
-    DRAGGABLE  = 0x00000008,    /// Draggable
-    RESERVED1  = 0x00000010,    /// Reserved
-    RESERVED2  = 0x00000020,    /// Reserved
-    ICONOWNED  = 0x00000040,    /// Icon owned by table item
-    RIGHT      = 0x00002000,    /// Align on right (default)
-    LEFT       = 0x00004000,    /// Align on left
-    CENTER_X   = 0,             /// Aling centered horizontally
-    TOP        = 0x00008000,    /// Align on top
-    BOTTOM     = 0x00010000,    /// Align on bottom
-    CENTER_Y   = 0,             /// Aling centered vertically (default)
-    BEFORE     = 0x00020000,    /// Icon before the text
-    AFTER      = 0x00040000,    /// Icon after the text
-    ABOVE      = 0x00080000,    /// Icon above the text
-    BELOW      = 0x00100000,    /// Icon below the text
-    LBORDER    = 0x00200000,    /// Draw left border
-    RBORDER    = 0x00400000,    /// Draw right border
-    TBORDER    = 0x00800000,    /// Draw top border
-    BBORDER    = 0x01000000     /// Draw bottom border
-    };
-public:
-
-  /// Construct new table item
-  FXTableItem(const FXString& text,FXIcon* ic=NULL,void* ptr=NULL):label(text),icon(ic),data(ptr),state(RIGHT|CENTER_Y){}
-
-  /// Change item's text label
-  virtual void setText(const FXString& txt);
-
-  /// Return item's text label
-  virtual FXString getText() const { return label; }
-
-  /// Change item's icon, deleting the old icon if it was owned
-  virtual void setIcon(FXIcon* icn,FXbool owned=FALSE);
-
-  /// Return item's icon
-  virtual FXIcon* getIcon() const { return icon; }
-
-  /// Change item's user data
-  void setData(void* ptr){ data=ptr; }
-
-  /// Get item's user data
-  void* getData() const { return data; }
-
-  /// Make item draw as focused
-  virtual void setFocus(FXbool focus);
-
-  /// Return true if item has focus
-  FXbool hasFocus() const { return (state&FOCUS)!=0; }
-
-  /// Select item
-  virtual void setSelected(FXbool selected);
-
-  /// Return true if this item is selected
-  FXbool isSelected() const { return (state&SELECTED)!=0; }
-
-  /// Enable or disable item
-  virtual void setEnabled(FXbool enabled);
-
-  /// Return true if this item is enabled
-  FXbool isEnabled() const { return (state&DISABLED)==0; }
-
-  /// Make item draggable
-  virtual void setDraggable(FXbool draggable);
-
-  /// Return true if this item is draggable
-  FXbool isDraggable() const { return (state&DRAGGABLE)!=0; }
-
-  /// Change item content justification
-  virtual void setJustify(FXuint justify=RIGHT|CENTER_Y);
-
-  /// Return item content justification
-  FXuint getJustify() const { return state&(RIGHT|LEFT|TOP|BOTTOM); }
-
-  /// Change item icon position
-  virtual void setIconPosition(FXuint mode);
-
-  /// Return item icon position
-  FXuint getIconPosition() const { return state&(BEFORE|AFTER|ABOVE|BELOW); }
-
-  /// Change item borders
-  virtual void setBorders(FXuint borders=0);
-
-  /// Return item borders
-  FXuint getBorders() const { return state&(LBORDER|RBORDER|TBORDER|BBORDER); }
-
-  /// Change item background stipple
-  virtual void setStipple(FXStipplePattern pattern);
-
-  /// Return item background stipple
-  FXStipplePattern getStipple() const;
-
-  /// Create input control for editing this item
-  virtual FXWindow *getControlFor(FXTable* table);
-
-  /// Set value from input control
-  virtual void setFromControl(FXWindow *control);
-
-  /// Return width of item
-  virtual FXint getWidth(const FXTable* table) const;
-
-  /// Return height of item
-  virtual FXint getHeight(const FXTable* table) const;
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Destroy server-side resources
-  virtual void destroy();
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destroy item and free icon if owned
-  virtual ~FXTableItem();
-  };
-
-
-/// Combobox Item
-class FXAPI FXComboTableItem : public FXTableItem {
-  FXDECLARE(FXComboTableItem)
-protected:
-  FXString selections;
-private:
-  FXComboTableItem(const FXComboTableItem&);
-  FXComboTableItem& operator=(const FXComboTableItem&);
-protected:
-  FXComboTableItem(){}
-public:
-
-  /// Construct new table item
-  FXComboTableItem(const FXString& text,FXIcon* ic=NULL,void* ptr=NULL);
-
-  /// Create input control for editing this item
-  virtual FXWindow *getControlFor(FXTable* table);
-
-  /// Set value from input control
-  virtual void setFromControl(FXWindow *control);
-
-  /// Set selections as newline-separated strings
-  void setSelections(const FXString& strings);
-
-  /// Return selections
-  const FXString& getSelections() const { return selections; }
-  };
-
-
-/// Table Widget
-class FXAPI FXTable : public FXScrollArea {
-  FXDECLARE(FXTable)
-protected:
-  FXHeader     *colHeader;              // Column header
-  FXHeader     *rowHeader;              // Row header
-  FXButton     *cornerButton;           // Corner button
-  FXTableItem **cells;                  // Cells
-  FXWindow     *editor;                 // Editor widget
-  FXFont       *font;                   // Font
-  FXint         nrows;                  // Number of rows
-  FXint         ncols;                  // Number of columns
-  FXint         visiblerows;            // Visible rows
-  FXint         visiblecols;            // Visible columns
-  FXint         margintop;              // Margin top
-  FXint         marginbottom;           // Margin bottom
-  FXint         marginleft;             // Margin left
-  FXint         marginright;            // Margin right
-  FXColor       textColor;              // Normal text color
-  FXColor       baseColor;              // Base color
-  FXColor       hiliteColor;            // Highlight color
-  FXColor       shadowColor;            // Shadow color
-  FXColor       borderColor;            // Border color
-  FXColor       selbackColor;           // Select background color
-  FXColor       seltextColor;           // Select text color
-  FXColor       gridColor;              // Grid line color
-  FXColor       stippleColor;           // Stipple color
-  FXColor       cellBorderColor;        // Cell border color
-  FXint         cellBorderWidth;        // Cell border width
-  FXColor       cellBackColor[2][2];    // Row/Column even/odd background color
-  FXint         defColWidth;            // Default column width [if uniform columns]
-  FXint         defRowHeight;           // Default row height [if uniform rows]
-  FXTablePos    current;                // Current position
-  FXTablePos    anchor;                 // Anchor position
-  FXTableRange  input;                  // Input cell
-  FXTableRange  selection;              // Range of selected cells
-  FXString      clipped;                // Clipped text
-  FXbool        hgrid;                  // Horizontal grid lines shown
-  FXbool        vgrid;                  // Vertical grid lines shown
-  FXuchar       mode;                   // Mode widget is in
-  FXint         grabx;                  // Grab point x
-  FXint         graby;                  // Grab point y
-  FXint         rowcol;                 // Row or column being resized
-  FXString      help;
-public:
-  static FXDragType csvType;
-  static const FXchar csvTypeName[];
-protected:
-  FXTable();
-  FXint startRow(FXint row,FXint col) const;
-  FXint startCol(FXint row,FXint col) const;
-  FXint endRow(FXint row,FXint col) const;
-  FXint endCol(FXint row,FXint col) const;
-  void spanningRange(FXint& sr,FXint& er,FXint& sc,FXint& ec,FXint anchrow,FXint anchcol,FXint currow,FXint curcol);
-  virtual void moveContents(FXint x,FXint y);
-  virtual void drawCell(FXDC& dc,FXint sr,FXint er,FXint sc,FXint ec);
-  virtual void drawRange(FXDC& dc,FXint rlo,FXint rhi,FXint clo,FXint chi);
-  virtual void drawHGrid(FXDC& dc,FXint rlo,FXint rhi,FXint clo,FXint chi);
-  virtual void drawVGrid(FXDC& dc,FXint rlo,FXint rhi,FXint clo,FXint chi);
-  virtual void drawContents(FXDC& dc,FXint x,FXint y,FXint w,FXint h);
-  virtual FXTableItem* createItem(const FXString& text,FXIcon* icon,void* ptr);
-  virtual FXWindow *getControlForItem(FXint r,FXint c);
-  virtual void setItemFromControl(FXint r,FXint c,FXWindow *control);
-  virtual void updateColumnNumbers(FXint lo,FXint hi);
-  virtual void updateRowNumbers(FXint lo,FXint hi);
-protected:
-  enum {
-    MOUSE_NONE,
-    MOUSE_SCROLL,
-    MOUSE_DRAG,
-    MOUSE_SELECT
-    };
-private:
-  FXTable(const FXTable&);
-  FXTable& operator=(const FXTable&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onFocusIn(FXObject*,FXSelector,void*);
-  long onFocusOut(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onRightBtnPress(FXObject*,FXSelector,void*);
-  long onRightBtnRelease(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onSelectionLost(FXObject*,FXSelector,void*);
-  long onSelectionGained(FXObject*,FXSelector,void*);
-  long onSelectionRequest(FXObject*,FXSelector,void* ptr);
-  long onClipboardLost(FXObject*,FXSelector,void*);
-  long onClipboardGained(FXObject*,FXSelector,void*);
-  long onClipboardRequest(FXObject*,FXSelector,void*);
-  long onAutoScroll(FXObject*,FXSelector,void*);
-  long onCommand(FXObject*,FXSelector,void*);
-  long onClicked(FXObject*,FXSelector,void*);
-  long onDoubleClicked(FXObject*,FXSelector,void*);
-  long onTripleClicked(FXObject*,FXSelector,void*);
-
-  long onCmdToggleEditable(FXObject*,FXSelector,void*);
-  long onUpdToggleEditable(FXObject*,FXSelector,void*);
-
-  // Visual characteristics
-  long onCmdHorzGrid(FXObject*,FXSelector,void*);
-  long onUpdHorzGrid(FXObject*,FXSelector,void*);
-  long onCmdVertGrid(FXObject*,FXSelector,void*);
-  long onUpdVertGrid(FXObject*,FXSelector,void*);
-
-  // Row/Column manipulations
-  long onCmdDeleteColumn(FXObject*,FXSelector,void*);
-  long onUpdDeleteColumn(FXObject*,FXSelector,void*);
-  long onCmdDeleteRow(FXObject*,FXSelector,void*);
-  long onUpdDeleteRow(FXObject*,FXSelector,void*);
-  long onCmdInsertColumn(FXObject*,FXSelector,void*);
-  long onUpdInsertColumn(FXObject*,FXSelector,void*);
-  long onCmdInsertRow(FXObject*,FXSelector,void*);
-  long onUpdInsertRow(FXObject*,FXSelector,void*);
-
-  // Movement
-  long onCmdMoveRight(FXObject*,FXSelector,void*);
-  long onCmdMoveLeft(FXObject*,FXSelector,void*);
-  long onCmdMoveUp(FXObject*,FXSelector,void*);
-  long onCmdMoveDown(FXObject*,FXSelector,void*);
-  long onCmdMoveHome(FXObject*,FXSelector,void*);
-  long onCmdMoveEnd(FXObject*,FXSelector,void*);
-  long onCmdMoveTop(FXObject*,FXSelector,void*);
-  long onCmdMoveBottom(FXObject*,FXSelector,void*);
-  long onCmdMovePageDown(FXObject*,FXSelector,void*);
-  long onCmdMovePageUp(FXObject*,FXSelector,void*);
-
-  // Mark and extend
-  long onCmdMark(FXObject*,FXSelector,void*);
-  long onCmdExtend(FXObject*,FXSelector,void*);
-
-  // Changing Selection
-  long onUpdSelectCell(FXObject*,FXSelector,void*);
-  long onCmdSelectCell(FXObject*,FXSelector,void*);
-  long onUpdSelectRow(FXObject*,FXSelector,void*);
-  long onCmdSelectRow(FXObject*,FXSelector,void*);
-  long onUpdSelectColumn(FXObject*,FXSelector,void*);
-  long onCmdSelectColumn(FXObject*,FXSelector,void*);
-  long onCmdSelectRowIndex(FXObject*,FXSelector,void*);
-  long onCmdSelectColumnIndex(FXObject*,FXSelector,void*);
-  long onUpdSelectAll(FXObject*,FXSelector,void*);
-  long onCmdSelectAll(FXObject*,FXSelector,void*);
-  long onUpdDeselectAll(FXObject*,FXSelector,void*);
-  long onCmdDeselectAll(FXObject*,FXSelector,void*);
-
-  // Manipulation Selection
-  long onCmdCutSel(FXObject*,FXSelector,void*);
-  long onCmdCopySel(FXObject*,FXSelector,void*);
-  long onCmdDeleteSel(FXObject*,FXSelector,void*);
-  long onCmdPasteSel(FXObject*,FXSelector,void*);
-  long onUpdHaveSelection(FXObject*,FXSelector,void*);
-
-  // Edit control
-  long onCmdStartInput(FXObject*,FXSelector,void*);
-  long onUpdStartInput(FXObject*,FXSelector,void*);
-  long onCmdAcceptInput(FXObject*,FXSelector,void*);
-  long onUpdAcceptInput(FXObject*,FXSelector,void*);
-  long onCmdCancelInput(FXObject*,FXSelector,void*);
-public:
-
-  enum {
-    ID_HORZ_GRID=FXScrollArea::ID_LAST,
-    ID_VERT_GRID,
-    ID_TOGGLE_EDITABLE,
-    ID_DELETE_COLUMN,
-    ID_DELETE_ROW,
-    ID_INSERT_COLUMN,
-    ID_INSERT_ROW,
-    ID_SELECT_COLUMN_INDEX,
-    ID_SELECT_ROW_INDEX,
-    ID_SELECT_COLUMN,
-    ID_SELECT_ROW,
-    ID_SELECT_CELL,
-    ID_SELECT_ALL,
-    ID_DESELECT_ALL,
-    ID_MOVE_LEFT,
-    ID_MOVE_RIGHT,
-    ID_MOVE_UP,
-    ID_MOVE_DOWN,
-    ID_MOVE_HOME,
-    ID_MOVE_END,
-    ID_MOVE_TOP,
-    ID_MOVE_BOTTOM,
-    ID_MOVE_PAGEDOWN,
-    ID_MOVE_PAGEUP,
-    ID_START_INPUT,
-    ID_CANCEL_INPUT,
-    ID_ACCEPT_INPUT,
-    ID_MARK,
-    ID_EXTEND,
-    ID_CUT_SEL,
-    ID_COPY_SEL,
-    ID_PASTE_SEL,
-    ID_DELETE_SEL,
-    ID_LAST
-    };
-
-public:
-
-  /**
-  * Construct a new table.
-  * The table is initially empty, and reports a default size based on
-  * the scroll areas's scrollbar placement policy.
-  */
-  FXTable(FXComposite *p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_MARGIN,FXint pr=DEFAULT_MARGIN,FXint pt=DEFAULT_MARGIN,FXint pb=DEFAULT_MARGIN);
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Computes content width
-  virtual FXint getContentWidth();
-
-  /// Computes content height
-  virtual FXint getContentHeight();
-
-  /// Create the server-side resources
-  virtual void create();
-
-  /// Detach the server-side resources
-  virtual void detach();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Mark this window's layout as dirty
-  virtual void recalc();
-
-  /// Table widget can receive focus
-  virtual bool canFocus() const;
-
-  /// Move the focus to this window
-  virtual void setFocus();
-
-  /// Remove the focus from this window
-  virtual void killFocus();
-
-  /// Notification that focus moved to new child
-  virtual void changeFocus(FXWindow *child);
-
-  /// Return button in the top/left corner
-  FXButton* getCornerButton() const { return cornerButton; }
-
-  /// Return column header control
-  FXHeader* getColumnHeader() const { return colHeader; }
-
-  /// Return row header control
-  FXHeader* getRowHeader() const { return rowHeader; }
-
-  /// Change visible rows
-  void setVisibleRows(FXint nvrows);
-
-  /// return number of visible rows
-  FXint getVisibleRows() const { return visiblerows; }
-
-  /// Change visible columns
-  void setVisibleColumns(FXint nvcols);
-
-  /// Return number of visible columns
-  FXint getVisibleColumns() const { return visiblecols; }
-
-  /// Return TRUE if table is editable
-  FXbool isEditable() const;
-
-  /// Set editable flag
-  void setEditable(FXbool edit=TRUE);
-
-  /// Show or hide horizontal grid
-  void showHorzGrid(FXbool on=TRUE);
-
-  /// Is horizontal grid shown
-  FXbool isHorzGridShown() const { return hgrid; }
-
-  /// Show or hide vertical grid
-  void showVertGrid(FXbool on=TRUE);
-
-  /// Is vertical grid shown
-  FXbool isVertGridShown() const { return vgrid; }
-
-  /// Get number of rows
-  FXint getNumRows() const { return nrows; }
-
-  /// Get number of columns
-  FXint getNumColumns() const { return ncols; }
-
-  /// Change top cell margin
-  void setMarginTop(FXint pt);
-
-  /// Return top cell margin
-  FXint getMarginTop() const { return margintop; }
-
-  /// Change bottom cell margin
-  void setMarginBottom(FXint pb);
-
-  /// Return bottom cell margin
-  FXint getMarginBottom() const { return marginbottom; }
-
-  /// Change left cell margin
-  void setMarginLeft(FXint pl);
-
-  /// Return left cell margin
-  FXint getMarginLeft() const { return marginleft; }
-
-  /// Change right cell margin
-  void setMarginRight(FXint pr);
-
-  /// Return right cell margin
-  FXint getMarginRight() const { return marginright; }
-
-  /**
-  * Start input mode for the cell at the given position.
-  * An input control is created which is used to edit the cell;
-  * it is filled by the original item's contents if the cell contained
-  * an item.  You can enter input mode also by sending the table an
-  * ID_START_INPUT message.
-  */
-  virtual void startInput(FXint row,FXint col);
-
-  /**
-  * Cancel input mode.  The input control is immediately deleted
-  * and the cell will retain its old value.  You can also cancel
-  * input mode by sending the table an ID_CANCEL_INPUT message.
-  */
-  virtual void cancelInput();
-
-  /**
-  * End input mode and accept the new value from the control.
-  * The item in the cell will be set to the value from the control,
-  * and the control will be deleted.  If TRUE is passed, a SEL_REPLACED
-  * callback will be generated to signify to the target that this call
-  * has a new value.  You can also accept the input by sending the table
-  * an ID_ACCEPT_INPUT message.
-  */
-  virtual void acceptInput(FXbool notify=FALSE);
-
-  /**
-  * Determine column containing x.
-  * Returns -1 if x left of first column, and ncols if x right of last column;
-  * otherwise, returns column in table containing x.
-  */
-  FXint colAtX(FXint x) const;
-
-  /**
-  * Determine row containing y.
-  * Returns -1 if y above first row, and nrows if y below last row;
-  * otherwise, returns row in table containing y.
-  */
-  FXint rowAtY(FXint y) const;
-
-  /// Return the item at the given index
-  FXTableItem *getItem(FXint row,FXint col) const;
-
-  /// Replace the item with a [possibly subclassed] item
-  void setItem(FXint row,FXint col,FXTableItem* item,FXbool notify=FALSE);
-
-  /// Set the table size to nr rows and nc columns; all existing items will be removed
-  virtual void setTableSize(FXint nr,FXint nc,FXbool notify=FALSE);
-
-  /// Insert new row
-  virtual void insertRows(FXint row,FXint nr=1,FXbool notify=FALSE);
-
-  /// Insert new column
-  virtual void insertColumns(FXint col,FXint nc=1,FXbool notify=FALSE);
-
-  /// Remove rows of cells
-  virtual void removeRows(FXint row,FXint nr=1,FXbool notify=FALSE);
-
-  /// Remove column of cells
-  virtual void removeColumns(FXint col,FXint nc=1,FXbool notify=FALSE);
-
-  /// Extract item from table
-  virtual FXTableItem* extractItem(FXint row,FXint col,FXbool notify=FALSE);
-
-  /// Clear single cell
-  virtual void removeItem(FXint row,FXint col,FXbool notify=FALSE);
-
-  /// Clear all cells in the given range
-  virtual void removeRange(FXint startrow,FXint endrow,FXint startcol,FXint endcol,FXbool notify=FALSE);
-
-  /// Remove all items from table
-  virtual void clearItems(FXbool notify=FALSE);
-
-  /// Scroll to make cell at r,c fully visible
-  virtual void makePositionVisible(FXint r,FXint c);
-
-  /// Return TRUE if item partially visible
-  FXbool isItemVisible(FXint r,FXint c) const;
-
-  /**
-  * Change column header height mode to fixed or variable.
-  * In variable height mode, the column header will size to
-  * fit the contents in it.  In fixed mode, the size is
-  * explicitly set using setColumnHeaderHeight().
-  */
-  void setColumnHeaderMode(FXuint hint=LAYOUT_FIX_HEIGHT);
-
-  /// Return column header height mode
-  FXuint getColumnHeaderMode() const;
-
-  /**
-  * Change row header width mode to fixed or variable.
-  * In variable width mode, the row header will size to
-  * fit the contents in it.  In fixed mode, the size is
-  * explicitly set using setRowHeaderWidth().
-  */
-  void setRowHeaderMode(FXuint hint=LAYOUT_FIX_WIDTH);
-
-  /// Return row header width mode
-  FXuint getRowHeaderMode() const;
-
-  /// Set column header font
-  void setColumnHeaderFont(FXFont* fnt);
-
-  /// Return column header font
-  FXFont* getColumnHeaderFont() const;
-
-  /// Set row header font
-  void setRowHeaderFont(FXFont* fnt);
-
-  /// Return row header font
-  FXFont* getRowHeaderFont() const;
-
-  /// Change column header height
-  void setColumnHeaderHeight(FXint h);
-
-  /// Return column header height
-  FXint getColumnHeaderHeight() const;
-
-  /// Change row header width
-  void setRowHeaderWidth(FXint w);
-
-  /// Return row header width
-  FXint getRowHeaderWidth() const;
-
-  /// Get X coordinate of column
-  FXint getColumnX(FXint col) const;
-
-  /// Get Y coordinate of row
-  FXint getRowY(FXint row) const;
-
-  /// Change column width
-  virtual void setColumnWidth(FXint col,FXint cwidth);
-
-  /// Get column width
-  FXint getColumnWidth(FXint col) const;
-
-  /// Change row height
-  virtual void setRowHeight(FXint row,FXint rheight);
-
-  /// Get row height
-  FXint getRowHeight(FXint row) const;
-
-  /// Change default column width
-  void setDefColumnWidth(FXint cwidth);
-
-  /// Get default column width
-  FXint getDefColumnWidth() const { return defColWidth; }
-
-  /// Change default row height
-  void setDefRowHeight(FXint rheight);
-
-  /// Get default row height
-  FXint getDefRowHeight() const { return defRowHeight; }
-
-  /// Return minimum row height
-  FXint getMinRowHeight(FXint r) const;
-
-  /// Return minimum column width
-  FXint getMinColumnWidth(FXint c) const;
-
-  /// Fit row heights to contents
-  void fitRowsToContents(FXint row,FXint nr=1);
-
-  /// Fit column widths to contents
-  void fitColumnsToContents(FXint col,FXint nc=1);
-
-  /// Change column header text
-  void setColumnText(FXint index,const FXString& text);
-
-  /// Return text of column header at index
-  FXString getColumnText(FXint index) const;
-
-  /// Change row header text
-  void setRowText(FXint index,const FXString& text);
-
-  /// Return text of row header at index
-  FXString getRowText(FXint index) const;
-
-  /// Change column header icon
-  void setColumnIcon(FXint index,FXIcon* icon);
-
-  /// Return icon of column header at index
-  FXIcon* getColumnIcon(FXint index) const;
-
-  /// Change row header icon
-  void setRowIcon(FXint index,FXIcon* icon);
-
-  /// Return icon of row header at index
-  FXIcon* getRowIcon(FXint index) const;
-
-  /// Change column header icon position, e.g. FXHeaderItem::BEFORE, etc.
-  void setColumnIconPosition(FXint index,FXuint mode);
-
-  /// Return icon position of column header at index
-  FXuint getColumnIconPosition(FXint index) const;
-
-  /// Change row header icon position, e.g. FXHeaderItem::BEFORE, etc.
-  void setRowIconPosition(FXint index,FXuint mode);
-
-  /// Return icon position of row header at index
-  FXuint getRowIconPosition(FXint index) const;
-
-  /// Change column header justify, e.g. FXHeaderItem::RIGHT, etc.
-  void setColumnJustify(FXint index,FXuint justify);
-
-  /// Return justify of column header at index
-  FXuint getColumnJustify(FXint index) const;
-
-  /// Change row header justify, e.g. FXHeaderItem::RIGHT, etc.
-  void setRowJustify(FXint index,FXuint justify);
-
-  /// Return justify of row header at index
-  FXuint getRowJustify(FXint index) const;
-
-  /// Modify cell text
-  void setItemText(FXint r,FXint c,const FXString& text,FXbool notify=FALSE);
-
-  /// Return cell text
-  FXString getItemText(FXint r,FXint c) const;
-
-  /// Modify cell icon, deleting the old icon if it was owned
-  void setItemIcon(FXint r,FXint c,FXIcon* icon,FXbool owned=FALSE,FXbool notify=FALSE);
-
-  /// Return cell icon
-  FXIcon* getItemIcon(FXint r,FXint c) const;
-
-  /// Modify cell user-data
-  void setItemData(FXint r,FXint c,void* ptr);
-  void* getItemData(FXint r,FXint c) const;
-
-  /**
-  * Extract cells from given range as text, each column separated by a string cs,
-  * and each row separated by a string rs.
-  */
-  void extractText(FXchar*& text,FXint& size,FXint startrow,FXint endrow,FXint startcol,FXint endcol,const FXchar* cs="\t",const FXchar* rs="\n") const;
-  void extractText(FXString& text,FXint startrow,FXint endrow,FXint startcol,FXint endcol,const FXchar* cs="\t",const FXchar* rs="\n") const;
-
-  /**
-  * Overlay text over given cell range; the text is interpreted as
-  * a number of columns separated by a character from the set cs, and
-  * a number of rows separated by a character from the set rs.
-  * Cells outside the given cell range are unaffected.
-  */
-  void overlayText(FXint startrow,FXint endrow,FXint startcol,FXint endcol,const FXchar* text,FXint size,const FXchar* cs="\t,",const FXchar* rs="\n",FXbool notify=FALSE);
-  void overlayText(FXint startrow,FXint endrow,FXint startcol,FXint endcol,const FXString& text,const FXchar* cs="\t,",const FXchar* rs="\n",FXbool notify=FALSE);
-
-  /**
-  * Determine the number of rows and columns in a block of text
-  * where columns are separated by characters from the set cs, and rows
-  * are separated by characters from the set rs.
-  */
-  void countText(FXint& nr,FXint& nc,const FXchar* text,FXint size,const FXchar* cs="\t,",const FXchar* rs="\n") const;
-  void countText(FXint& nr,FXint& nc,const FXString& text,const FXchar* cs="\t,",const FXchar* rs="\n") const;
-
-  /// Return TRUE if its a spanning cell
-  FXbool isItemSpanning(FXint r,FXint c) const;
-
-  /// Repaint cells between grid lines sr,er and grid lines sc,ec
-  void updateRange(FXint sr,FXint er,FXint sc,FXint ec) const;
-
-  /// Repaint cell at r,c
-  void updateItem(FXint r,FXint c) const;
-
-  /// Enable item
-  virtual FXbool enableItem(FXint r,FXint c);
-
-  /// Disable item
-  virtual FXbool disableItem(FXint r,FXint c);
-
-  /// Is item enabled
-  FXbool isItemEnabled(FXint r,FXint c) const;
-
-  /**
-  * Change item justification.  Horizontal justification is controlled by passing
-  * FXTableItem::RIGHT,  FXTableItem::LEFT, or FXTableItem::CENTER_X.
-  * Vertical justification is controlled by FXTableItem::TOP, FXTableItem::BOTTOM,
-  * or FXTableItem::CENTER_Y.
-  * The default is a combination of FXTableItem::RIGHT and FXTableItem::CENTER_Y.
-  */
-  void setItemJustify(FXint r,FXint c,FXuint justify);
-
-  /// Return item justification
-  FXuint getItemJustify(FXint r,FXint c) const;
-
-  /**
-  * Change relative position of icon and text of item.
-  * Passing FXTableItem::BEFORE or FXTableItem::AFTER places the icon
-  * before or after the text, and passing FXTableItem::ABOVE or
-  * FXTableItem::BELOW places it above or below the text, respectively.
-  * The default is 0 which places the text on top of the icon.
-  */
-  void setItemIconPosition(FXint r,FXint c,FXuint mode);
-
-  /// Return relative icon and text position
-  FXuint getItemIconPosition(FXint r,FXint c) const;
-
-  /**
-  * Change item borders style.  Borders on each side of the item can be turned
-  * controlled individually using FXTableItem::LBORDER, FXTableItem::RBORDER,
-  * FXTableItem::TBORDER and FXTableItem::BBORDER.
-  */
-  void setItemBorders(FXint r,FXint c,FXuint borders);
-
-  /// Return item border style
-  FXuint getItemBorders(FXint r,FXint c) const;
-
-  /// Change item background stipple style
-  void setItemStipple(FXint r,FXint c,FXStipplePattern pat);
-
-  /// return item background stipple style
-  FXStipplePattern getItemStipple(FXint r,FXint c) const;
-
-  /// Change current item
-  virtual void setCurrentItem(FXint r,FXint c,FXbool notify=FALSE);
-
-  /// Get row number of current item
-  FXint getCurrentRow() const { return current.row; }
-
-  /// Get column number of current item
-  FXint getCurrentColumn() const { return current.col; }
-
-  /// Is item current
-  FXbool isItemCurrent(FXint r,FXint c) const;
-
-  /// Change anchor item
-  void setAnchorItem(FXint r,FXint c);
-
-  /// Get row number of anchor item
-  FXint getAnchorRow() const { return anchor.row; }
-
-  /// Get column number of anchor item
-  FXint getAnchorColumn() const { return anchor.col; }
-
-  /// Get selection start row; returns -1 if no selection
-  FXint getSelStartRow() const { return selection.fm.row; }
-
-  /// Get selection start column; returns -1 if no selection
-  FXint getSelStartColumn() const { return selection.fm.col; }
-
-  /// Get selection end row; returns -1 if no selection
-  FXint getSelEndRow() const { return selection.to.row; }
-
-  /// Get selection end column; returns -1 if no selection
-  FXint getSelEndColumn() const { return selection.to.col; }
-
-  /// Is cell selected
-  FXbool isItemSelected(FXint r,FXint c) const;
-
-  /// Is row of cells selected
-  FXbool isRowSelected(FXint r) const;
-
-  /// Is column selected
-  FXbool isColumnSelected(FXint c) const;
-
-  /// Is anything selected
-  FXbool isAnythingSelected() const;
-
-  /// Select a row
-  virtual FXbool selectRow(FXint row,FXbool notify=FALSE);
-
-  /// Select a column
-  virtual FXbool selectColumn(FXint col,FXbool notify=FALSE);
-
-  /// Select range
-  virtual FXbool selectRange(FXint startrow,FXint endrow,FXint startcol,FXint endcol,FXbool notify=FALSE);
-
-  /// Extend selection
-  virtual FXbool extendSelection(FXint r,FXint c,FXbool notify=FALSE);
-
-  /// Kill selection
-  virtual FXbool killSelection(FXbool notify=FALSE);
-
-  /// Change font
-  void setFont(FXFont* fnt);
-
-  /// Return current font
-  FXFont* getFont() const { return font; }
-
-  /// Obtain colors of various parts
-  FXColor getTextColor() const { return textColor; }
-  FXColor getBaseColor() const { return baseColor; }
-  FXColor getHiliteColor() const { return hiliteColor; }
-  FXColor getShadowColor() const { return shadowColor; }
-  FXColor getBorderColor() const { return borderColor; }
-  FXColor getSelBackColor() const { return selbackColor; }
-  FXColor getSelTextColor() const { return seltextColor; }
-  FXColor getGridColor() const { return gridColor; }
-  FXColor getStippleColor() const { return stippleColor; }
-  FXColor getCellBorderColor() const { return cellBorderColor; }
-
-  /// Change colors of various parts
-  void setTextColor(FXColor clr);
-  void setBaseColor(FXColor clr);
-  void setHiliteColor(FXColor clr);
-  void setShadowColor(FXColor clr);
-  void setBorderColor(FXColor clr);
-  void setSelBackColor(FXColor clr);
-  void setSelTextColor(FXColor clr);
-  void setGridColor(FXColor clr);
-  void setStippleColor(FXColor clr);
-  void setCellBorderColor(FXColor clr);
-
-  /// Change cell background color for even/odd rows/columns
-  void setCellColor(FXint r,FXint c,FXColor clr);
-
-  /// Obtain cell background color for even/odd rows/columns
-  FXColor getCellColor(FXint r,FXint c) const;
-
-  /// Change cell border width
-  void setCellBorderWidth(FXint borderwidth);
-
-  /// Return cell border width
-  FXint getCellBorderWidth() const { return cellBorderWidth; }
-
-  /// Change table style
-  void setTableStyle(FXuint style);
-
-  /// Return table style
-  FXuint getTableStyle() const;
-
-  /// Set column renumbering
-  void setColumnRenumbering(FXbool flag);
-
-  /// Get column renumbering
-  FXbool getColumnRenumbering() const;
-
-  /// Set row renumbering
-  void setRowRenumbering(FXbool flag);
-
-  /// Get row renumbering
-  FXbool getRowRenumbering() const;
-
-  /// Change help text
-  void setHelpText(const FXString& text){ help=text; }
-  const FXString& getHelpText() const { return help; }
-
-  /// Serialize
-  virtual void save(FXStream& store) const;
-  virtual void load(FXStream& store);
-
-  virtual ~FXTable();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXText.h b/fox-includes/FXText.h
deleted file mode 100755
index 213cde4e..00000000
--- a/fox-includes/FXText.h
+++ /dev/null
@@ -1,883 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                    M u l t i - L i ne   T e x t   W i d g e t                 *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXText.h 2346 2006-02-14 03:26:11Z lyle $                           *
-********************************************************************************/
-#ifndef FXTEXT_H
-#define FXTEXT_H
-
-#ifndef FXSCROLLAREA_H
-#include "FXScrollArea.h"
-#endif
-
-namespace FX {
-
-
-/// Text widget options
-enum {
-  TEXT_READONLY      = 0x00100000,      /// Text is NOT editable
-  TEXT_WORDWRAP      = 0x00200000,      /// Wrap at word breaks
-  TEXT_OVERSTRIKE    = 0x00400000,      /// Overstrike mode
-  TEXT_FIXEDWRAP     = 0x00800000,      /// Fixed wrap columns
-  TEXT_NO_TABS       = 0x01000000,      /// Insert spaces for tabs
-  TEXT_AUTOINDENT    = 0x02000000,      /// Autoindent
-  TEXT_SHOWACTIVE    = 0x04000000,      /// Show active line
-  TEXT_AUTOSCROLL    = 0x08000000       /// Logging mode, keeping last line visible
-  };
-
-
-/// Selection modes
-enum FXTextSelectionMode {
-  SELECT_CHARS,
-  SELECT_WORDS,
-  SELECT_LINES
-  };
-
-
-/// Highlight style entry
-struct FXHiliteStyle {
-  FXColor normalForeColor;            /// Normal text foreground color
-  FXColor normalBackColor;            /// Normal text background color
-  FXColor selectForeColor;            /// Selected text foreground color
-  FXColor selectBackColor;            /// Selected text background color
-  FXColor hiliteForeColor;            /// Highlight text foreground color
-  FXColor hiliteBackColor;            /// Highlight text background color
-  FXColor activeBackColor;            /// Active text background color
-  FXuint  style;                      /// Highlight text style
-  };
-
-
-/**
-* Text mutation callback data passed with the SEL_INSERTED,
-* SEL_REPLACED, and SEL_DELETED messages; both old and new
-* text is available on behalf of the undo system as well as
-* syntax highlighting.
-*/
-struct FXTextChange {
-  FXint   pos;          /// Position in buffer
-  FXint   ndel;         /// Number characters deleted at position
-  FXint   nins;         /// Number characters inserted at position
-  FXchar *ins;          /// Text inserted at position
-  FXchar *del;          /// Text deleted at position
-  };
-
-
-/**
-* The text widget supports editing of multiple lines of text.
-* An optional style table can provide text coloring based on
-* the contents of an optional parallel style buffer, which is
-* maintained as text is edited.  In a typical scenario, the
-* contents of the style buffer is either directly written when
-* the text is added to the widget, or is continually modified
-* by editing the text via syntax-based highlighting engine which
-* colors the text based on syntactical patterns.
-*/
-class FXAPI FXText : public FXScrollArea {
-  FXDECLARE(FXText)
-protected:
-  FXchar        *buffer;              // Text buffer being edited
-  FXchar        *sbuffer;             // Text style buffer
-  FXint         *visrows;             // Starts of rows in buffer
-  FXint          length;              // Length of the actual text in the buffer
-  FXint          nvisrows;            // Number of visible rows
-  FXint          nrows;               // Total number of rows
-  FXint          gapstart;            // Start of the insertion point (the gap)
-  FXint          gapend;              // End of the insertion point+1
-  FXint          toppos;              // Start position of first visible row
-  FXint          keeppos;             // Position to keep on top visible row
-  FXint          toprow;              // Row number of first visible row
-  FXint          selstartpos;         // Start of selection
-  FXint          selendpos;           // End of selection
-  FXint          hilitestartpos;      // Hightlight start position
-  FXint          hiliteendpos;        // Hightlight end position
-  FXint          anchorpos;           // Anchor position
-  FXint          cursorpos;           // Cursor position
-  FXint          revertpos;           // Position of cursor prior to dragging
-  FXint          cursorstart;         // Cursor row start pos
-  FXint          cursorend;           // Cursor row end pos
-  FXint          cursorrow;           // Cursor row
-  FXint          cursorcol;           // Cursor column indent (not character offset!)
-  FXint          prefcol;             // Preferred cursor column
-  FXint          margintop;           // Margins top
-  FXint          marginbottom;        // Margin bottom
-  FXint          marginleft;          // Margin left
-  FXint          marginright;         // Margin right
-  FXint          wrapwidth;           // Wrap width in pixels
-  FXint          wrapcolumns;         // Wrap columns
-  FXint          tabwidth;            // Tab width in pixels
-  FXint          tabcolumns;          // Tab columns
-  FXint          barwidth;            // Line number width
-  FXint          barcolumns;          // Line number columns
-  FXFont        *font;                // Text font
-  FXColor        textColor;           // Normal text color
-  FXColor        selbackColor;        // Select background color
-  FXColor        seltextColor;        // Select text color
-  FXColor        hilitebackColor;     // Highlight background color
-  FXColor        hilitetextColor;     // Highlight text color
-  FXColor        activebackColor;     // Background color for active line
-  FXColor        numberColor;         // Line number color
-  FXColor        cursorColor;         // Cursor color
-  FXColor        barColor;            // Bar background color
-  FXint          textWidth;           // Total width of all text
-  FXint          textHeight;          // Total height of all text
-  FXString       searchstring;        // String of last search
-  FXuint         searchflags;         // Flags of last search
-  const FXchar  *delimiters;          // Delimiters
-  FXString       clipped;             // Clipped text
-  FXint          vrows;               // Default visible rows
-  FXint          vcols;               // Default visible columns
-  FXString       help;                // Status line help
-  FXString       tip;                 // Tooltip
-  const FXHiliteStyle *hilitestyles;  // Style definitions
-  FXuint         matchtime;           // Match time (ms)
-  FXint          grabx;               // Grab point x
-  FXint          graby;               // Grab point y
-  FXuchar        mode;                // Mode widget is in
-  FXbool         modified;            // User has modified text
-protected:
-  FXText();
-  void calcVisRows(FXint s,FXint e);
-  virtual void eraseCursorOverhang();
-  virtual void drawCursor(FXuint state);
-  virtual FXuint style(FXint row,FXint beg,FXint end,FXint pos) const;
-  virtual void drawBufferText(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h,FXint pos,FXint n,FXuint style) const;
-  virtual void fillBufferRect(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h,FXuint style) const;
-  virtual void drawTextRow(FXDCWindow& dc,FXint line,FXint left,FXint right) const;
-  virtual void drawContents(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h) const;
-  virtual void drawNumbers(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h) const;
-  FXint posToLine(FXint pos,FXint ln) const;
-  FXbool posVisible(FXint pos) const;
-  void updateRange(FXint beg,FXint end) const;
-  void movegap(FXint pos);
-  void sizegap(FXint sz);
-  void squeezegap();
-  FXint charWidth(FXwchar ch,FXint indent) const;
-  FXint wrap(FXint start) const;
-  FXint measureText(FXint start,FXint end,FXint& wmax,FXint& hmax) const;
-  FXint lineWidth(FXint pos,FXint n) const;
-  FXint getYOfPos(FXint pos) const;
-  FXint getXOfPos(FXint pos) const;
-  FXint changeBeg(FXint pos) const;
-  FXint changeEnd(FXint pos) const;
-  FXint indentFromPos(FXint start,FXint pos) const;
-  FXint posFromIndent(FXint start,FXint indent) const;
-  void mutation(FXint pos,FXint ncins,FXint ncdel,FXint nrins,FXint nrdel);
-  virtual void replace(FXint pos,FXint m,const FXchar *text,FXint n,FXint style);
-  void recompute();
-  FXint matchForward(FXint pos,FXint end,FXwchar l,FXwchar r,FXint level) const;
-  FXint matchBackward(FXint pos,FXint beg,FXwchar l,FXwchar r,FXint level) const;
-  FXint findMatching(FXint pos,FXint beg,FXint end,FXwchar ch,FXint level) const;
-  void flashMatching();
-  void moveContents(FXint x,FXint y);
-protected:
-  enum {
-    STYLE_MASK      = 0x00FF,   // Mask color table
-    STYLE_TEXT      = 0x0100,   // Draw some content
-    STYLE_SELECTED  = 0x0200,   // Selected
-    STYLE_CONTROL   = 0x0400,   // Control character
-    STYLE_HILITE    = 0x0800,   // Highlighted
-    STYLE_ACTIVE    = 0x1000    // Active
-    };
-  enum {
-    MOUSE_NONE,                 // No mouse operation
-    MOUSE_CHARS,                // Selecting characters
-    MOUSE_WORDS,                // Selecting words
-    MOUSE_LINES,                // Selecting lines
-    MOUSE_SCROLL,               // Scrolling
-    MOUSE_DRAG,                 // Dragging text
-    MOUSE_TRYDRAG               // Tentative drag
-    };
-public:
-  enum {
-    STYLE_UNDERLINE = 0x0001,   /// Underline text
-    STYLE_STRIKEOUT = 0x0002,   /// Strike out text
-    STYLE_BOLD      = 0x0004    /// Bold text
-    };
-private:
-  FXText(const FXText&);
-  FXText& operator=(const FXText&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onFocusIn(FXObject*,FXSelector,void*);
-  long onFocusOut(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onMiddleBtnPress(FXObject*,FXSelector,void*);
-  long onMiddleBtnRelease(FXObject*,FXSelector,void*);
-  long onRightBtnPress(FXObject*,FXSelector,void*);
-  long onRightBtnRelease(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onBeginDrag(FXObject*,FXSelector,void*);
-  long onEndDrag(FXObject*,FXSelector,void*);
-  long onDragged(FXObject*,FXSelector,void*);
-  long onDNDEnter(FXObject*,FXSelector,void*);
-  long onDNDLeave(FXObject*,FXSelector,void*);
-  long onDNDMotion(FXObject*,FXSelector,void*);
-  long onDNDDrop(FXObject*,FXSelector,void*);
-  long onDNDRequest(FXObject*,FXSelector,void*);
-  long onSelectionLost(FXObject*,FXSelector,void*);
-  long onSelectionGained(FXObject*,FXSelector,void*);
-  long onSelectionRequest(FXObject*,FXSelector,void* ptr);
-  long onClipboardLost(FXObject*,FXSelector,void*);
-  long onClipboardGained(FXObject*,FXSelector,void*);
-  long onClipboardRequest(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onBlink(FXObject*,FXSelector,void*);
-  long onFlash(FXObject*,FXSelector,void*);
-  long onAutoScroll(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-
-  // Control commands
-  long onCmdToggleEditable(FXObject*,FXSelector,void*);
-  long onUpdToggleEditable(FXObject*,FXSelector,void*);
-  long onCmdToggleOverstrike(FXObject*,FXSelector,void*);
-  long onUpdToggleOverstrike(FXObject*,FXSelector,void*);
-  long onCmdCursorRow(FXObject*,FXSelector,void*);
-  long onUpdCursorRow(FXObject*,FXSelector,void*);
-  long onCmdCursorColumn(FXObject*,FXSelector,void*);
-  long onUpdCursorColumn(FXObject*,FXSelector,void*);
-  long onUpdHaveSelection(FXObject*,FXSelector,void*);
-  long onUpdSelectAll(FXObject*,FXSelector,void*);
-  long onCmdSetStringValue(FXObject*,FXSelector,void*);
-  long onCmdGetStringValue(FXObject*,FXSelector,void*);
-  long onCmdSearch(FXObject*,FXSelector,void*);
-  long onCmdReplace(FXObject*,FXSelector,void*);
-  long onCmdSearchNext(FXObject*,FXSelector,void*);
-  long onCmdSearchSel(FXObject*,FXSelector,void*);
-
-  // Cursor movement
-  long onCmdCursorTop(FXObject*,FXSelector,void*);
-  long onCmdCursorBottom(FXObject*,FXSelector,void*);
-  long onCmdCursorHome(FXObject*,FXSelector,void*);
-  long onCmdCursorEnd(FXObject*,FXSelector,void*);
-  long onCmdCursorRight(FXObject*,FXSelector,void*);
-  long onCmdCursorLeft(FXObject*,FXSelector,void*);
-  long onCmdCursorUp(FXObject*,FXSelector,void*);
-  long onCmdCursorDown(FXObject*,FXSelector,void*);
-  long onCmdCursorWordLeft(FXObject*,FXSelector,void*);
-  long onCmdCursorWordRight(FXObject*,FXSelector,void*);
-  long onCmdCursorWordStart(FXObject*,FXSelector,void*);
-  long onCmdCursorWordEnd(FXObject*,FXSelector,void*);
-  long onCmdCursorPageDown(FXObject*,FXSelector,void*);
-  long onCmdCursorPageUp(FXObject*,FXSelector,void*);
-  long onCmdCursorScreenTop(FXObject*,FXSelector,void*);
-  long onCmdCursorScreenBottom(FXObject*,FXSelector,void*);
-  long onCmdCursorScreenCenter(FXObject*,FXSelector,void*);
-  long onCmdCursorParHome(FXObject*,FXSelector,void*);
-  long onCmdCursorParEnd(FXObject*,FXSelector,void*);
-  long onCmdBlockBeg(FXObject*,FXSelector,void*);
-  long onCmdBlockEnd(FXObject*,FXSelector,void*);
-  long onCmdGotoMatching(FXObject*,FXSelector,void*);
-  long onCmdGotoSelected(FXObject*,FXSelector,void*);
-  long onCmdGotoLine(FXObject*,FXSelector,void*);
-  long onCmdScrollUp(FXObject*,FXSelector,void*);
-  long onCmdScrollDown(FXObject*,FXSelector,void*);
-
-  // Mark and extend
-  long onCmdMark(FXObject*,FXSelector,void*);
-  long onCmdExtend(FXObject*,FXSelector,void*);
-
-  // Inserting
-  long onCmdOverstString(FXObject*,FXSelector,void*);
-  long onCmdInsertString(FXObject*,FXSelector,void*);
-  long onCmdInsertNewline(FXObject*,FXSelector,void*);
-  long onCmdInsertTab(FXObject*,FXSelector,void*);
-
-  // Manipulation Selection
-  long onCmdCutSel(FXObject*,FXSelector,void*);
-  long onCmdCopySel(FXObject*,FXSelector,void*);
-  long onCmdPasteSel(FXObject*,FXSelector,void*);
-  long onCmdDeleteSel(FXObject*,FXSelector,void*);
-  long onCmdChangeCase(FXObject*,FXSelector,void*);
-  long onCmdShiftText(FXObject*,FXSelector,void*);
-  long onCmdPasteMiddle(FXObject*,FXSelector,void*);
-
-  // Changing Selection
-  long onCmdSelectChar(FXObject*,FXSelector,void*);
-  long onCmdSelectWord(FXObject*,FXSelector,void*);
-  long onCmdSelectLine(FXObject*,FXSelector,void*);
-  long onCmdSelectAll(FXObject*,FXSelector,void*);
-  long onCmdSelectMatching(FXObject*,FXSelector,void*);
-  long onCmdSelectBlock(FXObject*,FXSelector,void*);
-  long onCmdDeselectAll(FXObject*,FXSelector,void*);
-
-  // Deletion
-  long onCmdBackspace(FXObject*,FXSelector,void*);
-  long onCmdBackspaceWord(FXObject*,FXSelector,void*);
-  long onCmdBackspaceBol(FXObject*,FXSelector,void*);
-  long onCmdDelete(FXObject*,FXSelector,void*);
-  long onCmdDeleteWord(FXObject*,FXSelector,void*);
-  long onCmdDeleteEol(FXObject*,FXSelector,void*);
-  long onCmdDeleteAll(FXObject*,FXSelector,void*);
-  long onCmdDeleteLine(FXObject*,FXSelector,void*);
-
-public:
-  static const FXchar textDelimiters[];
-
-public:
-
-  enum {
-    ID_CURSOR_TOP=FXScrollArea::ID_LAST,
-    ID_CURSOR_BOTTOM,
-    ID_CURSOR_HOME,
-    ID_CURSOR_END,
-    ID_CURSOR_RIGHT,
-    ID_CURSOR_LEFT,
-    ID_CURSOR_UP,
-    ID_CURSOR_DOWN,
-    ID_CURSOR_WORD_LEFT,
-    ID_CURSOR_WORD_RIGHT,
-    ID_CURSOR_WORD_START,
-    ID_CURSOR_WORD_END,
-    ID_CURSOR_PAGEDOWN,
-    ID_CURSOR_PAGEUP,
-    ID_CURSOR_SCRNTOP,
-    ID_CURSOR_SCRNBTM,
-    ID_CURSOR_SCRNCTR,
-    ID_CURSOR_PAR_HOME,
-    ID_CURSOR_PAR_END,
-    ID_SCROLL_UP,
-    ID_SCROLL_DOWN,
-    ID_MARK,
-    ID_EXTEND,
-    ID_OVERST_STRING,
-    ID_INSERT_STRING,
-    ID_INSERT_NEWLINE,
-    ID_INSERT_TAB,
-    ID_CUT_SEL,
-    ID_COPY_SEL,
-    ID_DELETE_SEL,
-    ID_PASTE_SEL,
-    ID_PASTE_MIDDLE,
-    ID_SELECT_CHAR,
-    ID_SELECT_WORD,
-    ID_SELECT_LINE,
-    ID_SELECT_ALL,
-    ID_SELECT_MATCHING,
-    ID_SELECT_BRACE,
-    ID_SELECT_BRACK,
-    ID_SELECT_PAREN,
-    ID_SELECT_ANG,
-    ID_DESELECT_ALL,
-    ID_BACKSPACE,
-    ID_BACKSPACE_WORD,
-    ID_BACKSPACE_BOL,
-    ID_DELETE,
-    ID_DELETE_WORD,
-    ID_DELETE_EOL,
-    ID_DELETE_ALL,
-    ID_DELETE_LINE,
-    ID_TOGGLE_EDITABLE,
-    ID_TOGGLE_OVERSTRIKE,
-    ID_CURSOR_ROW,
-    ID_CURSOR_COLUMN,
-    ID_CLEAN_INDENT,
-    ID_SHIFT_LEFT,
-    ID_SHIFT_RIGHT,
-    ID_SHIFT_TABLEFT,
-    ID_SHIFT_TABRIGHT,
-    ID_UPPER_CASE,
-    ID_LOWER_CASE,
-    ID_GOTO_MATCHING,
-    ID_GOTO_SELECTED,
-    ID_GOTO_LINE,
-    ID_SEARCH_FORW_SEL,
-    ID_SEARCH_BACK_SEL,
-    ID_SEARCH_FORW,
-    ID_SEARCH_BACK,
-    ID_SEARCH,
-    ID_REPLACE,
-    ID_LEFT_BRACE,
-    ID_LEFT_BRACK,
-    ID_LEFT_PAREN,
-    ID_LEFT_ANG,
-    ID_RIGHT_BRACE,
-    ID_RIGHT_BRACK,
-    ID_RIGHT_PAREN,
-    ID_RIGHT_ANG,
-    ID_BLINK,
-    ID_FLASH,
-    ID_LAST
-    };
-
-public:
-
-  /// Construct multi-line text widget
-  FXText(FXComposite *p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=3,FXint pr=3,FXint pt=2,FXint pb=2);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Enable the text widget
-  virtual void enable();
-
-  /// Disable the text widget
-  virtual void disable();
-
-  /// Need to recalculate size
-  virtual void recalc();
-
-  /// Get default width
-  virtual FXint getContentWidth();
-
-  /// Get default height
-  virtual FXint getContentHeight();
-
-  /// Returns true because a text widget can receive focus
-  virtual bool canFocus() const;
-
-  /// Move the focus to this window
-  virtual void setFocus();
-
-  /// Remove the focus from this window
-  virtual void killFocus();
-
-  /// Change top margin
-  void setMarginTop(FXint pt);
-
-  /// Return top margin
-  FXint getMarginTop() const { return margintop; }
-
-  /// Change bottom margin
-  void setMarginBottom(FXint pb);
-
-  /// Return bottom margin
-  FXint getMarginBottom() const { return marginbottom; }
-
-  /// Change left margin
-  void setMarginLeft(FXint pl);
-
-  /// Return left margin
-  FXint getMarginLeft() const { return marginleft; }
-
-  /// Change right margin
-  void setMarginRight(FXint pr);
-
-  /// Return right margin
-  FXint getMarginRight() const { return marginright; }
-
-  /// Return wrap columns
-  FXint getWrapColumns() const { return wrapcolumns; }
-
-  /// Set wrap columns
-  void setWrapColumns(FXint cols);
-
-  /// Return tab columns
-  FXint getTabColumns() const { return tabcolumns; }
-
-  /// Change tab columns
-  void setTabColumns(FXint cols);
-
-  /// Return number of columns used for line numbers
-  FXint getBarColumns() const { return barcolumns; }
-
-  /// Change number of columns used for line numbers
-  void setBarColumns(FXint cols);
-
-  /// Return TRUE if text was modified
-  FXbool isModified() const { return modified; }
-
-  /// Set modified flag
-  void setModified(FXbool mod=TRUE){ modified=mod; }
-
-  /// Set editable mode
-  void setEditable(FXbool edit=TRUE);
-
-  /// Return TRUE if text is editable
-  FXbool isEditable() const;
-
-  /// Set overstrike mode
-  void setOverstrike(FXbool over=TRUE);
-
-  /// Return TRUE if overstrike mode in effect
-  FXbool isOverstrike() const;
-
-  /// Set styled text mode
-  void setStyled(FXbool styled=TRUE);
-
-  /// Return TRUE if style buffer
-  FXbool isStyled() const { return (sbuffer!=NULL); }
-
-  /// Change delimiters of words
-  void setDelimiters(const FXchar* delims=textDelimiters){ delimiters=delims; }
-
-  /// Return word delimiters
-  const FXchar* getDelimiters() const { return delimiters; }
-
-  /// Change text font
-  void setFont(FXFont* fnt);
-
-  /// Return text font
-  FXFont* getFont() const { return font; }
-
-  /// Change text color
-  void setTextColor(FXColor clr);
-
-  /// Return text color
-  FXColor getTextColor() const { return textColor; }
-
-  /// Change selected background color
-  void setSelBackColor(FXColor clr);
-
-  /// Return selected background color
-  FXColor getSelBackColor() const { return selbackColor; }
-
-  /// Change selected text color
-  void setSelTextColor(FXColor clr);
-
-  /// Return selected text color
-  FXColor getSelTextColor() const { return seltextColor; }
-
-  /// Change highlighted text color
-  void setHiliteTextColor(FXColor clr);
-
-  /// Return highlighted text color
-  FXColor getHiliteTextColor() const { return hilitetextColor; }
-
-  /// Change highlighted background color
-  void setHiliteBackColor(FXColor clr);
-
-  /// Return highlighted background color
-  FXColor getHiliteBackColor() const { return hilitebackColor; }
-
-  /// Change active background color
-  void setActiveBackColor(FXColor clr);
-
-  /// Return active background color
-  FXColor getActiveBackColor() const { return activebackColor; }
-
-  /// Change cursor color
-  void setCursorColor(FXColor clr);
-
-  /// Return cursor color
-  FXColor getCursorColor() const { return cursorColor; }
-
-  /// Change line number color
-  void setNumberColor(FXColor clr);
-
-  /// Return line number color
-  FXColor getNumberColor() const { return numberColor; }
-
-  /// Change bar color
-  void setBarColor(FXColor clr);
-
-  /// Return bar color
-  FXColor getBarColor() const { return barColor; }
-
-  /// Set help text
-  void setHelpText(const FXString& text){ help=text; }
-
-  /// Return help text
-  FXString getHelpText() const { return help; }
-
-  /// Set the tool tip message for this text widget
-  void setTipText(const FXString& text){ tip=text; }
-
-  /// Get the tool tip message for this text widget
-  FXString getTipText() const { return tip; }
-
-  /// Get character at position in text buffer
-  FXint getByte(FXint pos) const;
-
-  /// Get wide character at position pos
-  FXwchar getChar(FXint pos) const;
-
-  /// Get length of wide character at position pos
-  FXint getCharLen(FXint pos) const;
-
-  /// Get style at position pos
-  FXint getStyle(FXint pos) const;
-
-  /// Extract n bytes of text from position pos
-  void extractText(FXchar *text,FXint pos,FXint n) const;
-  void extractText(FXString& text,FXint pos,FXint n) const;
-
-  /// Extract n bytes of style info from position pos
-  void extractStyle(FXString& text,FXint pos,FXint n) const;
-  void extractStyle(FXchar *style,FXint pos,FXint n) const;
-
-  /// Replace m bytes at pos by n characters
-  virtual void replaceText(FXint pos,FXint m,const FXchar *text,FXint n,FXbool notify=FALSE);
-  virtual void replaceText(FXint pos,FXint m,const FXString& text,FXbool notify=FALSE);
-
-  /// Replace m bytes at pos by n characters
-  virtual void replaceStyledText(FXint pos,FXint m,const FXchar *text,FXint n,FXint style=0,FXbool notify=FALSE);
-  virtual void replaceStyledText(FXint pos,FXint m,const FXString& text,FXint style=0,FXbool notify=FALSE);
-
-  /// Append n bytes of text at the end of the buffer
-  virtual void appendText(const FXchar *text,FXint n,FXbool notify=FALSE);
-  virtual void appendText(const FXString& text,FXbool notify=FALSE);
-
-  /// Append n bytes of text at the end of the buffer
-  virtual void appendStyledText(const FXchar *text,FXint n,FXint style=0,FXbool notify=FALSE);
-  virtual void appendStyledText(const FXString& text,FXint style=0,FXbool notify=FALSE);
-
-  /// Insert n bytes of text at position pos into the buffer
-  virtual void insertText(FXint pos,const FXchar *text,FXint n,FXbool notify=FALSE);
-  virtual void insertText(FXint pos,const FXString& text,FXbool notify=FALSE);
-
-  /// Insert n bytes of text at position pos into the buffer
-  virtual void insertStyledText(FXint pos,const FXchar *text,FXint n,FXint style=0,FXbool notify=FALSE);
-  virtual void insertStyledText(FXint pos,const FXString& text,FXint style=0,FXbool notify=FALSE);
-
-  /// Remove n bytes of text at position pos from the buffer
-  virtual void removeText(FXint pos,FXint n,FXbool notify=FALSE);
-
-  /// Change style of text range
-  virtual void changeStyle(FXint pos,FXint n,FXint style);
-
-  /// Change style of text range from style-array
-  virtual void changeStyle(FXint pos,const FXchar* style,FXint n);
-  virtual void changeStyle(FXint pos,const FXString& style);
-
-  /// Change the text in the buffer to new text
-  virtual void setText(const FXchar* text,FXint n,FXbool notify=FALSE);
-  virtual void setText(const FXString& text,FXbool notify=FALSE);
-
-  /// Change the text in the buffer to new text
-  virtual void setStyledText(const FXchar* text,FXint n,FXint style=0,FXbool notify=FALSE);
-  virtual void setStyledText(const FXString& text,FXint style=0,FXbool notify=FALSE);
-
-  /// Retrieve text into buffer
-  void getText(FXchar* text,FXint n) const;
-  void getText(FXString& text) const;
-
-  /// Return text in the widget
-  FXString getText() const;
-
-  /// Return length of buffer
-  FXint getLength() const { return length; }
-
-  /// Return number of rows in buffer
-  FXint getNumRows() const { return nrows; }
-
-  /// Shift block of lines from position start up to end by given amount
-  FXint shiftText(FXint start,FXint end,FXint amount,FXbool notify=FALSE);
-
-  /**
-  * Search for string in text buffer, returning the extent of
-  * the string in beg and end.  The search starts from the given
-  * starting position, scans forward (SEARCH_FORWARD) or backward
-  * (SEARCH_BACKWARD), and wraps around if SEARCH_WRAP has been
-  * specified.  The search type is either a plain search (SEARCH_EXACT),
-  * case insensitive search (SEARCH_IGNORECASE), or regular expression
-  * search (SEARCH_REGEX).
-  * For regular expression searches, capturing parentheses are used if
-  * npar is greater than 1; in this case, the number of entries in the
-  * beg[], end[] arrays must be npar also.  If either beg or end or
-  * both are NULL, internal arrays are used.
-  * [This API is still subject to change!!]
-  */
-  FXbool findText(const FXString& string,FXint* beg=NULL,FXint* end=NULL,FXint start=0,FXuint flags=SEARCH_FORWARD|SEARCH_WRAP|SEARCH_EXACT,FXint npar=1);
-
-  /// Return TRUE if position pos is selected
-  FXbool isPosSelected(FXint pos) const;
-
-  /// Return TRUE if position is fully visible
-  FXbool isPosVisible(FXint pos) const;
-
-  /// Return text position at given visible x,y coordinate
-  FXint getPosAt(FXint x,FXint y) const;
-
-  /// Count number of rows; start should be on a row start
-  FXint countRows(FXint start,FXint end) const;
-
-  /// Count number of columns; start should be on a row start
-  FXint countCols(FXint start,FXint end) const;
-
-  /// Count number of newlines
-  FXint countLines(FXint start,FXint end) const;
-
-  /// Return position of begin of line containing position pos
-  FXint lineStart(FXint pos) const;
-
-  /// Return position of end of line containing position pos
-  FXint lineEnd(FXint pos) const;
-
-  /// Return start of next line
-  FXint nextLine(FXint pos,FXint nl=1) const;
-
-  /// Return start of previous line
-  FXint prevLine(FXint pos,FXint nl=1) const;
-
-  /// Return row start
-  FXint rowStart(FXint pos) const;
-
-  /// Return row end
-  FXint rowEnd(FXint pos) const;
-
-  /// Return start of next row
-  FXint nextRow(FXint pos,FXint nr=1) const;
-
-  /// Return start of previous row
-  FXint prevRow(FXint pos,FXint nr=1) const;
-
-  /// Return end of previous word
-  FXint leftWord(FXint pos) const;
-
-  /// Return begin of next word
-  FXint rightWord(FXint pos) const;
-
-  /// Return begin of word
-  FXint wordStart(FXint pos) const;
-
-  /// Return end of word
-  FXint wordEnd(FXint pos) const;
-
-  /// Return validated utf8 character start position
-  FXint validPos(FXint pos) const;
-
-  /// Retreat to the previous valid utf8 character start
-  FXint dec(FXint pos) const;
-
-  /// Advance to the next valid utf8 character start
-  FXint inc(FXint pos) const;
-
-  /// Make line containing pos the top line
-  void setTopLine(FXint pos);
-
-  /// Return position of top line
-  FXint getTopLine() const;
-
-  /// Make line containing pos the bottom line
-  void setBottomLine(FXint pos);
-
-  /// Return the position of the bottom line
-  FXint getBottomLine() const;
-
-  /// Make line containing pos the center line
-  void setCenterLine(FXint pos);
-
-  /// Set the anchor position
-  void setAnchorPos(FXint pos);
-
-  /// Return the anchor position
-  FXint getAnchorPos() const { return anchorpos; }
-
-  /// Set the cursor position
-  virtual void setCursorPos(FXint pos,FXbool notify=FALSE);
-
-  /// Set cursor row
-  void setCursorRow(FXint row,FXbool notify=FALSE);
-
-  /// Return cursor row
-  FXint getCursorRow() const { return cursorrow; }
-
-  /// Set cursor column
-  void setCursorColumn(FXint col,FXbool notify=FALSE);
-
-  /// Return cursor row, i.e. indent position
-  FXint getCursorColumn() const { return cursorcol; }
-
-  /// Return the cursor position
-  FXint getCursorPos() const { return cursorpos; }
-
-  /// Return selstartpos
-  FXint getSelStartPos() const { return selstartpos; }
-
-  /// Return selendpos
-  FXint getSelEndPos() const { return selendpos; }
-
-  /// Select all text
-  FXbool selectAll(FXbool notify=FALSE);
-
-  /// Extend the selection from the anchor to the given position
-  virtual FXbool extendSelection(FXint pos,FXTextSelectionMode select=SELECT_CHARS,FXbool notify=FALSE);
-
-  /// Select len characters starting at given position pos
-  FXbool setSelection(FXint pos,FXint len,FXbool notify=FALSE);
-
-  /// Unselect the text
-  virtual FXbool killSelection(FXbool notify=FALSE);
-
-  /// Highlight len characters starting at given position pos
-  FXbool setHighlight(FXint start,FXint len);
-
-  /// Unhighlight the text
-  FXbool killHighlight();
-
-  /// Scroll text to make the given position visible
-  void makePositionVisible(FXint pos);
-
-  /// Change text widget style
-  void setTextStyle(FXuint style);
-
-  /// Return text widget style
-  FXuint getTextStyle() const;
-
-  /// Change number of visible rows
-  void setVisibleRows(FXint rows);
-
-  /// Return number of visible rows
-  FXint getVisibleRows() const { return vrows; }
-
-  /// Change number of visible columns
-  void setVisibleColumns(FXint cols);
-
-  /// Return number of visible columns
-  FXint getVisibleColumns() const { return vcols; }
-
-  /**
-  * Change brace and parenthesis match highlighting time, in ms.
-  * A match highlight time of 0 disables brace matching.
-  */
-  void setHiliteMatchTime(FXuint t){ matchtime=t; }
-
-  /**
-  * Return brace and parenthesis match highlighting time, in ms.
-  */
-  FXuint getHiliteMatchTime() const { return matchtime; }
-
-  /// Set highlight styles
-  void setHiliteStyles(const FXHiliteStyle* styles);
-
-  /// Get highlight styles
-  const FXHiliteStyle* getHiliteStyles() const { return hilitestyles; }
-
-  /// Save to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXText();
-  };
-
-
-}
-
-#endif
diff --git a/fox-includes/FXTextCodec.h b/fox-includes/FXTextCodec.h
deleted file mode 100755
index ba5edef8..00000000
--- a/fox-includes/FXTextCodec.h
+++ /dev/null
@@ -1,150 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                   U n i c o d e   T e x t   C o d e c                         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2002,2006 by L.Johnson & J.van der Zijp.  All Rights Reserved.  *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXTextCodec.h 2401 2006-04-27 00:46:49Z lyle $                       *
-********************************************************************************/
-#ifndef FXTEXTCODEC_H
-#define FXTEXTCODEC_H
-
-#ifndef FXOBJECT_H
-#include "FXObject.h"
-#endif
-
-
-namespace FX {
-
-
-/**
- * Abstract base class for a stateless coder/decoder.
- */
-class FXAPI FXTextCodec : public FXObject {
-  FXDECLARE_ABSTRACT(FXTextCodec)
-public:
-
-  /// Construct text codec
-  FXTextCodec(){}
-
-
-  /// Convert utf8 to single wide character
-  static FXint utf2wc(FXwchar& wc,const FXchar* src,FXint nsrc);
-
-  /// Convert utf16 to single wide character
-  static FXint utf2wc(FXwchar& wc,const FXnchar* src,FXint nsrc);
-
-  /// Convert utf32 to single wide character
-  static FXint utf2wc(FXwchar& wc,const FXwchar* src,FXint nsrc);
-
-
-  /// Convert single wide character to utf8
-  static FXint wc2utf(FXchar* dst,FXint ndst,FXwchar wc);
-
-  /// Convert single wide character to utf16
-  static FXint wc2utf(FXnchar* dst,FXint ndst,FXwchar wc);
-
-  /// Convert single wide character to utf32
-  static FXint wc2utf(FXwchar* dst,FXint ndst,FXwchar wc);
-
-
-  /// Count utf8 bytes needed to convert multi-byte characters from src
-  virtual FXint mb2utflen(const FXchar* src,FXint nsrc) const;
-
-  /// Count utf8 bytes needed to convert multi-byte characters from src
-  FXint mb2utflen(const FXString& src) const;
-
-  /// Convert multi-byte characters from src to utf8 characters at dst
-  virtual FXint mb2utf(FXchar* dst,FXint ndst,const FXchar* src,FXint nsrc) const;
-
-  /// Convert multi-byte characters from src to utf8 characters at dst
-  FXint mb2utf(FXchar* dst,FXint ndst,const FXchar* src) const;
-
-  /// Convert multi-byte characters from src to utf8 characters at dst
-  FXint mb2utf(FXchar* dst,FXint ndst,const FXString& src) const;
-
-  /// Convert multi-byte characters from src to utf8 string
-  FXString mb2utf(const FXchar* src,FXint nsrc) const;
-
-  /// Convert multi-byte characters from src to utf8 string
-  FXString mb2utf(const FXchar* src) const;
-
-  /// Convert multi-byte string to utf8 string
-  FXString mb2utf(const FXString& src) const;
-
-  /// Convert multi-byte characters from src to single wide character
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-
-
-
-  /// Count multi-byte characters characters needed to convert utf8 from src
-  virtual FXint utf2mblen(const FXchar* src,FXint nsrc) const;
-
-  /// Count multi-byte characters characters needed to convert utf8 from src
-  virtual FXint utf2mblen(const FXString& src) const;
-
-  /// Convert utf8 characters at src to multi-byte characters at dst
-  virtual FXint utf2mb(FXchar* dst,FXint ndst,const FXchar* src,FXint nsrc) const;
-
-  /// Convert utf8 characters at src to multi-byte characters at dst
-  FXint utf2mb(FXchar* dst,FXint ndst,const FXchar* src) const;
-
-  /// Convert utf8 characters at src to multi-byte characters at dst
-  FXint utf2mb(FXchar* dst,FXint ndst,const FXString& src) const;
-
-  /// Convert utf8 characters at src to multi-byte string
-  FXString utf2mb(const FXchar* src,FXint nsrc) const;
-
-  /// Convert utf8 characters at src to multi-byte string
-  FXString utf2mb(const FXchar* src) const;
-
-  /// Convert utf8 string to multi-byte string
-  FXString utf2mb(const FXString& src) const;
-
-  /// Convert single wide character to multi-byte characters at dst
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-
-
-  /**
-  * Return the Management Information Base (MIBenum) for the character set.
-  */
-  virtual FXint mibEnum() const = 0;
-
-  /**
-  * Return name of the codec.
-  */
-  virtual const FXchar* name() const = 0;
-
-  /**
-  * Return the IANA mime name for this codec; this is used for example
-  * as "text/utf-8" in drag and drop protocols.
-  */
-  virtual const FXchar* mimeName() const = 0;
-
-  /**
-  * Return NULL-terminated list of aliases for this codec.
-  */
-  virtual const FXchar* const* aliases() const = 0;
-
-  /// Destruct codec
-  virtual ~FXTextCodec(){}
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXTextField.h b/fox-includes/FXTextField.h
deleted file mode 100755
index 5783e3b4..00000000
--- a/fox-includes/FXTextField.h
+++ /dev/null
@@ -1,367 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                         T e x t   F i e l d   W i d g e t                     *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXTextField.h 2343 2006-02-12 20:26:26Z lyle $                       *
-********************************************************************************/
-#ifndef FXTEXTFIELD_H
-#define FXTEXTFIELD_H
-
-#ifndef FXFRAME_H
-#include "FXFrame.h"
-#endif
-
-namespace FX {
-
-
-/// Textfield styles
-enum {
-  TEXTFIELD_PASSWD     = 0x00080000,    /// Password mode
-  TEXTFIELD_INTEGER    = 0x00100000,    /// Integer mode
-  TEXTFIELD_REAL       = 0x00200000,    /// Real mode
-  TEXTFIELD_READONLY   = 0x00400000,    /// NOT editable
-  TEXTFIELD_ENTER_ONLY = 0x00800000,    /// Only callback when enter hit
-  TEXTFIELD_LIMITED    = 0x01000000,    /// Limit entry to given number of columns
-  TEXTFIELD_OVERSTRIKE = 0x02000000,    /// Overstrike mode
-  TEXTFIELD_AUTOGRAY   = 0x04000000,    /// Automatically gray out text field when not updated
-  TEXTFIELD_AUTOHIDE   = 0x08000000,    /// Automatically hide text field when not updated
-  TEXTFIELD_NORMAL     = FRAME_SUNKEN|FRAME_THICK
-  };
-
-
-/**
-* A text field is a single-line text entry widget.
-* The text field widget supports clipboard for cut-and-paste
-* operations.
-* Text input may be constrained to a certain format; the built-in
-* capabilities support integer and real number entry constraints;
-* additional constraints on the input may be implemented by intercepting
-* the SEL_VERIFY message; a custom handler should examine the tentative
-* input string passed as type const FXchar* in the message data, and return
-* a value of "0" if the new input is accepted.
-* During text entry, the text field sends a SEL_CHANGED message to its target,
-* with the message data set to the current text value of type const FXchar*.
-* When the text is accepted by hitting ENTER, the SEL_COMMAND message is sent.
-* The text field also sends SEL_COMMAND when the focus moves to another control.
-* TEXTFIELD_ENTER_ONLY can be passed to suppress this feature. Typically, this
-* flag is used in dialogs that close when ENTER is hit in a text field.
-*/
-class FXAPI FXTextField : public FXFrame {
-  FXDECLARE(FXTextField)
-protected:
-  FXString      contents;       // Edited text
-  const FXchar *delimiters;     // Set of delimiters
-  FXFont       *font;           // Text font
-  FXColor       textColor;      // Text color
-  FXColor       selbackColor;   // Selected background color
-  FXColor       seltextColor;   // Selected text color
-  FXColor       cursorColor;    // Color of the Cursor
-  FXint         cursor;         // Cursor position
-  FXint         anchor;         // Anchor position
-  FXint         columns;        // Number of columns visible
-  FXint         shift;          // Shift amount
-  FXString      clipped;        // Clipped text
-  FXString      help;           // Help string
-  FXString      tip;            // Tooltip
-protected:
-  FXTextField();
-  FXint index(FXint x) const;
-  FXint coord(FXint i) const;
-  void drawCursor(FXuint state);
-  void drawTextRange(FXDCWindow& dc,FXint fm,FXint to);
-  void drawTextFragment(FXDCWindow& dc,FXint x,FXint y,FXint fm,FXint to);
-  void drawPWDTextFragment(FXDCWindow& dc,FXint x,FXint y,FXint fm,FXint to);
-  FXint rightWord(FXint pos) const;
-  FXint leftWord(FXint pos) const;
-  FXint wordStart(FXint pos) const;
-  FXint wordEnd(FXint pos) const;
-private:
-  FXTextField(const FXTextField&);
-  FXTextField& operator=(const FXTextField&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onUpdate(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onMiddleBtnPress(FXObject*,FXSelector,void*);
-  long onMiddleBtnRelease(FXObject*,FXSelector,void*);
-  long onVerify(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onSelectionLost(FXObject*,FXSelector,void*);
-  long onSelectionGained(FXObject*,FXSelector,void*);
-  long onSelectionRequest(FXObject*,FXSelector,void* ptr);
-  long onClipboardLost(FXObject*,FXSelector,void*);
-  long onClipboardGained(FXObject*,FXSelector,void*);
-  long onClipboardRequest(FXObject*,FXSelector,void*);
-  long onFocusSelf(FXObject*,FXSelector,void*);
-  long onFocusIn(FXObject*,FXSelector,void*);
-  long onFocusOut(FXObject*,FXSelector,void*);
-  long onBlink(FXObject*,FXSelector,void*);
-  long onAutoScroll(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-  long onCmdSetRealValue(FXObject*,FXSelector,void*);
-  long onCmdSetStringValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-  long onCmdGetRealValue(FXObject*,FXSelector,void*);
-  long onCmdGetStringValue(FXObject*,FXSelector,void*);
-  long onCmdCursorHome(FXObject*,FXSelector,void*);
-  long onCmdCursorEnd(FXObject*,FXSelector,void*);
-  long onCmdCursorRight(FXObject*,FXSelector,void*);
-  long onCmdCursorLeft(FXObject*,FXSelector,void*);
-  long onCmdCursorWordLeft(FXObject*,FXSelector,void*);
-  long onCmdCursorWordRight(FXObject*,FXSelector,void*);
-  long onCmdCursorWordStart(FXObject*,FXSelector,void*);
-  long onCmdCursorWordEnd(FXObject*,FXSelector,void*);
-  long onCmdMark(FXObject*,FXSelector,void*);
-  long onCmdExtend(FXObject*,FXSelector,void*);
-  long onCmdSelectAll(FXObject*,FXSelector,void*);
-  long onCmdDeselectAll(FXObject*,FXSelector,void*);
-  long onCmdCutSel(FXObject*,FXSelector,void*);
-  long onCmdCopySel(FXObject*,FXSelector,void*);
-  long onCmdPasteSel(FXObject*,FXSelector,void*);
-  long onCmdPasteMiddle(FXObject*,FXSelector,void*);
-  long onCmdDeleteSel(FXObject*,FXSelector,void*);
-  long onCmdDeleteAll(FXObject*,FXSelector,void*);
-  long onCmdOverstString(FXObject*,FXSelector,void*);
-  long onCmdInsertString(FXObject*,FXSelector,void*);
-  long onCmdBackspace(FXObject*,FXSelector,void*);
-  long onCmdDelete(FXObject*,FXSelector,void*);
-  long onCmdToggleEditable(FXObject*,FXSelector,void*);
-  long onUpdToggleEditable(FXObject*,FXSelector,void*);
-  long onCmdToggleOverstrike(FXObject*,FXSelector,void*);
-  long onUpdToggleOverstrike(FXObject*,FXSelector,void*);
-  long onUpdHaveSelection(FXObject*,FXSelector,void*);
-  long onUpdSelectAll(FXObject*,FXSelector,void*);
-  long onCmdSetHelp(FXObject*,FXSelector,void*);
-  long onCmdGetHelp(FXObject*,FXSelector,void*);
-  long onCmdSetTip(FXObject*,FXSelector,void*);
-  long onCmdGetTip(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-public:
-
-  /// Default text delimiters
-  static const FXchar textDelimiters[];
-
-public:
-
-  enum{
-    ID_CURSOR_HOME=FXFrame::ID_LAST,
-    ID_CURSOR_END,
-    ID_CURSOR_RIGHT,
-    ID_CURSOR_LEFT,
-    ID_CURSOR_WORD_LEFT,
-    ID_CURSOR_WORD_RIGHT,
-    ID_CURSOR_WORD_START,
-    ID_CURSOR_WORD_END,
-    ID_MARK,
-    ID_EXTEND,
-    ID_SELECT_ALL,
-    ID_DESELECT_ALL,
-    ID_CUT_SEL,
-    ID_COPY_SEL,
-    ID_PASTE_SEL,
-    ID_PASTE_MIDDLE,
-    ID_DELETE_SEL,
-    ID_DELETE_ALL,
-    ID_OVERST_STRING,
-    ID_INSERT_STRING,
-    ID_BACKSPACE,
-    ID_DELETE,
-    ID_TOGGLE_EDITABLE,
-    ID_TOGGLE_OVERSTRIKE,
-    ID_BLINK,
-    ID_LAST
-    };
-
-public:
-
-  /// Construct text field wide enough to display ncols columns
-  FXTextField(FXComposite* p,FXint ncols,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=TEXTFIELD_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Enable text field
-  virtual void enable();
-
-  /// Disable text field
-  virtual void disable();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Yes, text field may receive focus
-  virtual bool canFocus() const;
-
-  /// Move the focus to this window
-  virtual void setFocus();
-
-  /// Remove the focus from this window
-  virtual void killFocus();
-
-  /// Set editable mode
-  void setEditable(FXbool edit=TRUE);
-
-  /// Return TRUE if text field may be edited
-  FXbool isEditable() const;
-
-  /// Set overstrike mode
-  void setOverstrike(FXbool over=TRUE);
-
-  /// Return TRUE if overstrike mode in effect
-  FXbool isOverstrike() const;
-
-  /// Set cursor position
-  void setCursorPos(FXint pos);
-
-  /// Return cursor position
-  FXint getCursorPos() const { return cursor; }
-
-  /// Change anchor position
-  void setAnchorPos(FXint pos);
-
-  /// Return anchor position
-  FXint getAnchorPos() const { return anchor; }
-
-  /// Change the text and move cursor to end
-  void setText(const FXString& text,FXbool notify=FALSE);
-
-  /// Get the text for this label
-  FXString getText() const { return contents; }
-
-  /// Set the text font
-  void setFont(FXFont* fnt);
-
-  /// Get the text font
-  FXFont* getFont() const { return font; }
-
-  /// Change text color
-  void setTextColor(FXColor clr);
-
-  /// Return text color
-  FXColor getTextColor() const { return textColor; }
-
-  /// Change selected background color
-  void setSelBackColor(FXColor clr);
-
-  /// Return selected background color
-  FXColor getSelBackColor() const { return selbackColor; }
-
-  /// Change selected text color
-  void setSelTextColor(FXColor clr);
-
-  /// Return selected text color
-  FXColor getSelTextColor() const { return seltextColor; }
-
-  /// Changes the cursor color
-  void setCursorColor(FXColor clr);
-
-  /// Return the cursor color
-  FXColor getCursorColor() const { return cursorColor; }
-
-  /**
-  * Change the default width of the text field in terms of a number
-  * of columns times the width of the numeral '8'.
-  */
-  void setNumColumns(FXint cols);
-
-  /// Return number of columns
-  FXint getNumColumns() const { return columns; }
-
-  /**
-  * Change text justification mode. The justify mode is a combination of
-  * horizontal justification (JUSTIFY_LEFT, JUSTIFY_RIGHT, or JUSTIFY_CENTER_X),
-  * and vertical justification (JUSTIFY_TOP, JUSTIFY_BOTTOM, JUSTIFY_CENTER_Y).
-  * Note that JUSTIFY_CENTER_X can not be set from the constructor since by
-  * default text fields are left-justified.
-  */
-  void setJustify(FXuint mode);
-
-  /// Return text justification mode
-  FXuint getJustify() const;
-
-  /// Change word delimiters
-  void setDelimiters(const FXchar* delims=textDelimiters){ delimiters=delims; }
-
-  /// Return word delimiters
-  const FXchar* getDelimiters() const { return delimiters; }
-
-  /// Set the status line help text for this label
-  void setHelpText(const FXString& text){ help=text; }
-
-  /// Get the status line help text for this label
-  const FXString& getHelpText() const { return help; }
-
-  /// Set the tool tip message for this text field
-  void setTipText(const FXString& text){ tip=text; }
-
-  /// Get the tool tip message for this text field
-  const FXString& getTipText() const { return tip; }
-
-  /// Change text style
-  void setTextStyle(FXuint style);
-
-  /// Return text style
-  FXuint getTextStyle() const;
-
-  /// Select all text
-  FXbool selectAll();
-
-  /// Select len characters starting at given position pos
-  FXbool setSelection(FXint pos,FXint len);
-
-  /// Extend the selection from the anchor to the given position
-  FXbool extendSelection(FXint pos);
-
-  /// Unselect the text
-  FXbool killSelection();
-
-  /// Return TRUE if position pos is selected
-  FXbool isPosSelected(FXint pos) const;
-
-  /// Return TRUE if position is fully visible
-  FXbool isPosVisible(FXint pos) const;
-
-  /// Scroll text to make the given position visible
-  void makePositionVisible(FXint pos);
-
-  /// Save text field to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load text field from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXTextField();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXThread.h b/fox-includes/FXThread.h
deleted file mode 100755
index d9d4c16e..00000000
--- a/fox-includes/FXThread.h
+++ /dev/null
@@ -1,326 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                 M u l i t h r e a d i n g   S u p p o r t                     *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2004,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXThread.h 2360 2006-03-29 04:10:56Z lyle $                          *
-********************************************************************************/
-#ifndef FXTHREAD_H
-#define FXTHREAD_H
-
-namespace FX {
-
-
-// Thread ID type
-#ifndef WIN32
-typedef unsigned long FXThreadID;
-#else
-typedef void*         FXThreadID;
-#endif
-
-
-class FXCondition;
-
-
-/**
-* FXMutex provides a mutex which can be used to enforce critical
-* sections around updates of data shared by multiple threads.
-*/
-class FXAPI FXMutex {
-  friend class FXCondition;
-private:
-  FXuval data[24];
-private:
-  FXMutex(const FXMutex&);
-  FXMutex &operator=(const FXMutex&);
-public:
-
-  /// Initialize the mutex
-  FXMutex(FXbool recursive=FALSE);
-
-  /// Lock the mutex
-  void lock();
-
-  /// Return TRUE if succeeded locking the mutex
-  FXbool trylock();
-
-  /// Return TRUE if mutex is already locked
-  FXbool locked();
-
-  /// Unlock mutex
-  void unlock();
-
-  /// Delete the mutex
-  ~FXMutex();
-  };
-
-
-/**
-* An easy way to establish a correspondence between a C++ scope
-* and a critical section is to simply declare an FXMutexLock
-* at the beginning of the scope.
-* The mutex will be automatically released when the scope is
-* left (either by natural means or by means of an exception.
-*/
-class FXAPI FXMutexLock {
-private:
-  FXMutex& mtx;
-private:
-  FXMutexLock();
-  FXMutexLock(const FXMutexLock&);
-  FXMutexLock& operator=(const FXMutexLock&);
-public:
-
-  /// Construct & lock associated mutex
-  FXMutexLock(FXMutex& m):mtx(m){ lock(); }
-
-  /// Return reference to associated mutex
-  FXMutex& mutex(){ return mtx; }
-
-  /// Lock mutex
-  void lock(){ mtx.lock(); }
-
-  /// Return TRUE if succeeded locking the mutex
-  FXbool trylock(){ return mtx.trylock(); }
-
-  /// Return TRUE if mutex is already locked
-  FXbool locked(){ return mtx.locked(); }
-
-  /// Unlock mutex
-  void unlock(){ mtx.unlock(); }
-
-  /// Destroy and unlock associated mutex
-  ~FXMutexLock(){ unlock(); }
-  };
-
-
-/**
-* A condition allows one or more threads to synchronize
-* to an event.  When a thread calls wait, the associated
-* mutex is unlocked while the thread is blocked.  When the
-* condition becomes signaled, the associated mutex is
-* locked and the thread(s) are reawakened.
-*/
-class FXAPI FXCondition {
-private:
-  FXuval data[12];
-private:
-  FXCondition(const FXCondition&);
-  FXCondition& operator=(const FXCondition&);
-public:
-
-  /// Initialize the condition
-  FXCondition();
-
-  /**
-  * Wait until condition becomes signalled, using given mutex,
-  * which must already have been locked prior to this call.
-  */
-  void wait(FXMutex& mtx);
-
-  /**
-  * Wait until condition becomes signalled, using given mutex,
-  * which must already have been locked prior to this call.
-  * Returns TRUE if successful, FALSE if timeout occurred.
-  * Note that the wait-time is specified in nanoseconds
-  * since the Epoch (Jan 1, 1970).
-  */
-  FXbool wait(FXMutex& mtx,FXlong nsec);
-
-  /**
-  * Wake or unblock a single blocked thread
-  */
-  void signal();
-
-  /**
-  * Wake or unblock all blocked threads
-  */
-  void broadcast();
-
-  /// Delete the condition
-  ~FXCondition();
-  };
-
-
-/**
-* A semaphore allows for protection of a resource that can
-* be accessed by a fixed number of simultaneous threads.
-*/
-class FXSemaphore {
-private:
-  FXuval data[16];
-private:
-  FXSemaphore(const FXSemaphore&);
-  FXSemaphore& operator=(const FXSemaphore&);
-public:
-
-  /// Initialize semaphore with given count
-  FXSemaphore(FXint initial=1);
-
-  /// Decrement semaphore
-  void wait();
-
-  /// Non-blocking semaphore decrement; return true if locked
-  FXbool trywait();
-
-  /// Increment semaphore
-  void post();
-
-  /// Delete semaphore
-  ~FXSemaphore();
-  };
-
-
-/**
-* FXThread provides system-independent support for threads.
-* Subclasses must implement the run() function do implement
-* the desired functionality of the thread.
-* The storage of the FXThread object is to be managed by the
-* calling thread, not by the thread itself.
-*/
-class FXAPI FXThread {
-private:
-  FXThreadID tid;
-private:
-  FXThread(const FXThread&);
-  FXThread &operator=(const FXThread&);
-#ifdef WIN32
-  static unsigned int CALLBACK execute(void*);
-#else
-  static void* execute(void*);
-#endif
-protected:
-
-  /**
-  * All threads execute by deriving the run method of FXThread.
-  * If an uncaught exception was thrown, this function returns -1.
-  */
-  virtual FXint run() = 0;
-
-public:
-
-  /// Initialize thread object.
-  FXThread();
-
-  /**
-  * Return handle of this thread object.
-  * This handle is valid in the context of the thread which
-  * called start().
-  */
-  FXThreadID id() const;
-
-  /**
-  * Return TRUE if this thread is running.
-  */
-  FXbool running() const;
-
-  /**
-  * Start thread; the thread is started as attached.
-  * The thread is given stacksize for its stack; a value of
-  * zero for stacksize will give it the default stack size.
-  */
-  FXbool start(unsigned long stacksize=0);
-
-  /**
-  * Suspend calling thread until thread is done.
-  */
-  FXbool join();
-
-  /**
-  * Suspend calling thread until thread is done, and set code to the
-  * return value of run() or the argument passed into exit().
-  * If an exception happened in the thread, return -1.
-  */
-  FXbool join(FXint& code);
-
-  /**
-  * Cancel the thread, stopping it immediately, running or not.
-  * If the calling thread is this thread, nothing happens.
-  * It is probably better to wait until it is finished, in case the
-  * thread currently holds mutexes.
-  */
-  FXbool cancel();
-
-  /**
-  * Detach thread, so that a no join() is necessary to harvest the
-  * resources of this thread.
-  */
-  FXbool detach();
-
-  /**
-  * Exit the calling thread.
-  * No destructors are invoked for objects on thread's stack;
-  * to invoke destructors, throw an exception instead.
-  */
-  static void exit(FXint code=0);
-
-  /**
-  * Make the thread yield its time quantum.
-  */
-  static void yield();
-
-  /**
-  * Return time in nanoseconds since Epoch (Jan 1, 1970).
-  */
-  static FXlong time();
-
-  /**
-  * Make the calling thread sleep for a number of nanoseconds.
-  */
-  static void sleep(FXlong nsec);
-
-  /**
-  * Wake at appointed time specified in nanoseconds since Epoch.
-  */
-  static void wakeat(FXlong nsec);
-
-  /**
-  * Return pointer to the FXThread instance associated
-  * with the calling thread; it returns NULL for the main
-  * thread and all threads not created by FOX.
-  */
-  static FXThread* self();
-
-  /**
-  * Return thread id of calling thread.
-  */
-  static FXThreadID current();
-
-  /**
-  * Set thread priority.
-  */
-  void priority(FXint prio);
-
-  /**
-  * Return thread priority.
-  */
-  FXint priority();
-
-  /**
-  * Destroy the thread immediately, running or not.
-  * It is probably better to wait until it is finished, in case
-  * the thread currently holds mutexes.
-  */
-  virtual ~FXThread();
-  };
-
-}
-
-#endif
-
diff --git a/fox-includes/FXToggleButton.h b/fox-includes/FXToggleButton.h
deleted file mode 100755
index a336a531..00000000
--- a/fox-includes/FXToggleButton.h
+++ /dev/null
@@ -1,157 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                   T o g g l e    B u t t o n    W i d g e t                   *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXToggleButton.h 2343 2006-02-12 20:26:26Z lyle $                    *
-********************************************************************************/
-#ifndef FXTOGGLEBUTTON_H
-#define FXTOGGLEBUTTON_H
-
-#ifndef FXLABEL_H
-#include "FXLabel.h"
-#endif
-
-namespace FX {
-
-
-/// Toggle button flags
-enum {
-  TOGGLEBUTTON_AUTOGRAY = 0x00800000,       /// Automatically gray out when not updated
-  TOGGLEBUTTON_AUTOHIDE = 0x01000000,       /// Automatically hide toggle button when not updated
-  TOGGLEBUTTON_TOOLBAR  = 0x02000000,       /// Toolbar style toggle button [flat look]
-  TOGGLEBUTTON_KEEPSTATE= 0x04000000,       /// Draw button according to state
-  TOGGLEBUTTON_NORMAL   = FRAME_RAISED|FRAME_THICK|JUSTIFY_NORMAL|ICON_BEFORE_TEXT
-  };
-
-
-/**
-* The toggle button provides a two-state button, which toggles between the
-* on and the off state each time it is pressed.  For each state, the toggle
-* button has a unique icon and text label.
-* When pressed, the button widget sends a SEL_COMMAND to its target, with the
-* message data set to the current state of the toggle button, of the type FXbool.
-*/
-class FXAPI FXToggleButton : public FXLabel {
-  FXDECLARE(FXToggleButton)
-protected:
-  FXString  altlabel;
-  FXIcon   *alticon;
-  FXHotKey  althotkey;
-  FXint     althotoff;
-  FXString  alttip;
-  FXString  althelp;
-  FXbool    state;
-  FXbool    down;
-protected:
-  FXToggleButton();
-  void press(FXbool dn);
-private:
-  FXToggleButton(const FXToggleButton&);
-  FXToggleButton& operator=(const FXToggleButton&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onUpdate(FXObject*,FXSelector,void*);
-  long onEnter(FXObject*,FXSelector,void*);
-  long onLeave(FXObject*,FXSelector,void*);
-  long onFocusIn(FXObject*,FXSelector,void*);
-  long onFocusOut(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onHotKeyPress(FXObject*,FXSelector,void*);
-  long onHotKeyRelease(FXObject*,FXSelector,void*);
-  long onCheck(FXObject*,FXSelector,void*);
-  long onUncheck(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-  long onCmdSetValue(FXObject*,FXSelector,void*);
-  long onCmdSetIntValue(FXObject*,FXSelector,void*);
-  long onCmdGetIntValue(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct toggle button with two text labels, and two icons, one for each state
-  FXToggleButton(FXComposite* p,const FXString& text1,const FXString& text2,FXIcon* icon1=NULL,FXIcon* icon2=NULL,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=TOGGLEBUTTON_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Returns true because a toggle button can receive focus
-  virtual bool canFocus() const;
-
-  /// Get default width
-  virtual FXint getDefaultWidth();
-
-  /// Get default height
-  virtual FXint getDefaultHeight();
-
-  /// Change alternate text shown when toggled
-  void setAltText(const FXString& text);
-
-  /// Return alternate text
-  FXString getAltText() const { return altlabel; }
-
-  /// Change alternate icon shown when toggled
-  void setAltIcon(FXIcon* ic);
-
-  /// Return alternate icon
-  FXIcon* getAltIcon() const { return alticon; }
-
-  /// Change toggled state
-  void setState(FXbool s=TRUE,FXbool notify=FALSE);
-
-  /// return toggled state
-  FXbool getState() const { return state; }
-
-  /// Change alternate help text shown when toggled
-  void setAltHelpText(const FXString& text);
-
-  /// Return alternate help text
-  FXString getAltHelpText() const { return althelp; }
-
-  /// Change alternate tip text shown when toggled
-  void setAltTipText(const FXString& text);
-
-  /// Return alternate tip text
-  FXString getAltTipText() const { return alttip; }
-
-  /// Set the toggle button style flags
-  void setToggleStyle(FXuint style);
-
-  /// Get the toggle button style flags
-  FXuint getToggleStyle() const;
-
-  /// Save toggle button to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load toggle button from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXToggleButton();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXToolBar.h b/fox-includes/FXToolBar.h
deleted file mode 100755
index 5a4aaab5..00000000
--- a/fox-includes/FXToolBar.h
+++ /dev/null
@@ -1,84 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        T o o l B a r   W i d g e t                            *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2004,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXToolBar.h 2244 2005-11-10 01:45:23Z lyle $                         *
-********************************************************************************/
-#ifndef FXTOOLBAR_H
-#define FXTOOLBAR_H
-
-#ifndef FXDOCKBAR_H
-#include "FXDockBar.h"
-#endif
-
-namespace FX {
-
-class FXDockSite;
-
-
-/**
-* A tool bar widget can be docked in a dock site; it automatically
-* adjusts its orientation based on the orientation of the dock site,
-* and adjusts the layout options accordingly.
-* See dock bar widget for more information on the docking behavior.
-*/
-class FXAPI FXToolBar : public FXDockBar {
-  FXDECLARE(FXToolBar)
-protected:
-  FXToolBar(){}
-private:
-  FXToolBar(const FXToolBar&);
-  FXToolBar &operator=(const FXToolBar&);
-public:
-  long onCmdDockFlip(FXObject*,FXSelector,void*);
-  long onUpdDockFlip(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct floatable toolbar, initially docked under parent p
-  FXToolBar(FXComposite* p,FXComposite* q,FXuint opts=LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=3,FXint pr=3,FXint pt=2,FXint pb=2,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING);
-
-  /// Construct a non-floatable toolbar
-  FXToolBar(FXComposite* p,FXuint opts,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=2,FXint pr=3,FXint pt=3,FXint pb=2,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING);
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Dock and optionally flip orientation of toolbar
-  virtual void dock(FXDockSite* docksite,FXWindow* before=NULL,FXbool notify=FALSE);
-
-  /// Dock and optionally flip orientation of toolbar
-  virtual void dock(FXDockSite* docksite,FXint localx,FXint localy,FXbool notify);
-
-  /// Set docking side
-  void setDockingSide(FXuint side=LAYOUT_SIDE_TOP);
-
-  /// Return docking side
-  FXuint getDockingSide() const;
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXToolBarGrip.h b/fox-includes/FXToolBarGrip.h
deleted file mode 100755
index c120fbcf..00000000
--- a/fox-includes/FXToolBarGrip.h
+++ /dev/null
@@ -1,100 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       T o o l B a r G r i p   W i d g e t                     *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2000,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXToolBarGrip.h 2343 2006-02-12 20:26:26Z lyle $                     *
-********************************************************************************/
-#ifndef FXTOOLBARGRIP_H
-#define FXTOOLBARGRIP_H
-
-#ifndef FXDOCKHANDLER_H
-#include "FXDockHandler.h"
-#endif
-
-namespace FX {
-
-
-/// Tool Bar Grip styles
-enum {
-  TOOLBARGRIP_SINGLE     = 0,             /// Single bar mode for movable toolbars
-  TOOLBARGRIP_DOUBLE     = 0x00008000     /// Double bar mode for dockable toolbars
-  };
-
-
-/**
-* A toolbar grip is used to move its container, a dock bar.
-* The grip draws either a single or double bar; it is customary
-* to use the single bar grip for toolbar-rearrangements only,
-* and use the double-bar when the toolbar needs to be floated
-* or docked.
-* The toolbar grip is automatically oriented properly by the
-* the toolbar widget, similar to the FXSeparator widget.
-* Holding the Control Key while dragging the grip will prevent
-* the toolbar from docking when it is near a dock site.
-*/
-class FXAPI FXToolBarGrip : public FXDockHandler {
-  FXDECLARE(FXToolBarGrip)
-protected:
-  FXColor activeColor;  // Color when active
-protected:
-  FXToolBarGrip();
-private:
-  FXToolBarGrip(const FXToolBarGrip&);
-  FXToolBarGrip& operator=(const FXToolBarGrip&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onEnter(FXObject*,FXSelector,void*);
-  long onLeave(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct toolbar grip
-  FXToolBarGrip(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=TOOLBARGRIP_SINGLE,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=0,FXint pr=0,FXint pt=0,FXint pb=0);
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// The grip can not receive the focus
-  virtual bool canFocus() const;
-
-  /// Change toolbar grip to double
-  void setDoubleBar(FXbool dbl=TRUE);
-
-  /// Return TRUE if toolbar grip is displayed as a double bar
-  FXbool isDoubleBar() const;
-
-  /// Set the active color
-  void setActiveColor(FXColor clr);
-
-  /// Get the active color
-  FXColor getActiveColor() const { return activeColor; }
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXToolBarShell.h b/fox-includes/FXToolBarShell.h
deleted file mode 100755
index 00e0520d..00000000
--- a/fox-includes/FXToolBarShell.h
+++ /dev/null
@@ -1,120 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                    T o o l   B a r   S h e l l   W i d g e t                  *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2000,2003 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXToolBarShell.h 1536 2003-05-14 21:41:00Z lyle $                     *
-********************************************************************************/
-#ifndef FXTOOLBARSHELL_H
-#define FXTOOLBARSHELL_H
-
-#ifndef FXTOPWINDOW_H
-#include "FXTopWindow.h"
-#endif
-
-namespace FX {
-
-
-/**
-* A Tool bar shell is a widget floating around over the Main Window.
-* It typically contains an undocked tool bar.
-*/
-class FXAPI FXToolBarShell : public FXTopWindow {
-  FXDECLARE(FXToolBarShell)
-protected:
-  FXColor   baseColor;
-  FXColor   hiliteColor;
-  FXColor   shadowColor;
-  FXColor   borderColor;
-  FXint     border;
-protected:
-  FXToolBarShell(){}
-  void drawBorderRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawRaisedRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawSunkenRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawRidgeRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawGrooveRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawDoubleRaisedRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawDoubleSunkenRectangle(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-  void drawFrame(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
-private:
-  FXToolBarShell(const FXToolBarShell&);
-  FXToolBarShell &operator=(const FXToolBarShell&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct a toolbar shell
-  FXToolBarShell(FXWindow* owner,FXuint opts=FRAME_RAISED|FRAME_THICK,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint hs=4,FXint vs=4);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return the default width of this window
-  virtual FXint getDefaultWidth();
-
-  /// Return the default height of this window
-  virtual FXint getDefaultHeight();
-
-  /// Change frame style
-  void setFrameStyle(FXuint style);
-
-  /// Get current frame style
-  FXuint getFrameStyle() const;
-
-  /// Get border width
-  FXint getBorderWidth() const { return border; }
-
-  /// Change highlight color
-  void setHiliteColor(FXColor clr);
-
-  /// Get highlight color
-  FXColor getHiliteColor() const { return hiliteColor; }
-
-  /// Change shadow color
-  void setShadowColor(FXColor clr);
-
-  /// Get shadow color
-  FXColor getShadowColor() const { return shadowColor; }
-
-  /// Change border color
-  void setBorderColor(FXColor clr);
-
-  /// Get border color
-  FXColor getBorderColor() const { return borderColor; }
-
-  /// Change base gui color
-  void setBaseColor(FXColor clr);
-
-  /// Get base gui color
-  FXColor getBaseColor() const { return baseColor; }
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXToolBarTab.h b/fox-includes/FXToolBarTab.h
deleted file mode 100755
index 33213a9b..00000000
--- a/fox-includes/FXToolBarTab.h
+++ /dev/null
@@ -1,142 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       T o o l   B a r   T a b   W i d g e t                   *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1999,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXToolBarTab.h 2343 2006-02-12 20:26:26Z lyle $                      *
-********************************************************************************/
-#ifndef FXTOOLBARTAB_H
-#define FXTOOLBARTAB_H
-
-#ifndef FXFRAME_H
-#include "FXFrame.h"
-#endif
-
-namespace FX {
-
-
-/// Tool Bar Tab styles
-enum {
-  TOOLBARTAB_HORIZONTAL = 0,              /// Default is for horizontal toolbar
-  TOOLBARTAB_VERTICAL   = 0x00008000      /// For vertical toolbar
-  };
-
-
-
-/**
-* A toolbar tab is used to collapse or uncollapse a sibling
-* widget.  The sibling affected is the widget immediately following
-* the toolbar tab or, if the toolbar tab is the last widget in the list,
-* the widget immediately preceding the toolbar tab.
-*/
-class FXAPI FXToolBarTab : public FXFrame {
-  FXDECLARE(FXToolBarTab)
-protected:
-  FXColor  activeColor; // Color when active
-  FXString tip;         // Tooltip
-  FXbool   collapsed;   // Is collapsed flat
-  FXbool   down;        // Button down
-protected:
-  FXToolBarTab();
-  void drawUpArrow(FXDCWindow& dc);
-  void drawDownArrow(FXDCWindow& dc);
-  void drawRightArrow(FXDCWindow& dc);
-  void drawLeftArrow(FXDCWindow& dc);
-  void drawHSpeckles(FXDCWindow& dc,FXint x,FXint w);
-  void drawVSpeckles(FXDCWindow& dc,FXint y,FXint h);
-private:
-  FXToolBarTab(const FXToolBarTab&);
-  FXToolBarTab& operator=(const FXToolBarTab&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onUpdate(FXObject*,FXSelector,void*);
-  long onEnter(FXObject*,FXSelector,void*);
-  long onLeave(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onCmdCollapse(FXObject*,FXSelector,void*);
-  long onUpdCollapse(FXObject*,FXSelector,void*);
-  long onCmdUncollapse(FXObject*,FXSelector,void*);
-  long onUpdUncollapse(FXObject*,FXSelector,void*);
-  long onCmdSetTip(FXObject*,FXSelector,void*);
-  long onCmdGetTip(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_COLLAPSE=FXFrame::ID_LAST,
-    ID_UNCOLLAPSE,
-    ID_LAST
-    };
-public:
-
-  /// Construct toolbar tab
-  FXToolBarTab(FXComposite* p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=FRAME_RAISED,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Toolbar tab can receive focus
-  virtual bool canFocus() const;
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Enable the toolbar tab
-  virtual void enable();
-
-  /// Disable the toolbar tab
-  virtual void disable();
-
-  /// Collapse or uncollapse the toolbar
-  void collapse(FXbool fold,FXbool notify=FALSE);
-
-  /// Return true if the toolbar is collapsed
-  FXbool isCollapsed() const { return collapsed; }
-
-  /// Change the tab style
-  void setTabStyle(FXuint style);
-
-  /// Get current tab style
-  FXuint getTabStyle() const;
-
-  /// Get the active color
-  FXColor getActiveColor() const { return activeColor; }
-
-  /// Set the active color
-  void setActiveColor(FXColor clr);
-
-  /// Set the tool tip message for the toolbar tab
-  void setTipText(const FXString& text){ tip=text; }
-
-  /// Get the tool tip message for the toolbar tab
-  const FXString& getTipText() const { return tip; }
-
-  /// Save to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from a stream
-  virtual void load(FXStream& store);
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXToolTip.h b/fox-includes/FXToolTip.h
deleted file mode 100755
index 51f3a613..00000000
--- a/fox-includes/FXToolTip.h
+++ /dev/null
@@ -1,128 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                           T o o l   T i p   W i d g e t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXToolTip.h 2346 2006-02-14 03:26:11Z lyle $                         *
-********************************************************************************/
-#ifndef FXTOOLTIP_H
-#define FXTOOLTIP_H
-
-#ifndef FXSHELL_H
-#include "FXShell.h"
-#endif
-
-namespace FX {
-
-
-class FXFont;
-
-
-/// Tooltip styles
-enum {
-  TOOLTIP_PERMANENT  = 0x00020000,      /// Tooltip stays up indefinitely
-  TOOLTIP_VARIABLE   = 0x00040000,      /// Tooltip stays up variable time, depending on the length of the string
-  TOOLTIP_NORMAL     = 0                /// Normal tooltip
-  };
-
-
-/// Hopefully Helpful Hint message
-class FXAPI FXToolTip : public FXShell {
-  FXDECLARE(FXToolTip)
-protected:
-  FXString  label;                      // Text in the tip
-  FXFont   *font;                       // Font of the tip
-  FXColor   textColor;                  // Text color
-  FXbool    popped;                     // Is currently popped up
-protected:
-  FXToolTip();
-  virtual bool doesOverrideRedirect() const;
-  void place(FXint x,FXint y);
-  void autoplace();
-private:
-  FXToolTip(const FXToolTip&);
-  FXToolTip& operator=(const FXToolTip&);
-#ifdef WIN32
-  virtual const char* GetClass() const;
-#endif
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onUpdate(FXObject*,FXSelector,void*);
-  long onTipShow(FXObject*,FXSelector,void*);
-  long onTipHide(FXObject*,FXSelector,void*);
-  long onCmdGetStringValue(FXObject*,FXSelector,void*);
-  long onCmdSetStringValue(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_TIP_SHOW=FXShell::ID_LAST,
-    ID_TIP_HIDE,
-    ID_LAST
-    };
-public:
-  /// Construct a tool tip
-  FXToolTip(FXApp* a,FXuint opts=TOOLTIP_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Display the tip
-  virtual void show();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Set the text for this tip
-  void setText(const FXString& text);
-
-  /// Get the text for this tip
-  FXString getText() const { return label; }
-
-  /// Set the tip text font
-  void setFont(FXFont *fnt);
-
-  /// Get the tip text font
-  FXFont* getFont() const { return font; }
-
-  /// Get the current tip text color
-  FXColor getTextColor() const { return textColor; }
-
-  /// Set the current tip text color
-  void setTextColor(FXColor clr);
-
-  virtual bool doesSaveUnder() const;
-
-  /// Save tip to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load tip from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXToolTip();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXTopWindow.h b/fox-includes/FXTopWindow.h
deleted file mode 100755
index 7204a132..00000000
--- a/fox-includes/FXTopWindow.h
+++ /dev/null
@@ -1,298 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                 T o p - L e v e l   W i n d o w   W i d g e t                 *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1998,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXTopWindow.h 2246 2005-11-10 02:01:15Z lyle $                       *
-********************************************************************************/
-#ifndef FXTOPWINDOW_H
-#define FXTOPWINDOW_H
-
-#ifndef FXSHELL_H
-#include "FXShell.h"
-#endif
-
-
-namespace FX {
-
-
-/// Title and border decorations
-enum {
-  DECOR_NONE        = 0,                                  /// Borderless window
-  DECOR_TITLE       = 0x00020000,                         /// Window title
-  DECOR_MINIMIZE    = 0x00040000,                         /// Minimize button
-  DECOR_MAXIMIZE    = 0x00080000,                         /// Maximize button
-  DECOR_CLOSE       = 0x00100000,                         /// Close button
-  DECOR_BORDER      = 0x00200000,                         /// Border
-  DECOR_SHRINKABLE  = 0x00400000,                         /// Window can become smaller
-  DECOR_STRETCHABLE = 0x00800000,                         /// Window can become larger
-  DECOR_RESIZE      = DECOR_SHRINKABLE|DECOR_STRETCHABLE, /// Resize handles
-  DECOR_MENU        = 0x01000000,                         /// Window menu
-  DECOR_ALL         = (DECOR_TITLE|DECOR_MINIMIZE|DECOR_MAXIMIZE|DECOR_CLOSE|DECOR_BORDER|DECOR_SHRINKABLE|DECOR_STRETCHABLE|DECOR_MENU)
-  };
-
-
-/// Initial window placement
-enum {
-  PLACEMENT_DEFAULT,                  /// Place it at the default size and location
-  PLACEMENT_VISIBLE,                  /// Place window to be fully visible
-  PLACEMENT_CURSOR,                   /// Place it under the cursor position
-  PLACEMENT_OWNER,                    /// Place it centered on its owner
-  PLACEMENT_SCREEN,                   /// Place it centered on the screen
-  PLACEMENT_MAXIMIZED                 /// Place it maximized to the screen size
-  };
-
-
-class FXToolBar;
-class FXIcon;
-
-
-
-/**
-* Abstract base class for all top-level windows.
-* TopWindows are usually managed by a Window Manager under X11 and
-* therefore borders and window-menus and other decorations like resize-
-* handles are subject to the Window Manager's interpretation of the
-* decoration hints.
-* When a TopWindow is closed, it sends a SEL_CLOSE message to its
-* target.  The target should return 0 in response to this message if
-* there is no objection to proceed with the closing of the window, and
-* return 1 otherwise.  After the SEL_CLOSE message has been sent and
-* no objection was raised, the window will delete itself.
-* When the session is closed, the window will send a SEL_SESSION_NOTIFY
-* message to its target, allowing the application to write any unsaved
-* data to the disk.  If the target returns 0, then the system will proceed
-* to close the session.  Subsequently a SEL_SESSION_CLOSED will be received
-* which causes the window to be closed with prejudice by calling the
-* function close(FALSE).
-* When receiving a SEL_UPDATE, the target can update the title string
-* of the window, so that the title of the window reflects the name
-* of the document, for example.
-* For convenience, TopWindow provides the same layout behavior as
-* the Packer widget, as well as docking and undocking of toolbars.
-* TopWindows can be owned by other windows, or be free-floating.
-* Owned TopWindows will usually remain stacked on top of the owner
-* windows. The lifetime of an owned window should not exceed that of
-* the owner.
-*/
-class FXAPI FXTopWindow : public FXShell {
-  FXDECLARE_ABSTRACT(FXTopWindow)
-protected:
-  FXString  title;                    // Window title
-  FXIcon   *icon;                     // Window icon (big)
-  FXIcon   *miniIcon;                 // Window icon (small)
-  FXint     padtop;                   // Top margin
-  FXint     padbottom;                // Bottom margin
-  FXint     padleft;                  // Left margin
-  FXint     padright;                 // Right margin
-  FXint     hspacing;                 // Horizontal child spacing
-  FXint     vspacing;                 // Vertical child spacing
-protected:
-  FXTopWindow();
-  void settitle();
-  void seticons();
-  void setdecorations();
-  FXTopWindow(FXApp* ap,const FXString& name,FXIcon *ic,FXIcon *mi,FXuint opts,FXint x,FXint y,FXint w,FXint h,FXint pl,FXint pr,FXint pt,FXint pb,FXint hs,FXint vs);
-  FXTopWindow(FXWindow* ow,const FXString& name,FXIcon *ic,FXIcon *mi,FXuint opts,FXint x,FXint y,FXint w,FXint h,FXint pl,FXint pr,FXint pt,FXint pb,FXint hs,FXint vs);
-private:
-  FXTopWindow(const FXTopWindow&);
-  FXTopWindow& operator=(const FXTopWindow&);
-#ifdef WIN32
-  virtual const char* GetClass() const;
-#endif
-public:
-  long onFocusUp(FXObject*,FXSelector,void*);
-  long onFocusDown(FXObject*,FXSelector,void*);
-  long onFocusLeft(FXObject*,FXSelector,void*);
-  long onFocusRight(FXObject*,FXSelector,void*);
-  long onSessionNotify(FXObject*,FXSelector,void*);
-  long onSessionClosed(FXObject*,FXSelector,void*);
-  long onCmdMaximize(FXObject*,FXSelector,void*);
-  long onCmdMinimize(FXObject*,FXSelector,void*);
-  long onCmdRestore(FXObject*,FXSelector,void*);
-  long onCmdClose(FXObject*,FXSelector,void*);
-  long onCmdSetStringValue(FXObject*,FXSelector,void*);
-  long onCmdGetStringValue(FXObject*,FXSelector,void*);
-  long onCmdSetIconValue(FXObject*,FXSelector,void*);
-  long onCmdGetIconValue(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_MAXIMIZE=FXShell::ID_LAST,       /// Maximize the window
-    ID_MINIMIZE,                        /// Minimize the window
-    ID_RESTORE,                         /// Restore the window
-    ID_CLOSE,                           /// Close the window
-    ID_QUERY_DOCK,                      /// Toolbar asks to dock
-    ID_LAST
-    };
-public:
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach the server-side resources for this window
-  virtual void detach();
-
-  /// Destroy the server-side resources for this window
-  virtual void destroy();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Move the focus to this window
-  virtual void setFocus();
-
-  /// Remove the focus from this window
-  virtual void killFocus();
-
-  /// Show this window
-  virtual void show();
-
-  /// Hide this window
-  virtual void hide();
-
-  /// Show this window with given placement
-  virtual void show(FXuint placement);
-
-  /// Position the window based on placement
-  void place(FXuint placement);
-
-  /// Return the default width of this window
-  virtual FXint getDefaultWidth();
-
-  /// Return the default height of this window
-  virtual FXint getDefaultHeight();
-
-  /// Obtain border sizes added to our window by the window manager
-  FXbool getWMBorders(FXint& left,FXint& right,FXint& top,FXint& bottom);
-
-  /// Raise this window to the top of the stacking order
-  virtual void raise();
-
-  /// Move this window to the specified position in the parent's coordinates
-  virtual void move(FXint x,FXint y);
-
-  /// Resize this window to the specified width and height
-  virtual void resize(FXint w,FXint h);
-
-  /// Move and resize this window in the parent's coordinates
-  virtual void position(FXint x,FXint y,FXint w,FXint h);
-
-  /// Maximize window, return TRUE if maximized
-  virtual FXbool maximize(FXbool notify=FALSE);
-
-  /// Minimize or iconify window, return TRUE if minimized
-  virtual FXbool minimize(FXbool notify=FALSE);
-
-  /// Restore window to normal, return TRUE if restored
-  virtual FXbool restore(FXbool notify=FALSE);
-
-  /**
-  * Close the window, return TRUE if actually closed.  If notify=TRUE, the target
-  * will receive a SEL_CLOSE message to determine if it is OK to close the window.
-  * If the target ignores the SEL_CLOSE message or returns 0, the window will
-  * be closed, and subsequently deleted.  When the last main window has been
-  * closed, the application will receive an ID_QUIT message and will be closed.
-  */
-  virtual FXbool close(FXbool notify=FALSE);
-
-  /// Return TRUE if maximized
-  FXbool isMaximized() const;
-
-  /// Return TRUE if minimized
-  FXbool isMinimized() const;
-
-  /// Change window title
-  void setTitle(const FXString& name);
-
-  /// Return window title
-  FXString getTitle() const { return title; }
-
-  /// Change top padding
-  void setPadTop(FXint pt);
-
-  /// Get top interior padding
-  FXint getPadTop() const { return padtop; }
-
-  /// Change bottom padding
-  void setPadBottom(FXint pb);
-
-  /// Get bottom interior padding
-  FXint getPadBottom() const { return padbottom; }
-
-  /// Change left padding
-  void setPadLeft(FXint pl);
-
-  /// Get left interior padding
-  FXint getPadLeft() const { return padleft; }
-
-  /// Change right padding
-  void setPadRight(FXint pr);
-
-  /// Get right interior padding
-  FXint getPadRight() const { return padright; }
-
-  /// Return horizontal spacing between children
-  FXint getHSpacing() const { return hspacing; }
-
-  /// Return vertical spacing between children
-  FXint getVSpacing() const { return vspacing; }
-
-  /// Change horizontal spacing between children
-  void setHSpacing(FXint hs);
-
-  /// Change vertical spacing between children
-  void setVSpacing(FXint vs);
-
-  /// Change packing hints for children
-  void setPackingHints(FXuint ph);
-
-  /// Return packing hints for children
-  FXuint getPackingHints() const;
-
-  /// Change title and border decorations
-  void setDecorations(FXuint decorations);
-
-  /// Return current title and border decorations
-  FXuint getDecorations() const;
-
-  /// Return window icon
-  FXIcon* getIcon() const { return icon; }
-
-  /// Change window icon
-  void setIcon(FXIcon* ic);
-
-  /// Return window mini (title) icon
-  FXIcon* getMiniIcon() const { return miniIcon; }
-
-  /// Change window mini (title) icon
-  void setMiniIcon(FXIcon *ic);
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXTopWindow();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXTranslator.h b/fox-includes/FXTranslator.h
deleted file mode 100644
index 9303280b..00000000
--- a/fox-includes/FXTranslator.h
+++ /dev/null
@@ -1,84 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       M e s s a g e   T r a n s l a t o r                     *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2005 by Jeroen van der Zijp.   All Rights Reserved.             *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXTranslator.h 2290 2005-12-05 03:28:56Z lyle $                       *
-********************************************************************************/
-#ifndef FXTRANSLATOR_H
-#define FXTRANSLATOR_H
-
-#ifndef FXOBJECT_H
-#include "FXObject.h"
-#endif
-
-
-////////////////////////////  UNDER DEVELOPMENT  ////////////////////////////////
-
-
-namespace FX {
-
-class FXApp;
-class FXTextCodec;
-
-
-/**
-* The translator class translates a message to another language.
-*/
-class FXAPI FXTranslator : public FXObject {
-  FXDECLARE(FXTranslator)
-private:
-  FXApp       *app;     // Back link to application object
-  FXTextCodec *codec;   // Text codec used for source text
-private:
-  FXTranslator(const FXTranslator&);
-  FXTranslator &operator=(const FXTranslator&);
-protected:
-  FXTranslator():app((FXApp*)-1L){}
-public:
-
-  /// Construct translator
-  FXTranslator(FXApp* a);
-
-  /// Get application
-  FXApp* getApp() const { return app; }
-
-  /// Translate a string
-  virtual const FXchar* tr(const FXchar* context,const FXchar* message,const FXchar* hint=NULL) const;
-
-  /// Change text codec used to decode the messages embedded in the source
-  void setTextCodec(FXTextCodec *cdc){ codec=cdc; }
-
-  /// Return text codec
-  FXTextCodec *getTextCodec() const { return codec; }
-
-  /// Save translator to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load translator from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXTranslator();
-  };
-
-
-}
-
-#endif
diff --git a/fox-includes/FXTreeList.h b/fox-includes/FXTreeList.h
deleted file mode 100755
index 6b738c2b..00000000
--- a/fox-includes/FXTreeList.h
+++ /dev/null
@@ -1,609 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                         T r e e   L i s t   W i d g e t                       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXTreeList.h 2343 2006-02-12 20:26:26Z lyle $                       *
-********************************************************************************/
-#ifndef FXTREELIST_H
-#define FXTREELIST_H
-
-#ifndef FXSCROLLAREA_H
-#include "FXScrollArea.h"
-#endif
-
-namespace FX {
-
-
-class FXIcon;
-class FXFont;
-class FXTreeList;
-class FXDirList;
-
-
-/// Tree list styles
-enum {
-  TREELIST_EXTENDEDSELECT = 0,            /// Extended selection mode allows for drag-selection of ranges of items
-  TREELIST_SINGLESELECT   = 0x00100000,   /// Single selection mode allows up to one item to be selected
-  TREELIST_BROWSESELECT   = 0x00200000,   /// Browse selection mode enforces one single item to be selected at all times
-  TREELIST_MULTIPLESELECT = 0x00300000,   /// Multiple selection mode is used for selection of individual items
-  TREELIST_AUTOSELECT     = 0x00400000,   /// Automatically select under cursor
-  TREELIST_SHOWS_LINES    = 0x00800000,   /// Lines shown
-  TREELIST_SHOWS_BOXES    = 0x01000000,   /// Boxes to expand shown
-  TREELIST_ROOT_BOXES     = 0x02000000,   /// Display root boxes also
-  TREELIST_NORMAL         = TREELIST_EXTENDEDSELECT
-  };
-
-
-/// Tree list Item
-class FXAPI FXTreeItem : public FXObject {
-  FXDECLARE(FXTreeItem)
-  friend class FXTreeList;
-  friend class FXDirList;
-protected:
-  FXTreeItem *parent;           // Parent item
-  FXTreeItem *prev;             // Previous item
-  FXTreeItem *next;             // Next item
-  FXTreeItem *first;            // First child item
-  FXTreeItem *last;             // Last child item
-  FXString    label;            // Text of item
-  FXIcon     *openIcon;         // Icon of item
-  FXIcon     *closedIcon;       // Icon of item
-  void       *data;             // Item user data pointer
-  FXuint      state;            // Item state flags
-  FXint       x,y;
-private:
-  FXTreeItem(const FXTreeItem&);
-  FXTreeItem& operator=(const FXTreeItem&);
-protected:
-  FXTreeItem():parent(NULL),prev(NULL),next(NULL),first(NULL),last(NULL),openIcon(NULL),closedIcon(NULL),data(NULL),state(0),x(0),y(0){}
-  virtual void draw(const FXTreeList* list,FXDC& dc,FXint x,FXint y,FXint w,FXint h) const;
-  virtual FXint hitItem(const FXTreeList* list,FXint x,FXint y) const;
-public:
-  enum{
-    SELECTED        = 1,        /// Selected
-    FOCUS           = 2,        /// Focus
-    DISABLED        = 4,        /// Disabled
-    OPENED          = 8,        /// Opened
-    EXPANDED        = 16,       /// Expanded
-    HASITEMS        = 32,       /// Has virtual subitems
-    DRAGGABLE       = 64,       /// Draggable
-    OPENICONOWNED   = 128,      /// Open icon owned by item
-    CLOSEDICONOWNED = 256       /// Close icon owned by item
-    };
-public:
-
-  /// Constructor
-  FXTreeItem(const FXString& text,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL):parent(NULL),prev(NULL),next(NULL),first(NULL),last(NULL),label(text),openIcon(oi),closedIcon(ci),data(ptr),state(0),x(0),y(0){}
-
-  /// Get parent item
-  FXTreeItem* getParent() const { return parent; }
-
-  /// Get next sibling item
-  FXTreeItem* getNext() const { return next; }
-
-  /// Get previous sibling item
-  FXTreeItem* getPrev() const { return prev; }
-
-  /// Get first child item
-  FXTreeItem* getFirst() const { return first; }
-
-  /// Get las child item
-  FXTreeItem* getLast() const { return last; }
-
-  /// Get item below this one in list
-  FXTreeItem* getBelow() const;
-
-  /// Get item above this one in list
-  FXTreeItem* getAbove() const;
-
-  /// Get number of children of item
-  FXint getNumChildren() const;
-
-  /// Change item label
-  virtual void setText(const FXString& txt);
-
-  /// Get item label
-  const FXString& getText() const { return label; }
-
-  /// Change open icon, deleting the old icon if it was owned
-  virtual void setOpenIcon(FXIcon* icn,FXbool owned=FALSE);
-
-  /// Get open icon
-  FXIcon* getOpenIcon() const { return openIcon; }
-
-  /// Change closed icon, deleting the old icon if it was owned
-  virtual void setClosedIcon(FXIcon* icn,FXbool owned=FALSE);
-
-  /// Get closed icon
-  FXIcon* getClosedIcon() const { return closedIcon; }
-
-  /// Change item user data
-  void setData(void* ptr){ data=ptr; }
-
-  /// Get item user data
-  void* getData() const { return data; }
-
-  /// Make item draw as focused
-  virtual void setFocus(FXbool focus);
-
-  /// Return true if item has focus
-  FXbool hasFocus() const { return (state&FOCUS)!=0; }
-
-  /// Select item
-  virtual void setSelected(FXbool selected);
-
-  /// Return true if this item is selected
-  FXbool isSelected() const { return (state&SELECTED)!=0; }
-
-  /// Make item show as open
-  virtual void setOpened(FXbool opened);
-
-  /// Return true if this item is open
-  FXbool isOpened() const { return (state&OPENED)!=0; }
-
-  /// Expand or collapse item
-  virtual void setExpanded(FXbool expanded);
-
-  /// Return true if this item is expanded into sub items
-  FXbool isExpanded() const { return (state&EXPANDED)!=0; }
-
-  /// Enable or disable item
-  virtual void setEnabled(FXbool enabled);
-
-  /// Return true if this item is enabled
-  FXbool isEnabled() const { return (state&DISABLED)==0; }
-
-  /// Make item draggable
-  virtual void setDraggable(FXbool draggable);
-
-  /// Return true if this item is draggable
-  FXbool isDraggable() const { return (state&DRAGGABLE)!=0; }
-
-  /// Return TRUE if subitems, real or imagined
-  FXbool hasItems() const { return (state&HASITEMS)!=0; }
-
-  /// Change has items flag
-  void setHasItems(FXbool flag);
-
-  /// Return true if descendent of parent item
-  FXbool isChildOf(const FXTreeItem* item) const;
-
-  /// Return true if ancestor of child item
-  FXbool isParentOf(const FXTreeItem* item) const;
-
-  /// Return width of item as drawn in list
-  virtual FXint getWidth(const FXTreeList* list) const;
-
-  /// Return height of item as drawn in list
-  virtual FXint getHeight(const FXTreeList* list) const;
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Destroy server-side resources
-  virtual void destroy();
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  /// Destroy item and free icons if owned
-  virtual ~FXTreeItem();
-  };
-
-
-
-/// Tree item collate function
-typedef FXint (*FXTreeListSortFunc)(const FXTreeItem*,const FXTreeItem*);
-
-
-
-/**
-* A Tree List Widget organizes items in a hierarchical, tree-like fashion.
-* Subtrees can be collapsed or expanded by double-clicking on an item
-* or by clicking on the optional plus button in front of the item.
-* Each item may have a text and optional open-icon as well as a closed-icon.
-* The items may be connected by optional lines to show the hierarchical
-* relationship.
-* When an item's selected state changes, the treelist emits a SEL_SELECTED
-* or SEL_DESELECTED message.  If an item is opened or closed, a message
-* of type SEL_OPENED or SEL_CLOSED is sent.  When the subtree under an
-* item is expanded, a SEL_EXPANDED or SEL_COLLAPSED message is issued.
-* A change of the current item is signified by the SEL_CHANGED message.
-* In addition, the tree list sends SEL_COMMAND messages when the user
-* clicks on an item, and SEL_CLICKED, SEL_DOUBLECLICKED, and SEL_TRIPLECLICKED
-* when the user clicks once, twice, or thrice, respectively.
-* When items are added or removed, the tree list sends messages of the
-* type SEL_INSERTED or SEL_DELETED.
-* In each of these cases, a pointer to the item, if any, is passed in the
-* 3rd argument of the message.
-*/
-class FXAPI FXTreeList : public FXScrollArea {
-  FXDECLARE(FXTreeList)
-protected:
-  FXTreeItem        *firstitem;         // First root item
-  FXTreeItem        *lastitem;          // Last root item
-  FXTreeItem        *anchoritem;        // Selection anchor item
-  FXTreeItem        *currentitem;       // Current item
-  FXTreeItem        *extentitem;        // Selection extent
-  FXTreeItem        *cursoritem;        // Item under cursor
-  FXTreeItem        *viewableitem;      // Visible item
-  FXFont            *font;              // Font
-  FXTreeListSortFunc sortfunc;          // Item sort function
-  FXColor            textColor;         // Text color
-  FXColor            selbackColor;      // Selected background color
-  FXColor            seltextColor;      // Selected text color
-  FXColor            lineColor;         // Line color
-  FXint              treeWidth;         // Tree width
-  FXint              treeHeight;        // Tree height
-  FXint              visible;           // Number of visible items
-  FXint              indent;            // Parent to child indentation
-  FXint              grabx;             // Grab point x
-  FXint              graby;             // Grab point y
-  FXString           lookup;            // Lookup string
-  FXString           tip;
-  FXString           help;              // Help string
-  FXbool             state;             // State of item
-protected:
-  FXTreeList();
-  virtual FXTreeItem* createItem(const FXString& text,FXIcon* oi,FXIcon* ci,void* ptr);
-  void sort(FXTreeItem*& f1,FXTreeItem*& t1,FXTreeItem*& f2,FXTreeItem*& t2,int n);
-  void recompute();
-private:
-  FXTreeList(const FXTreeList&);
-  FXTreeList& operator=(const FXTreeList&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onEnter(FXObject*,FXSelector,void*);
-  long onLeave(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onRightBtnPress(FXObject*,FXSelector,void*);
-  long onRightBtnRelease(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onTipTimer(FXObject*,FXSelector,void*);
-  long onFocusIn(FXObject*,FXSelector,void*);
-  long onFocusOut(FXObject*,FXSelector,void*);
-  long onAutoScroll(FXObject*,FXSelector,void*);
-  long onClicked(FXObject*,FXSelector,void*);
-  long onDoubleClicked(FXObject*,FXSelector,void*);
-  long onTripleClicked(FXObject*,FXSelector,void*);
-  long onCommand(FXObject*,FXSelector,void*);
-  long onLookupTimer(FXObject*,FXSelector,void*);
-public:
-  static FXint ascending(const FXTreeItem*,const FXTreeItem*);
-  static FXint descending(const FXTreeItem*,const FXTreeItem*);
-  static FXint ascendingCase(const FXTreeItem*,const FXTreeItem*);
-  static FXint descendingCase(const FXTreeItem*,const FXTreeItem*);
-public:
-  enum {
-    ID_LOOKUPTIMER=FXScrollArea::ID_LAST,
-    ID_LAST
-    };
-public:
-
-  /// Construct a new, initially empty tree list
-  FXTreeList(FXComposite *p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=TREELIST_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Compute and return content width
-  virtual FXint getContentWidth();
-
-  /// Return content height
-  virtual FXint getContentHeight();
-
-  /// Recalculate layout
-  virtual void recalc();
-
-  /// Tree list can receive focus
-  virtual bool canFocus() const;
-
-  /// Move the focus to this window
-  virtual void setFocus();
-
-  /// Remove the focus from this window
-  virtual void killFocus();
-
-  /// Return number of items
-  FXint getNumItems() const;
-
-  /// Return number of visible items
-  FXint getNumVisible() const { return visible; }
-
-  /// Change number of visible items
-  void setNumVisible(FXint nvis);
-
-  /// Return first root item
-  FXTreeItem* getFirstItem() const { return firstitem; }
-
-  /// Return last root item
-  FXTreeItem* getLastItem() const { return lastitem; }
-
-  /// Fill tree list by appending items from array of strings
-  FXint fillItems(FXTreeItem* father,const FXchar** strings,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Fill tree list by appending items from newline separated strings
-  FXint fillItems(FXTreeItem* father,const FXString& strings,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Insert [possibly subclassed] item under father before other item
-  FXTreeItem* insertItem(FXTreeItem* other,FXTreeItem* father,FXTreeItem* item,FXbool notify=FALSE);
-
-  /// Insert item with given text and optional icons, and user-data pointer under father before other item
-  FXTreeItem* insertItem(FXTreeItem* other,FXTreeItem* father,const FXString& text,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Append [possibly subclassed] item as last child of father
-  FXTreeItem* appendItem(FXTreeItem* father,FXTreeItem* item,FXbool notify=FALSE);
-
-  /// Append item with given text and optional icons, and user-data pointer as last child of father
-  FXTreeItem* appendItem(FXTreeItem* father,const FXString& text,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Prepend [possibly subclassed] item as first child of father
-  FXTreeItem* prependItem(FXTreeItem* father,FXTreeItem* item,FXbool notify=FALSE);
-
-  /// Prepend item with given text and optional icons, and user-data pointer as first child of father
-  FXTreeItem* prependItem(FXTreeItem* father,const FXString& text,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL,FXbool notify=FALSE);
-
-  /// Move item under father before other item
-  FXTreeItem *moveItem(FXTreeItem* other,FXTreeItem* father,FXTreeItem* item);
-
-  /// Extract item
-  FXTreeItem* extractItem(FXTreeItem* item,FXbool notify=FALSE);
-
-  /// Remove item
-  void removeItem(FXTreeItem* item,FXbool notify=FALSE);
-
-  /// Remove items in range [fm, to] inclusively
-  void removeItems(FXTreeItem* fm,FXTreeItem* to,FXbool notify=FALSE);
-
-  /// Remove all items from list
-  void clearItems(FXbool notify=FALSE);
-
-  /// Return item width
-  FXint getItemWidth(const FXTreeItem* item) const { return item->getWidth(this); }
-
-  /// Return item height
-  FXint getItemHeight(const FXTreeItem* item) const { return item->getHeight(this); }
-
-  /// Get item at x,y, if any
-  virtual FXTreeItem* getItemAt(FXint x,FXint y) const;
-
-  /**
-  * Search items by name, beginning from item start.  If the start item
-  * is NULL the search will start at the first, top-most item in the list.
-  * Flags may be SEARCH_FORWARD or SEARCH_BACKWARD to control the search
-  * direction; this can be combined with SEARCH_NOWRAP or SEARCH_WRAP
-  * to control whether the search wraps at the start or end of the list.
-  * The option SEARCH_IGNORECASE causes a case-insensitive match.  Finally,
-  * passing SEARCH_PREFIX causes searching for a prefix of the item name.
-  * Return NULL if no matching item is found.
-  */
-  FXTreeItem* findItem(const FXString& name,FXTreeItem* start=NULL,FXuint flags=SEARCH_FORWARD|SEARCH_WRAP) const;
-
-  /**
-  * Search items by associated user data, beginning from item start. If the
-  * start item is NULL the search will start at the first, top-most item
-  * in the list.  Flags may be SEARCH_FORWARD or SEARCH_BACKWARD to control
-  * the search direction; this can be combined with SEARCH_NOWRAP or SEARCH_WRAP
-  * to control whether the search wraps at the start or end of the list.
-  */
-  FXTreeItem* findItemByData(const void *ptr,FXTreeItem* start=NULL,FXuint flags=SEARCH_FORWARD|SEARCH_WRAP) const;
-
-  /// Scroll to make item visible
-  virtual void makeItemVisible(FXTreeItem* item);
-
-  /// Change item's text
-  void setItemText(FXTreeItem* item,const FXString& text);
-
-  /// Return item's text
-  FXString getItemText(const FXTreeItem* item) const;
-
-  /// Change item's open icon
-  void setItemOpenIcon(FXTreeItem* item,FXIcon* icon,FXbool owned=FALSE);
-
-  /// Return item's open icon, deleting the old icon if it was owned
-  FXIcon* getItemOpenIcon(const FXTreeItem* item) const;
-
-  /// Chance item's closed icon, deleting the old icon if it was owned
-  void setItemClosedIcon(FXTreeItem* item,FXIcon* icon,FXbool owned=FALSE);
-
-  /// Return item's closed icon
-  FXIcon* getItemClosedIcon(const FXTreeItem* item) const;
-
-  /// Change item user-data pointer
-  void setItemData(FXTreeItem* item,void* ptr) const;
-
-  /// Return item user-data pointer
-  void* getItemData(const FXTreeItem* item) const;
-
-  /// Return TRUE if item is selected
-  FXbool isItemSelected(const FXTreeItem* item) const;
-
-  /// Return TRUE if item is current
-  FXbool isItemCurrent(const FXTreeItem* item) const;
-
-  /// Return TRUE if item is visible
-  FXbool isItemVisible(const FXTreeItem* item) const;
-
-  /// Return TRUE if item opened
-  FXbool isItemOpened(const FXTreeItem* item) const;
-
-  /// Return TRUE if item expanded
-  FXbool isItemExpanded(const FXTreeItem* item) const;
-
-  /// Return TRUE if item is a leaf-item, i.e. has no children
-  FXbool isItemLeaf(const FXTreeItem* item) const;
-
-  /// Return TRUE if item is enabled
-  FXbool isItemEnabled(const FXTreeItem* item) const;
-
-  /// Return item hit code: 0 outside, 1 icon, 2 text, 3 box
-  FXint hitItem(const FXTreeItem* item,FXint x,FXint y) const;
-
-  /// Repaint item
-  void updateItem(FXTreeItem* item) const;
-
-  /// Enable item
-  virtual FXbool enableItem(FXTreeItem* item);
-
-  /// Disable item
-  virtual FXbool disableItem(FXTreeItem* item);
-
-  /// Select item
-  virtual FXbool selectItem(FXTreeItem* item,FXbool notify=FALSE);
-
-  /// Deselect item
-  virtual FXbool deselectItem(FXTreeItem* item,FXbool notify=FALSE);
-
-  /// Toggle item selection
-  virtual FXbool toggleItem(FXTreeItem* item,FXbool notify=FALSE);
-
-  /// Extend selection from anchor item to item
-  virtual FXbool extendSelection(FXTreeItem* item,FXbool notify=FALSE);
-
-  /// Deselect all items
-  virtual FXbool killSelection(FXbool notify=FALSE);
-
-  /// Open item
-  virtual FXbool openItem(FXTreeItem* item,FXbool notify=FALSE);
-
-  /// Close item
-  virtual FXbool closeItem(FXTreeItem* item,FXbool notify=FALSE);
-
-  /// Collapse tree
-  virtual FXbool collapseTree(FXTreeItem* tree,FXbool notify=FALSE);
-
-  /// Expand tree
-  virtual FXbool expandTree(FXTreeItem* tree,FXbool notify=FALSE);
-
-  /// Change current item
-  virtual void setCurrentItem(FXTreeItem* item,FXbool notify=FALSE);
-
-  /// Return current item, if any
-  FXTreeItem* getCurrentItem() const { return currentitem; }
-
-  /// Change anchor item
-  void setAnchorItem(FXTreeItem* item);
-
-  /// Return anchor item, if any
-  FXTreeItem* getAnchorItem() const { return anchoritem; }
-
-  /// Return item under cursor, if any
-  FXTreeItem* getCursorItem() const { return cursoritem; }
-
-  /// Sort all items recursively
-  void sortItems();
-
-  /// Sort root items
-  void sortRootItems();
-
-  /// Sort children of item
-  void sortChildItems(FXTreeItem* item);
-
-  /// Return sort function
-  FXTreeListSortFunc getSortFunc() const { return sortfunc; }
-
-  /// Change sort function
-  void setSortFunc(FXTreeListSortFunc func){ sortfunc=func; }
-
-  /// Change text font
-  void setFont(FXFont* fnt);
-
-  /// Return text font
-  FXFont* getFont() const { return font; }
-
-  /// Change parent-child indent amount
-  void setIndent(FXint in);
-
-  /// Return parent-child indent amount
-  FXint getIndent() const { return indent; }
-
-  /// Return normal text color
-  FXColor getTextColor() const { return textColor; }
-
-  /// Change normal text color
-  void setTextColor(FXColor clr);
-
-  /// Return selected text background
-  FXColor getSelBackColor() const { return selbackColor; }
-
-  /// Change selected text background
-  void setSelBackColor(FXColor clr);
-
-  /// Return selected text color
-  FXColor getSelTextColor() const { return seltextColor; }
-
-  /// Change selected text color
-  void setSelTextColor(FXColor clr);
-
-  /// Return line color
-  FXColor getLineColor() const { return lineColor; }
-
-  /// Change line color
-  void setLineColor(FXColor clr);
-
-  /// Return list style
-  FXuint getListStyle() const;
-
-  /// Change list style
-  void setListStyle(FXuint style);
-
-  /// Set the status line help text for this list
-  void setHelpText(const FXString& text);
-
-  /// Get the status line help text for this list
-  const FXString& getHelpText() const { return help; }
-
-  /// Save object to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load object from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXTreeList();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXTreeListBox.h b/fox-includes/FXTreeListBox.h
deleted file mode 100755
index 19b88686..00000000
--- a/fox-includes/FXTreeListBox.h
+++ /dev/null
@@ -1,274 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                      T r e e   L i s t   B o x   W i d g e t                  *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1999,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXTreeListBox.h 2258 2005-11-30 14:28:29Z lyle $                     *
-********************************************************************************/
-#ifndef FXTREELISTBOX_H
-#define FXTREELISTBOX_H
-
-#ifndef FXPACKER_H
-#include "FXPacker.h"
-#endif
-
-namespace FX {
-
-
-/// Tree List Box styles
-enum {
-  TREELISTBOX_NORMAL         = 0          /// Normal style
-  };
-
-
-class FXButton;
-class FXMenuButton;
-class FXTreeList;
-class FXPopup;
-
-
-/**
-* The Tree List Box behaves very much like a List Box, except that
-* it supports a hierarchical, tree structured display of the items.
-* When an item is selected it issues a SEL_COMMAND message with the
-* pointer to the item.  While manipulating the tree list, it may send
-* SEL_CHANGED messages to indicate which item the cursor is hovering over.
-*/
-class FXAPI FXTreeListBox : public FXPacker {
-  FXDECLARE(FXTreeListBox)
-protected:
-  FXButton      *field;
-  FXMenuButton  *button;
-  FXTreeList    *tree;
-  FXPopup       *pane;
-protected:
-  FXTreeListBox(){}
-private:
-  FXTreeListBox(const FXTreeListBox&);
-  FXTreeListBox& operator=(const FXTreeListBox&);
-public:
-  long onFocusUp(FXObject*,FXSelector,void*);
-  long onFocusDown(FXObject*,FXSelector,void*);
-  long onFocusSelf(FXObject*,FXSelector,void*);
-  long onMouseWheel(FXObject*,FXSelector,void*);
-  long onFieldButton(FXObject*,FXSelector,void*);
-  long onTreeUpdate(FXObject*,FXSelector,void*);
-  long onTreeChanged(FXObject*,FXSelector,void*);
-  long onTreeClicked(FXObject*,FXSelector,void*);
-public:
-  enum{
-    ID_TREE=FXPacker::ID_LAST,
-    ID_FIELD,
-    ID_LAST
-    };
-public:
-
-  /// Construct tree list box
-  FXTreeListBox(FXComposite *p,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=FRAME_SUNKEN|FRAME_THICK|TREELISTBOX_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Destroy server-side resources
-  virtual void destroy();
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Enable widget
-  virtual void enable();
-
-  /// Disable widget
-  virtual void disable();
-
-  /// Return default with
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-
-  /// Return number of items
-  FXint getNumItems() const;
-
-  /// Return number of visible items
-  FXint getNumVisible() const;
-
-  /// Set number of visible items to determine default height
-  void setNumVisible(FXint nvis);
-
-  /// Return first top-level item
-  FXTreeItem* getFirstItem() const;
-
-  /// Return last top-level item
-  FXTreeItem* getLastItem() const;
-
-  /// Fill tree list box by appending items from array of strings
-  FXint fillItems(FXTreeItem* father,const FXchar** strings,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL);
-
-  /// Fill tree list box by appending items from newline separated strings
-  FXint fillItems(FXTreeItem* father,const FXString& strings,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL);
-
-  /// Insert [possibly subclassed] item under father before other item
-  FXTreeItem* insertItem(FXTreeItem* other,FXTreeItem* father,FXTreeItem* item);
-
-  /// Insert item with given text and optional icons, and user-data pointer under father before other item
-  FXTreeItem* insertItem(FXTreeItem* other,FXTreeItem* father,const FXString& text,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL);
-
-  /// Append [possibly subclassed] item as last child of father
-  FXTreeItem* appendItem(FXTreeItem* father,FXTreeItem* item);
-
-  /// Append item with given text and optional icons, and user-data pointer as last child of father
-  FXTreeItem* appendItem(FXTreeItem* father,const FXString& text,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL);
-
-  /// Prepend [possibly subclassed] item as first child of father
-  FXTreeItem* prependItem(FXTreeItem* father,FXTreeItem* item);
-
-  /// Prepend item with given text and optional icons, and user-data pointer as first child of father
-  FXTreeItem* prependItem(FXTreeItem* father,const FXString& text,FXIcon* oi=NULL,FXIcon* ci=NULL,void* ptr=NULL);
-
-  /// Move item under father before other item
-  FXTreeItem *moveItem(FXTreeItem* other,FXTreeItem* father,FXTreeItem* item);
-
-  /// Extract item
-  FXTreeItem* extractItem(FXTreeItem* item);
-
-  /// Remove item
-  void removeItem(FXTreeItem* item);
-
-  /// Remove all items in range [fm...to]
-  void removeItems(FXTreeItem* fm,FXTreeItem* to);
-
-  /// Remove all items from list
-  void clearItems();
-
-  /**
-  * Search items by name, beginning from item start.  If the
-  * start item is NULL the search will start at the first, top-most item
-  * in the list.  Flags may be SEARCH_FORWARD or SEARCH_BACKWARD to control
-  * the search direction; this can be combined with SEARCH_NOWRAP or SEARCH_WRAP
-  * to control whether the search wraps at the start or end of the list.
-  * The option SEARCH_IGNORECASE causes a case-insensitive match.  Finally,
-  * passing SEARCH_PREFIX causes searching for a prefix of the item name.
-  * Return NULL if no matching item is found.
-  */
-  FXTreeItem* findItem(const FXString& text,FXTreeItem* start=NULL,FXuint flags=SEARCH_FORWARD|SEARCH_WRAP) const;
-
-  /**
-  * Search items by associated user data, beginning from item start. If the
-  * start item is NULL the search will start at the first, top-most item
-  * in the list.  Flags may be SEARCH_FORWARD or SEARCH_BACKWARD to control
-  * the search direction; this can be combined with SEARCH_NOWRAP or SEARCH_WRAP
-  * to control whether the search wraps at the start or end of the list.
-  */
-  FXTreeItem* findItemByData(const void *ptr,FXTreeItem* start=NULL,FXuint flags=SEARCH_FORWARD|SEARCH_WRAP) const;
-
-  /// Return TRUE if item is the current item
-  FXbool isItemCurrent(const FXTreeItem* item) const;
-
-  /// Return TRUE if item is leaf-item, i.e. has no children
-  FXbool isItemLeaf(const FXTreeItem* item) const;
-
-  /// Sort the toplevel items with the sort function
-  void sortRootItems();
-
-  /// Sort all items recursively
-  void sortItems();
-
-  /// Sort child items of item
-  void sortChildItems(FXTreeItem* item);
-
-  /// Change current item
-  virtual void setCurrentItem(FXTreeItem* item,FXbool notify=FALSE);
-
-  /// Return current item
-  FXTreeItem* getCurrentItem() const;
-
-  /// Change item label
-  void setItemText(FXTreeItem* item,const FXString& text);
-
-  /// Return item label
-  FXString getItemText(const FXTreeItem* item) const;
-
-  /// Change item's open icon, delete old one if it was owned
-  void setItemOpenIcon(FXTreeItem* item,FXIcon* icon,FXbool owned=FALSE);
-
-  /// Return item's open icon
-  FXIcon* getItemOpenIcon(const FXTreeItem* item) const;
-
-  /// Change item's closed icon, delete old one if it was owned
-  void setItemClosedIcon(FXTreeItem* item,FXIcon* icon,FXbool owned=FALSE);
-
-  /// Return item's closed icon
-  FXIcon* getItemClosedIcon(const FXTreeItem* item) const;
-
-  /// Change item's user data
-  void setItemData(FXTreeItem* item,void* ptr) const;
-
-  /// Return item's user data
-  void* getItemData(const FXTreeItem* item) const;
-
-  /// Return item sort function
-  FXTreeListSortFunc getSortFunc() const;
-
-  /// Change item sort function
-  void setSortFunc(FXTreeListSortFunc func);
-
-  /// Is the pane shown
-  FXbool isPaneShown() const;
-
-  /// Change font
-  void setFont(FXFont* fnt);
-
-  /// Return font
-  FXFont* getFont() const;
-
-  /// Return list style
-  FXuint getListStyle() const;
-
-  /// Change list style
-  void setListStyle(FXuint style);
-
-  /// Change help text
-  void setHelpText(const FXString& txt);
-
-  /// Return help text
-  const FXString& getHelpText() const;
-
-  /// Change tip text
-  void setTipText(const FXString& txt);
-
-  /// Return tip text
-  const FXString& getTipText() const;
-
-  /// Save object to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load object from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXTreeListBox();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXTriStateButton.h b/fox-includes/FXTriStateButton.h
deleted file mode 100755
index 27192082..00000000
--- a/fox-includes/FXTriStateButton.h
+++ /dev/null
@@ -1,112 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*               T r i - S t a t e    B u t t o n    W i d g e t                 *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2002 by Charles Warren.   All Rights Reserved.                  *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXTriStateButton.h 1166 2002-12-19 18:11:19Z lyle $                   *
-********************************************************************************/
-#ifndef FXTRISTATEBUTTON_H
-#define FXTRISTATEBUTTON_H
-
-#ifndef FXTOGGLEBUTTON_H
-#include "FXToggleButton.h"
-#endif
-
-
-namespace FX {
-
-/**
-* The tri-state button provides a three-state button, which toggles between the
-* on and the off state each time it is pressed; programmatically, it may also be
-* switched into the MAYBE state.  The MAYBE state is useful to signify an unknown
-* state in the application data.
-* Like the toggle button, it sends a SEL_COMMAND to its target, with the
-* message data set to the current state of the toggle button, of the type FXbool.
-*/
-class FXAPI FXTriStateButton : public FXToggleButton {
-  FXDECLARE(FXTriStateButton)
-protected:
-  FXString  maybelabel;
-  FXIcon   *maybeicon;
-  FXString  maybetip;
-  FXString  maybehelp;
-protected:
-  FXTriStateButton();
-private:
-  FXTriStateButton(const FXTriStateButton&);
-  FXTriStateButton& operator=(const FXTriStateButton&);
-public:
-  long onPaint(FXObject*,FXSelector,void*);
-  long onUnknown(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-public:
-
-  /// Construct tri-state toggle button with three text labels, and three icons, one for each state
-  FXTriStateButton(FXComposite* p,const FXString& text1,const FXString& text2,const FXString& text3,FXIcon* icon1=NULL,FXIcon* icon2=NULL,FXIcon* icon3=NULL,FXObject* tgt=NULL,FXSelector sel=0,FXuint opts=TOGGLEBUTTON_NORMAL,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_PAD,FXint pr=DEFAULT_PAD,FXint pt=DEFAULT_PAD,FXint pb=DEFAULT_PAD);
-
-  /// Create server-side resources
-  virtual void create();
-
-  /// Detach server-side resources
-  virtual void detach();
-
-  /// Get default width
-  virtual FXint getDefaultWidth();
-
-  /// Get default height
-  virtual FXint getDefaultHeight();
-
-  /// Change maybe text shown when toggled
-  void setMaybeText(const FXString& text);
-
-  /// Return maybe text
-  FXString getMaybeText() const { return maybelabel; }
-
-  /// Change maybe icon shown when toggled
-  void setMaybeIcon(FXIcon* ic);
-
-  /// Return maybe icon
-  FXIcon* getMaybeIcon() const { return maybeicon; }
-
-  /// Change maybe help text shown when toggled
-  void setMaybeHelpText(const FXString& text);
-
-  /// Return maybe help text
-  FXString getMaybeHelpText() const { return maybehelp; }
-
-  /// Change maybe tip text shown when toggled
-  void setMaybeTipText(const FXString& text);
-
-  /// Return maybe tip text
-  FXString getMaybeTipText() const { return maybetip; }
-
-  /// Save toggle button to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load toggle button from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXTriStateButton();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXURL.h b/fox-includes/FXURL.h
deleted file mode 100755
index fefbb935..00000000
--- a/fox-includes/FXURL.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                       U R L   M a n i p u l a t i o n                         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2000,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXURL.h 2343 2006-02-12 20:26:26Z lyle $                             *
-********************************************************************************/
-#ifndef FXURL_H
-#define FXURL_H
-
-namespace FX {
-
-namespace FXURL {
-
-/// Return host name
-extern FXAPI FXString hostname();
-
-/// Return URL of filename
-extern FXAPI FXString fileToURL(const FXString& file);
-
-/// Return filename from URL, empty if url is not a local file
-extern FXAPI FXString fileFromURL(const FXString& url);
-
-/// Decode url string
-extern FXAPI FXString decode(const FXString& url);
-
-/// Encode url string
-extern FXAPI FXString encode(const FXString& url);
-
-}
-
-}
-
-#endif
diff --git a/fox-includes/FXUTF16Codec.h b/fox-includes/FXUTF16Codec.h
deleted file mode 100755
index 045a6c1b..00000000
--- a/fox-includes/FXUTF16Codec.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                      U T F - 1 6  T e x t   C o d e c                         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2002,2006 by L.Johnson & J.van der Zijp.  All Rights Reserved.  *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXUTF16Codec.h 2401 2006-04-27 00:46:49Z lyle $                       *
-********************************************************************************/
-#ifndef FXUTF16CODEC_H
-#define FXUTF16CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-
-namespace FX {
-
-/// Codec for UTF-16BE
-class FXAPI FXUTF16BECodec : public FXTextCodec {
-  FXDECLARE(FXUTF16BECodec)
-public:
-  FXUTF16BECodec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXUTF16BECodec(){}
-  };
-
-
-/// Codec for UTF-16LE
-class FXAPI FXUTF16LECodec : public FXTextCodec {
-  FXDECLARE(FXUTF16LECodec)
-public:
-  FXUTF16LECodec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXUTF16LECodec(){}
-  };
-
-
-/// Codec for UTF-16
-class FXAPI FXUTF16Codec : public FXTextCodec {
-  FXDECLARE(FXUTF16Codec)
-public:
-  FXUTF16Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint mb2utflen(const FXchar* src,FXint nsrc) const;
-  virtual FXint mb2utf(FXchar* dst,FXint ndst,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint utf2mblen(const FXchar* src,FXint nsrc) const;
-  virtual FXint utf2mb(FXchar* dst,FXint ndst,const FXchar* src,FXint nsrc) const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXUTF16Codec(){}
-  };
-
-}
-
-#endif
-
diff --git a/fox-includes/FXUTF32Codec.h b/fox-includes/FXUTF32Codec.h
deleted file mode 100755
index 3963bc9f..00000000
--- a/fox-includes/FXUTF32Codec.h
+++ /dev/null
@@ -1,87 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                      U T F - 3 2  T e x t   C o d e c                         *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2002,2006 by L.Johnson & J.van der Zijp.  All Rights Reserved.  *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXUTF32Codec.h 2401 2006-04-27 00:46:49Z lyle $                       *
-********************************************************************************/
-#ifndef FXUTF32CODEC_H
-#define FXUTF32CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-
-namespace FX {
-
-
-/// Codec for UTF-32BE
-class FXAPI FXUTF32BECodec : public FXTextCodec {
-  FXDECLARE(FXUTF32BECodec)
-public:
-  FXUTF32BECodec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXUTF32BECodec(){}
-  };
-
-
-/// Codec for UTF-32LE
-class FXAPI FXUTF32LECodec : public FXTextCodec {
-  FXDECLARE(FXUTF32LECodec)
-public:
-  FXUTF32LECodec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXUTF32LECodec(){}
-  };
-
-
-/// Codec for UTF-32
-class FXAPI FXUTF32Codec : public FXTextCodec {
-  FXDECLARE(FXUTF32Codec)
-public:
-  FXUTF32Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint mb2utflen(const FXchar* src,FXint nsrc) const;
-  virtual FXint mb2utf(FXchar* dst,FXint ndst,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual FXint utf2mblen(const FXchar* src,FXint nsrc) const;
-  virtual FXint utf2mb(FXchar* dst,FXint ndst,const FXchar* src,FXint nsrc) const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXUTF32Codec(){}
-  };
-
-
-}
-
-#endif
-
diff --git a/fox-includes/FXUTF8Codec.h b/fox-includes/FXUTF8Codec.h
deleted file mode 100755
index 0434506d..00000000
--- a/fox-includes/FXUTF8Codec.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                      U T F - 8  T e x t   C o d e c                           *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2002,2006 by L.Johnson & J.van der Zijp.  All Rights Reserved.  *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXUTF8Codec.h 2401 2006-04-27 00:46:49Z lyle $                       *
-********************************************************************************/
-#ifndef FXUTF8CODEC_H
-#define FXUTF8CODEC_H
-
-#ifndef FXTEXTCODEC_H
-#include "FXTextCodec.h"
-#endif
-
-
-namespace FX {
-
-/// Codec for UTF-8
-class FXAPI FXUTF8Codec : public FXTextCodec {
-public:
-  FXUTF8Codec(){}
-  virtual FXint mb2wc(FXwchar& wc,const FXchar* src,FXint nsrc) const;
-  virtual FXint wc2mb(FXchar* dst,FXint ndst,FXwchar wc) const;
-  virtual const FXchar* name() const;
-  virtual const FXchar* mimeName() const;
-  virtual FXint mibEnum() const;
-  virtual const FXchar* const* aliases() const;
-  virtual ~FXUTF8Codec(){}
-  };
-
-}
-
-#endif
-
diff --git a/fox-includes/FXUndoList.h b/fox-includes/FXUndoList.h
deleted file mode 100755
index f137f029..00000000
--- a/fox-includes/FXUndoList.h
+++ /dev/null
@@ -1,338 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                  U n d o / R e d o - a b l e   C o m m a n d                  *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2000,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXUndoList.h 2346 2006-02-14 03:26:11Z lyle $                        *
-********************************************************************************/
-#ifndef FXUNDOLIST_H
-#define FXUNDOLIST_H
-
-#ifndef FXOBJECT_H
-#include "FXObject.h"
-#endif
-
-namespace FX {
-
-
-class FXUndoList;
-class FXCommandGroup;
-
-
-/**
-* Base class for undoable commands.  Each undo records all the
-* information necessary to undo as well as redo a given operation.
-* Since commands are derived from FXObject, subclassed commands can
-* both send and receive messages (like ID_GETINTVALUE, for example).
-*/
-class FXAPI FXCommand : public FXObject {
-  FXDECLARE_ABSTRACT(FXCommand)
-  friend class FXUndoList;
-  friend class FXCommandGroup;
-private:
-  FXCommand *next;
-private:
-  FXCommand(const FXCommand&);
-  FXCommand &operator=(const FXCommand&);
-protected:
-  FXCommand():next(NULL){}
-public:
-
-  /**
-  * Undo this command; this should save the
-  * information for a subsequent redo.
-  */
-  virtual void undo() = 0;
-
-  /**
-  * Redo this command; this should save the
-  * information for a subsequent undo.
-  */
-  virtual void redo() = 0;
-
-  /**
-  * Return the size of the information in the undo record.
-  * The undo list may be trimmed to limit memory usage to
-  * a certain limit.  The value returned should include
-  * the size of the command record itself as well as any
-  * data linked from it.
-  */
-  virtual FXuint size() const;
-
-  /**
-  * Name of the undo command to be shown on a button;
-  * for example, "Undo Delete".
-  */
-  virtual FXString undoName() const;
-
-  /**
-  * Name of the redo command to be shown on a button;
-  * for example, "Redo Delete".
-  */
-  virtual FXString redoName() const;
-
-  /**
-  * Return TRUE if this command can be merged with previous undo
-  * commands.  This is useful to combine e.g. multiple consecutive
-  * single-character text changes into a single block change.
-  * The default implementation returns FALSE.
-  */
-  virtual bool canMerge() const;
-
-  /**
-  * Called by the undo system to try and merge the new incoming command
-  * with this command; should return TRUE if merging was possible.
-  * The default implementation returns FALSE.
-  */
-  virtual bool mergeWith(FXCommand* command);
-
-  /// Delete undo command
-  virtual ~FXCommand(){}
-  };
-
-
-
-/**
-* Group of undoable commands.  A group may comprise multiple
-* individual actions which together undo (or redo) a larger
-* operation.  Even larger operations may be built by nesting
-* multiple undo groups.
-*/
-class FXAPI FXCommandGroup : public FXCommand {
-  FXDECLARE(FXCommandGroup)
-  friend class FXUndoList;
-private:
-  FXCommand      *undolist;
-  FXCommand      *redolist;
-  FXCommandGroup *group;
-private:
-  FXCommandGroup(const FXCommandGroup&);
-  FXCommandGroup &operator=(const FXCommandGroup&);
-public:
-
-  /// Construct initially empty undo command group
-  FXCommandGroup():undolist(NULL),redolist(NULL),group(NULL){}
-
-  /// Return TRUE if empty
-  bool empty(){ return !undolist; }
-
-  /// Undo whole command group
-  virtual void undo();
-
-  /// Redo whole command group
-  virtual void redo();
-
-  /// Return the size of the command group
-  virtual FXuint size() const;
-
-  /// Delete undo command and sub-commands
-  virtual ~FXCommandGroup();
-  };
-
-
-
-/**
-* The Undo List class manages a list of undoable commands.
-*/
-class FXAPI FXUndoList : public FXCommandGroup {
-  FXDECLARE(FXUndoList)
-private:
-  FXint      undocount;     // Number of undo records
-  FXint      redocount;     // Number of redo records
-  FXint      marker;        // Marker value
-  FXuint     space;         // Space taken up by all the undo records
-  bool       working;       // Currently busy with undo or redo
-private:
-  FXUndoList(const FXUndoList&);
-  FXUndoList &operator=(const FXUndoList&);
-public:
-  long onCmdUndo(FXObject*,FXSelector,void*);
-  long onUpdUndo(FXObject*,FXSelector,void*);
-  long onCmdRedo(FXObject*,FXSelector,void*);
-  long onUpdRedo(FXObject*,FXSelector,void*);
-  long onCmdClear(FXObject*,FXSelector,void*);
-  long onUpdClear(FXObject*,FXSelector,void*);
-  long onCmdRevert(FXObject*,FXSelector,void*);
-  long onUpdRevert(FXObject*,FXSelector,void*);
-  long onCmdUndoAll(FXObject*,FXSelector,void*);
-  long onCmdRedoAll(FXObject*,FXSelector,void*);
-  long onUpdUndoCount(FXObject*,FXSelector,void*);
-  long onUpdRedoCount(FXObject*,FXSelector,void*);
-public:
-  enum{
-    ID_CLEAR=FXWindow::ID_LAST,
-    ID_REVERT,
-    ID_UNDO,
-    ID_REDO,
-    ID_UNDO_ALL,
-    ID_REDO_ALL,
-    ID_UNDO_COUNT,
-    ID_REDO_COUNT,
-    ID_LAST
-    };
-public:
-
-  /**
-  * Make new empty undo list, initially unmarked.
-  */
-  FXUndoList();
-
-  /**
-  * Cut the redo list.
-  * This is automatically invoked when a new undo command is added.
-  */
-  void cut();
-
-  /**
-  * Add new command, executing it if desired. The new command will be merged
-  * with the previous command if merge is TRUE and we're not at a marked position
-  * and the commands are mergeable.  Otherwise the new command will be appended
-  * after the last undo command in the currently active undo group.
-  * If the new command is successfully merged, it will be deleted.  Furthermore,
-  * all redo commands will be deleted since it is no longer possible to redo
-  * from this point.
-  */
-  void add(FXCommand* command,bool doit=false,bool merge=true);
-
-  /**
-  * Begin undo command sub-group. This begins a new group of commands that
-  * are treated as a single command.  Must eventually be followed by a
-  * matching end() after recording the sub-commands.  The new sub-group
-  * will be appended to its parent group's undo list when end() is called.
-  */
-  void begin(FXCommandGroup *command);
-
-  /**
-  * End undo command sub-group.  If the sub-group is still empty, it will
-  * be deleted; otherwise, the sub-group will be added as a new command
-  * into parent group.
-  * A matching begin() must have been called previously.
-  */
-  void end();
-
-  /**
-  * Abort the current command sub-group being compiled.  All commands
-  * already added to the sub-groups undo list will be discarded.
-  * Intermediate command groups will be left intact.
-  */
-  void abort();
-
-  /**
-  * Undo last command. This will move the command to the redo list.
-  */
-  virtual void undo();
-
-  /**
-  * Redo next command. This will move the command back to the undo list.
-  */
-  virtual void redo();
-
-  /// Undo all commands
-  void undoAll();
-
-  /// Redo all commands
-  void redoAll();
-
-  /// Revert to marked
-  void revert();
-
-  /// Can we undo more commands
-  bool canUndo() const;
-
-  /// Can we redo more commands
-  bool canRedo() const;
-
-  /// Can revert to marked
-  bool canRevert() const;
-
-  /**
-  * Return TRUE if currently inside undo or redo operation; this
-  * is useful to avoid generating another undo command while inside
-  * an undo operation.
-  */
-  bool busy() const { return working; }
-
-  /// Current top level undo command
-  FXCommand* current() const { return undolist; }
-
-  /**
-  * Return name of the first undo command available; if no
-  * undo command available this will return the empty string.
-  */
-  virtual FXString undoName() const;
-
-  /**
-  * Return name of the first redo command available; if no
-  * Redo command available this will return the empty string.
-  */
-  virtual FXString redoName() const;
-
-  /// Number of undo records
-  FXint undoCount() const { return undocount; }
-
-  /// Number of redo records
-  FXint redoCount() const { return redocount; }
-
-  /// Size of undo information
-  virtual FXuint size() const;
-
-  /**
-  * Clear list, and unmark all states.
-  * All undo and redo information will be destroyed.
-  */
-  void clear();
-
-  /**
-  * Trim undo list down to at most nc commands.
-  * Call this periodically to prevent the undo-list from growing
-  * beyond a certain number of records.
-  */
-  void trimCount(FXint nc);
-
-  /**
-  * Trim undo list down to at most size sz.
-  * Call this periodically to prevent the undo-list from growing
-  * beyond a certain amount of memory.
-  */
-  void trimSize(FXuint sz);
-
-  /**
-  * Mark the current state of the undo list, which is initially unmarked.
-  * There can be only one active mark at any time.  Call mark() at any
-  * time when you know the document to be "clean"; for example when you
-  * save the document to disk.
-  */
-  void mark();
-
-  /**
-  * Unmark all states in the undo list.
-  */
-  void unmark();
-
-  /**
-  * Check if the current state was marked, if the application has returned
-  * to the previously marked state.
-  */
-  bool marked() const;
-  };
-
-
-}
-
-#endif
diff --git a/fox-includes/FXVec2d.h b/fox-includes/FXVec2d.h
deleted file mode 100755
index 2ef56f00..00000000
--- a/fox-includes/FXVec2d.h
+++ /dev/null
@@ -1,184 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*       D o u b l e - P r e c i s i o n   2 - E l e m e n t   V e c t o r       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1994,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXVec2d.h 2346 2006-02-14 03:26:11Z lyle $                           *
-********************************************************************************/
-#ifndef FXVEC2D_H
-#define FXVEC2D_H
-
-
-namespace FX {
-
-
-class FXMat3d;
-
-
-/// Double-precision 2-element vector
-class FXAPI FXVec2d {
-public:
-  FXdouble x;
-  FXdouble y;
-public:
-
-  /// Default constructor
-  FXVec2d(){}
-
-  /// Initialize from another vector
-  FXVec2d(const FXVec2d& v){x=v.x;y=v.y;}
-
-  /// Initialize from array of floats
-  FXVec2d(const FXdouble v[]){x=v[0];y=v[1];}
-
-  /// Initialize from components
-  FXVec2d(FXdouble xx,FXdouble yy){x=xx;y=yy;}
-
-  /// Return a non-const reference to the ith element
-  FXdouble& operator[](FXint i){return (&x)[i];}
-
-  /// Return a const reference to the ith element
-  const FXdouble& operator[](FXint i) const {return (&x)[i];}
-
-  /// Assignment
-  FXVec2d& operator=(const FXVec2d& v){x=v.x;y=v.y;return *this;}
-
-  /// Assignment from array of floats
-  FXVec2d& operator=(const FXdouble v[]){x=v[0];y=v[1];return *this;}
-
-  /// Set value from another vector
-  FXVec2d& set(const FXVec2d& v){x=v.x;y=v.y;return *this;}
-
-  /// Set value from array of floats
-  FXVec2d& set(const FXdouble v[]){x=v[0];y=v[1];return *this;}
-
-  /// Set value from components
-  FXVec2d& set(FXdouble xx,FXdouble yy){x=xx;y=yy;return *this;}
-
-  /// Assigning operators
-  FXVec2d& operator*=(FXdouble n){x*=n;y*=n;return *this;}
-  FXVec2d& operator/=(FXdouble n){x/=n;y/=n;return *this;}
-  FXVec2d& operator+=(const FXVec2d& v){x+=v.x;y+=v.y;return *this;}
-  FXVec2d& operator-=(const FXVec2d& v){x-=v.x;y-=v.y;return *this;}
-
-  /// Conversions
-  operator FXdouble*(){return &x;}
-  operator const FXdouble*() const {return &x;}
-
-  /// Unary
-  FXVec2d operator+() const { return *this; }
-  FXVec2d operator-() const { return FXVec2d(-x,-y); }
-
-  /// Vector and vector
-  FXVec2d operator+(const FXVec2d& v) const { return FXVec2d(x+v.x,y+v.y); }
-  FXVec2d operator-(const FXVec2d& v) const { return FXVec2d(x-v.x,y-v.y); }
-
-  /// Vector and matrix
-  FXVec2d operator*(const FXMat3d& m) const;
-
-  /// Scaling
-  friend inline FXVec2d operator*(const FXVec2d& a,FXdouble n);
-  friend inline FXVec2d operator*(FXdouble n,const FXVec2d& a);
-  friend inline FXVec2d operator/(const FXVec2d& a,FXdouble n);
-  friend inline FXVec2d operator/(FXdouble n,const FXVec2d& a);
-
-  /// Dot product
-  FXdouble operator*(const FXVec2d& v) const { return x*v.x+y*v.y; }
-
-  /// Test if zero
-  bool operator!() const { return x==0.0 && y==0.0;}
-
-  /// Equality tests
-  bool operator==(const FXVec2d& v) const { return x==v.x && y==v.y; }
-  bool operator!=(const FXVec2d& v) const { return x!=v.x || y!=v.y; }
-
-  friend inline bool operator==(const FXVec2d& a,FXdouble n);
-  friend inline bool operator!=(const FXVec2d& a,FXdouble n);
-  friend inline bool operator==(FXdouble n,const FXVec2d& a);
-  friend inline bool operator!=(FXdouble n,const FXVec2d& a);
-
-  /// Inequality tests
-  bool operator<(const FXVec2d& v) const { return x<v.x && y<v.y; }
-  bool operator<=(const FXVec2d& v) const { return x<=v.x && y<=v.y; }
-  bool operator>(const FXVec2d& v) const { return x>v.x && y>v.y; }
-  bool operator>=(const FXVec2d& v) const { return x>=v.x && y>=v.y; }
-
-  friend inline bool operator<(const FXVec2d& a,FXdouble n);
-  friend inline bool operator<=(const FXVec2d& a,FXdouble n);
-  friend inline bool operator>(const FXVec2d& a,FXdouble n);
-  friend inline bool operator>=(const FXVec2d& a,FXdouble n);
-
-  friend inline bool operator<(FXdouble n,const FXVec2d& a);
-  friend inline bool operator<=(FXdouble n,const FXVec2d& a);
-  friend inline bool operator>(FXdouble n,const FXVec2d& a);
-  friend inline bool operator>=(FXdouble n,const FXVec2d& a);
-
-  /// Length and square of length
-  FXdouble length2() const { return x*x+y*y; }
-  FXdouble length() const { return sqrt(length2()); }
-
-  /// Clamp values of vector between limits
-  FXVec2d& clamp(FXdouble lo,FXdouble hi){x=FXCLAMP(lo,x,hi);y=FXCLAMP(lo,y,hi);return *this;}
-
-  /// Lowest or highest components
-  friend inline FXVec2d lo(const FXVec2d& a,const FXVec2d& b);
-  friend inline FXVec2d hi(const FXVec2d& a,const FXVec2d& b);
-
-  /// Normalize vector
-  friend FXAPI FXVec2d normalize(const FXVec2d& v);
-
-  /// Save vector to a stream
-  friend FXAPI FXStream& operator<<(FXStream& store,const FXVec2d& v);
-
-  /// Load vector from a stream
-  friend FXAPI FXStream& operator>>(FXStream& store,FXVec2d& v);
-  };
-
-
-inline FXVec2d operator*(const FXVec2d& a,FXdouble n){return FXVec2d(a.x*n,a.y*n);}
-inline FXVec2d operator*(FXdouble n,const FXVec2d& a){return FXVec2d(n*a.x,n*a.y);}
-inline FXVec2d operator/(const FXVec2d& a,FXdouble n){return FXVec2d(a.x/n,a.y/n);}
-inline FXVec2d operator/(FXdouble n,const FXVec2d& a){return FXVec2d(n/a.x,n/a.y);}
-
-inline bool operator==(const FXVec2d& a,FXdouble n){return a.x==n && a.y==n;}
-inline bool operator!=(const FXVec2d& a,FXdouble n){return a.x!=n || a.y!=n;}
-inline bool operator==(FXdouble n,const FXVec2d& a){return n==a.x && n==a.y;}
-inline bool operator!=(FXdouble n,const FXVec2d& a){return n!=a.x || n!=a.y;}
-
-inline bool operator<(const FXVec2d& a,FXdouble n){return a.x<n && a.y<n;}
-inline bool operator<=(const FXVec2d& a,FXdouble n){return a.x<=n && a.y<=n;}
-inline bool operator>(const FXVec2d& a,FXdouble n){return a.x>n && a.y>n;}
-inline bool operator>=(const FXVec2d& a,FXdouble n){return a.x>=n && a.y>=n;}
-
-inline bool operator<(FXdouble n,const FXVec2d& a){return n<a.x && n<a.y;}
-inline bool operator<=(FXdouble n,const FXVec2d& a){return n<=a.x && n<=a.y;}
-inline bool operator>(FXdouble n,const FXVec2d& a){return n>a.x && n>a.y;}
-inline bool operator>=(FXdouble n,const FXVec2d& a){return n>=a.x && n>=a.y;}
-
-inline FXVec2d lo(const FXVec2d& a,const FXVec2d& b){return FXVec2d(FXMIN(a.x,b.x),FXMIN(a.y,b.y));}
-inline FXVec2d hi(const FXVec2d& a,const FXVec2d& b){return FXVec2d(FXMAX(a.x,b.x),FXMAX(a.y,b.y));}
-
-extern FXAPI FXVec2d normalize(const FXVec2d& v);
-
-extern FXAPI FXStream& operator<<(FXStream& store,const FXVec2d& v);
-extern FXAPI FXStream& operator>>(FXStream& store,FXVec2d& v);
-
-}
-
-#endif
diff --git a/fox-includes/FXVec2f.h b/fox-includes/FXVec2f.h
deleted file mode 100755
index 199c58a4..00000000
--- a/fox-includes/FXVec2f.h
+++ /dev/null
@@ -1,184 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*       S i n g l e - P r e c i s i o n   2 - E l e m e n t   V e c t o r       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1994,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXVec2f.h 2346 2006-02-14 03:26:11Z lyle $                           *
-********************************************************************************/
-#ifndef FXVEC2F_H
-#define FXVEC2F_H
-
-
-namespace FX {
-
-
-class FXMat3f;
-
-
-/// Single-precision 2-element vector
-class FXAPI FXVec2f {
-public:
-  FXfloat x;
-  FXfloat y;
-public:
-
-  /// Default constructor
-  FXVec2f(){}
-
-  /// Initialize from another vector
-  FXVec2f(const FXVec2f& v){x=v.x;y=v.y;}
-
-  /// Initialize from array of floats
-  FXVec2f(const FXfloat v[]){x=v[0];y=v[1];}
-
-  /// Initialize from components
-  FXVec2f(FXfloat xx,FXfloat yy){x=xx;y=yy;}
-
-  /// Return a non-const reference to the ith element
-  FXfloat& operator[](FXint i){return (&x)[i];}
-
-  /// Return a const reference to the ith element
-  const FXfloat& operator[](FXint i) const {return (&x)[i];}
-
-  /// Assignment
-  FXVec2f& operator=(const FXVec2f& v){x=v.x;y=v.y;return *this;}
-
-  /// Assignment from array of floats
-  FXVec2f& operator=(const FXfloat v[]){x=v[0];y=v[1];return *this;}
-
-  /// Set value from another vector
-  FXVec2f& set(const FXVec2f& v){x=v.x;y=v.y;return *this;}
-
-  /// Set value from array of floats
-  FXVec2f& set(const FXfloat v[]){x=v[0];y=v[1];return *this;}
-
-  /// Set value from components
-  FXVec2f& set(FXfloat xx,FXfloat yy){x=xx;y=yy;return *this;}
-
-  /// Assigning operators
-  FXVec2f& operator*=(FXfloat n){x*=n;y*=n;return *this;}
-  FXVec2f& operator/=(FXfloat n){x/=n;y/=n;return *this;}
-  FXVec2f& operator+=(const FXVec2f& v){x+=v.x;y+=v.y;return *this;}
-  FXVec2f& operator-=(const FXVec2f& v){x-=v.x;y-=v.y;return *this;}
-
-  /// Conversions
-  operator FXfloat*(){return &x;}
-  operator const FXfloat*() const {return &x;}
-
-  /// Unary
-  FXVec2f operator+() const { return *this; }
-  FXVec2f operator-() const { return FXVec2f(-x,-y); }
-
-  /// Vector and vector
-  FXVec2f operator+(const FXVec2f& v) const { return FXVec2f(x+v.x,y+v.y); }
-  FXVec2f operator-(const FXVec2f& v) const { return FXVec2f(x-v.x,y-v.y); }
-
-  /// Vector and matrix
-  FXVec2f operator*(const FXMat3f& m) const;
-
-  /// Scaling
-  friend inline FXVec2f operator*(const FXVec2f& a,FXfloat n);
-  friend inline FXVec2f operator*(FXfloat n,const FXVec2f& a);
-  friend inline FXVec2f operator/(const FXVec2f& a,FXfloat n);
-  friend inline FXVec2f operator/(FXfloat n,const FXVec2f& a);
-
-  /// Dot product
-  FXfloat operator*(const FXVec2f& v) const { return x*v.x+y*v.y; }
-
-  /// Test if zero
-  bool operator!() const { return x==0.0f && y==0.0f; }
-
-  /// Equality tests
-  bool operator==(const FXVec2f& v) const { return x==v.x && y==v.y; }
-  bool operator!=(const FXVec2f& v) const { return x!=v.x || y!=v.y; }
-
-  friend inline bool operator==(const FXVec2f& a,FXfloat n);
-  friend inline bool operator!=(const FXVec2f& a,FXfloat n);
-  friend inline bool operator==(FXfloat n,const FXVec2f& a);
-  friend inline bool operator!=(FXfloat n,const FXVec2f& a);
-
-  /// Inequality tests
-  bool operator<(const FXVec2f& v) const { return x<v.x && y<v.y; }
-  bool operator<=(const FXVec2f& v) const { return x<=v.x && y<=v.y; }
-  bool operator>(const FXVec2f& v) const { return x>v.x && y>v.y; }
-  bool operator>=(const FXVec2f& v) const { return x>=v.x && y>=v.y; }
-
-  friend inline bool operator<(const FXVec2f& a,FXfloat n);
-  friend inline bool operator<=(const FXVec2f& a,FXfloat n);
-  friend inline bool operator>(const FXVec2f& a,FXfloat n);
-  friend inline bool operator>=(const FXVec2f& a,FXfloat n);
-
-  friend inline bool operator<(FXfloat n,const FXVec2f& a);
-  friend inline bool operator<=(FXfloat n,const FXVec2f& a);
-  friend inline bool operator>(FXfloat n,const FXVec2f& a);
-  friend inline bool operator>=(FXfloat n,const FXVec2f& a);
-
-  /// Length and square of length
-  FXfloat length2() const { return x*x+y*y; }
-  FXfloat length() const { return sqrtf(length2()); }
-
-  /// Clamp values of vector between limits
-  FXVec2f& clamp(FXfloat lo,FXfloat hi){x=FXCLAMP(lo,x,hi);y=FXCLAMP(lo,y,hi);return *this;}
-
-  /// Lowest or highest components
-  friend inline FXVec2f lo(const FXVec2f& a,const FXVec2f& b);
-  friend inline FXVec2f hi(const FXVec2f& a,const FXVec2f& b);
-
-  /// Normalize vector
-  friend FXAPI FXVec2f normalize(const FXVec2f& v);
-
-  /// Save vector to a stream
-  friend FXAPI FXStream& operator<<(FXStream& store,const FXVec2f& v);
-
-  /// Load vector from a stream
-  friend FXAPI FXStream& operator>>(FXStream& store,FXVec2f& v);
-  };
-
-
-inline FXVec2f operator*(const FXVec2f& a,FXfloat n){return FXVec2f(a.x*n,a.y*n);}
-inline FXVec2f operator*(FXfloat n,const FXVec2f& a){return FXVec2f(n*a.x,n*a.y);}
-inline FXVec2f operator/(const FXVec2f& a,FXfloat n){return FXVec2f(a.x/n,a.y/n);}
-inline FXVec2f operator/(FXfloat n,const FXVec2f& a){return FXVec2f(n/a.x,n/a.y);}
-
-inline bool operator==(const FXVec2f& a,FXfloat n){return a.x==n && a.y==n;}
-inline bool operator!=(const FXVec2f& a,FXfloat n){return a.x!=n || a.y!=n;}
-inline bool operator==(FXfloat n,const FXVec2f& a){return n==a.x && n==a.y;}
-inline bool operator!=(FXfloat n,const FXVec2f& a){return n!=a.x || n!=a.y;}
-
-inline bool operator<(const FXVec2f& a,FXfloat n){return a.x<n && a.y<n;}
-inline bool operator<=(const FXVec2f& a,FXfloat n){return a.x<=n && a.y<=n;}
-inline bool operator>(const FXVec2f& a,FXfloat n){return a.x>n && a.y>n;}
-inline bool operator>=(const FXVec2f& a,FXfloat n){return a.x>=n && a.y>=n;}
-
-inline bool operator<(FXfloat n,const FXVec2f& a){return n<a.x && n<a.y;}
-inline bool operator<=(FXfloat n,const FXVec2f& a){return n<=a.x && n<=a.y;}
-inline bool operator>(FXfloat n,const FXVec2f& a){return n>a.x && n>a.y;}
-inline bool operator>=(FXfloat n,const FXVec2f& a){return n>=a.x && n>=a.y;}
-
-inline FXVec2f lo(const FXVec2f& a,const FXVec2f& b){return FXVec2f(FXMIN(a.x,b.x),FXMIN(a.y,b.y));}
-inline FXVec2f hi(const FXVec2f& a,const FXVec2f& b){return FXVec2f(FXMAX(a.x,b.x),FXMAX(a.y,b.y));}
-
-extern FXAPI FXVec2f normalize(const FXVec2f& v);
-
-extern FXAPI FXStream& operator<<(FXStream& store,const FXVec2f& v);
-extern FXAPI FXStream& operator>>(FXStream& store,FXVec2f& v);
-
-}
-
-#endif
diff --git a/fox-includes/FXVec3d.h b/fox-includes/FXVec3d.h
deleted file mode 100755
index 5a0ec8ad..00000000
--- a/fox-includes/FXVec3d.h
+++ /dev/null
@@ -1,210 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*       D o u b l e - P r e c i s i o n   3 - E l e m e n t   V e c t o r       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1994,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXVec3d.h 2346 2006-02-14 03:26:11Z lyle $                           *
-********************************************************************************/
-#ifndef FXVEC3D_H
-#define FXVEC3D_H
-
-
-namespace FX {
-
-
-class FXMat3d;
-class FXMat4d;
-
-
-/// Double-precision 3-element vector
-class FXAPI FXVec3d {
-public:
-  FXdouble x;
-  FXdouble y;
-  FXdouble z;
-public:
-
-  /// Default constructor
-  FXVec3d(){}
-
-  /// Initialize from another vector
-  FXVec3d(const FXVec3d& v){x=v.x;y=v.y;z=v.z;}
-
-  /// Initialize from array of doubles
-  FXVec3d(const FXdouble v[]){x=v[0];y=v[1];z=v[2];}
-
-  /// Initialize with components
-  FXVec3d(FXdouble xx,FXdouble yy,FXdouble zz=1.0){x=xx;y=yy;z=zz;}
-
-  /// Initialize with color
-  FXVec3d(FXColor color);
-
-  /// Return a non-const reference to the ith element
-  FXdouble& operator[](FXint i){return (&x)[i];}
-
-  /// Return a const reference to the ith element
-  const FXdouble& operator[](FXint i) const {return (&x)[i];}
-
-  /// Assign color
-  FXVec3d& operator=(FXColor color);
-
-  /// Assignment
-  FXVec3d& operator=(const FXVec3d& v){x=v.x;y=v.y;z=v.z;return *this;}
-
-  /// Assignment from array of doubles
-  FXVec3d& operator=(const FXdouble v[]){x=v[0];y=v[1];z=v[2];return *this;}
-
-  /// Set value from another vector
-  FXVec3d& set(const FXVec3d& v){x=v.x;y=v.y;z=v.z;return *this;}
-
-  /// Set value from array of floats
-  FXVec3d& set(const FXdouble v[]){x=v[0];y=v[1];z=v[2];return *this;}
-
-  /// Set value from components
-  FXVec3d& set(FXdouble xx,FXdouble yy,FXdouble zz){x=xx;y=yy;z=zz;return *this;}
-
-  /// Assigning operators
-  FXVec3d& operator*=(FXdouble n){x*=n;y*=n;z*=n;return *this;}
-  FXVec3d& operator/=(FXdouble n){x/=n;y/=n;z/=n;return *this;}
-  FXVec3d& operator+=(const FXVec3d& v){x+=v.x;y+=v.y;z+=v.z;return *this;}
-  FXVec3d& operator-=(const FXVec3d& v){x-=v.x;y-=v.y;z-=v.z;return *this;}
-
-  /// Conversions
-  operator FXdouble*(){return &x;}
-  operator const FXdouble*() const {return &x;}
-  operator FXVec2d&(){return *reinterpret_cast<FXVec2d*>(this);}
-  operator const FXVec2d&() const {return *reinterpret_cast<const FXVec2d*>(this);}
-
-  /// Convert to color
-  operator FXColor() const;
-
-  /// Unary
-  FXVec3d operator+() const { return *this; }
-  FXVec3d operator-() const { return FXVec3d(-x,-y,-z); }
-
-  /// Vector and vector
-  FXVec3d operator+(const FXVec3d& v) const { return FXVec3d(x+v.x,y+v.y,z+v.z); }
-  FXVec3d operator-(const FXVec3d& v) const { return FXVec3d(x-v.x,y-v.y,z-v.z); }
-
-  /// Vector and matrix
-  FXVec3d operator*(const FXMat3d& m) const;
-  FXVec3d operator*(const FXMat4d& m) const;
-
-  /// Scaling
-  friend inline FXVec3d operator*(const FXVec3d& a,FXdouble n);
-  friend inline FXVec3d operator*(FXdouble n,const FXVec3d& a);
-  friend inline FXVec3d operator/(const FXVec3d& a,FXdouble n);
-  friend inline FXVec3d operator/(FXdouble n,const FXVec3d& a);
-
-  /// Dot product
-  FXdouble operator*(const FXVec3d& v) const { return x*v.x+y*v.y+z*v.z; }
-
-  /// Cross product
-  FXVec3d operator^(const FXVec3d& v) const { return FXVec3d(y*v.z-z*v.y, z*v.x-x*v.z, x*v.y-y*v.x); }
-
-  /// Test if zero
-  bool operator!() const { return x==0.0 && y==0.0 && z==0.0; }
-
-  /// Equality tests
-  bool operator==(const FXVec3d& v) const { return x==v.x && y==v.y && z==v.z; }
-  bool operator!=(const FXVec3d& v) const { return x!=v.x || y!=v.y || z!=v.z; }
-
-  friend inline bool operator==(const FXVec3d& a,FXdouble n);
-  friend inline bool operator!=(const FXVec3d& a,FXdouble n);
-  friend inline bool operator==(FXdouble n,const FXVec3d& a);
-  friend inline bool operator!=(FXdouble n,const FXVec3d& a);
-
-  /// Inequality tests
-  bool operator<(const FXVec3d& v) const { return x<v.x && y<v.y && z<v.z; }
-  bool operator<=(const FXVec3d& v) const { return x<=v.x && y<=v.y && z<=v.z; }
-  bool operator>(const FXVec3d& v) const { return x>v.x && y>v.y && z>v.z; }
-  bool operator>=(const FXVec3d& v) const { return x>=v.x && y>=v.y && z>=v.z; }
-
-  friend inline bool operator<(const FXVec3d& a,FXdouble n);
-  friend inline bool operator<=(const FXVec3d& a,FXdouble n);
-  friend inline bool operator>(const FXVec3d& a,FXdouble n);
-  friend inline bool operator>=(const FXVec3d& a,FXdouble n);
-
-  friend inline bool operator<(FXdouble n,const FXVec3d& a);
-  friend inline bool operator<=(FXdouble n,const FXVec3d& a);
-  friend inline bool operator>(FXdouble n,const FXVec3d& a);
-  friend inline bool operator>=(FXdouble n,const FXVec3d& a);
-
-  /// Length and square of length
-  FXdouble length2() const { return x*x+y*y+z*z; }
-  FXdouble length() const { return sqrt(length2()); }
-
-  /// Clamp values of vector between limits
-  FXVec3d& clamp(FXdouble lo,FXdouble hi){x=FXCLAMP(lo,x,hi);y=FXCLAMP(lo,y,hi);z=FXCLAMP(lo,z,hi);return *this;}
-
-  /// Lowest or highest components
-  friend inline FXVec3d lo(const FXVec3d& a,const FXVec3d& b);
-  friend inline FXVec3d hi(const FXVec3d& a,const FXVec3d& b);
-
-  /// Compute normal from three points a,b,c
-  friend FXAPI FXVec3d normal(const FXVec3d& a,const FXVec3d& b,const FXVec3d& c);
-
-  /// Compute approximate normal from four points a,b,c,d
-  friend FXAPI FXVec3d normal(const FXVec3d& a,const FXVec3d& b,const FXVec3d& c,const FXVec3d& d);
-
-  /// Normalize vector
-  friend FXAPI FXVec3d normalize(const FXVec3d& v);
-
-  /// Save vector to a stream
-  friend FXAPI FXStream& operator<<(FXStream& store,const FXVec3d& v);
-
-  /// Load vector from a stream
-  friend FXAPI FXStream& operator>>(FXStream& store,FXVec3d& v);
-  };
-
-
-inline FXVec3d operator*(const FXVec3d& a,FXdouble n){return FXVec3d(a.x*n,a.y*n,a.z*n);}
-inline FXVec3d operator*(FXdouble n,const FXVec3d& a){return FXVec3d(n*a.x,n*a.y,n*a.z);}
-inline FXVec3d operator/(const FXVec3d& a,FXdouble n){return FXVec3d(a.x/n,a.y/n,a.z/n);}
-inline FXVec3d operator/(FXdouble n,const FXVec3d& a){return FXVec3d(n/a.x,n/a.y,n/a.z);}
-
-inline bool operator==(const FXVec3d& a,FXdouble n){return a.x==n && a.y==n && a.z==n;}
-inline bool operator!=(const FXVec3d& a,FXdouble n){return a.x!=n || a.y!=n || a.z!=n;}
-inline bool operator==(FXdouble n,const FXVec3d& a){return n==a.x && n==a.y && n==a.z;}
-inline bool operator!=(FXdouble n,const FXVec3d& a){return n!=a.x || n!=a.y || n!=a.z;}
-
-inline bool operator<(const FXVec3d& a,FXdouble n){return a.x<n && a.y<n && a.z<n;}
-inline bool operator<=(const FXVec3d& a,FXdouble n){return a.x<=n && a.y<=n && a.z<=n;}
-inline bool operator>(const FXVec3d& a,FXdouble n){return a.x>n && a.y>n && a.z>n;}
-inline bool operator>=(const FXVec3d& a,FXdouble n){return a.x>=n && a.y>=n && a.z>=n;}
-
-inline bool operator<(FXdouble n,const FXVec3d& a){return n<a.x && n<a.y && n<a.z;}
-inline bool operator<=(FXdouble n,const FXVec3d& a){return n<=a.x && n<=a.y && n<=a.z;}
-inline bool operator>(FXdouble n,const FXVec3d& a){return n>a.x && n>a.y && n>a.z;}
-inline bool operator>=(FXdouble n,const FXVec3d& a){return n>=a.x && n>=a.y && n>=a.z;}
-
-inline FXVec3d lo(const FXVec3d& a,const FXVec3d& b){return FXVec3d(FXMIN(a.x,b.x),FXMIN(a.y,b.y),FXMIN(a.z,b.z));}
-inline FXVec3d hi(const FXVec3d& a,const FXVec3d& b){return FXVec3d(FXMAX(a.x,b.x),FXMAX(a.y,b.y),FXMAX(a.z,b.z));}
-
-extern FXAPI FXVec3d normal(const FXVec3d& a,const FXVec3d& b,const FXVec3d& c);
-extern FXAPI FXVec3d normal(const FXVec3d& a,const FXVec3d& b,const FXVec3d& c,const FXVec3d& d);
-
-extern FXAPI FXVec3d normalize(const FXVec3d& v);
-
-extern FXAPI FXStream& operator<<(FXStream& store,const FXVec3d& v);
-extern FXAPI FXStream& operator>>(FXStream& store,FXVec3d& v);
-
-}
-
-#endif
diff --git a/fox-includes/FXVec3f.h b/fox-includes/FXVec3f.h
deleted file mode 100755
index 18293a50..00000000
--- a/fox-includes/FXVec3f.h
+++ /dev/null
@@ -1,210 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*       S i n g l e - P r e c i s i o n   3 - E l e m e n t   V e c t o r       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1994,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXVec3f.h 2346 2006-02-14 03:26:11Z lyle $                           *
-********************************************************************************/
-#ifndef FXVEC3F_H
-#define FXVEC3F_H
-
-
-namespace FX {
-
-
-class FXMat3f;
-class FXMat4f;
-
-
-/// Single-precision 3-element vector
-class FXAPI FXVec3f {
-public:
-  FXfloat x;
-  FXfloat y;
-  FXfloat z;
-public:
-
-  /// Default constructor
-  FXVec3f(){}
-
-  /// Initialize from another vector
-  FXVec3f(const FXVec3f& v){x=v.x;y=v.y;z=v.z;}
-
-  /// Initialize from array of floats
-  FXVec3f(const FXfloat v[]){x=v[0];y=v[1];z=v[2];}
-
-  /// Initialize from components
-  FXVec3f(FXfloat xx,FXfloat yy,FXfloat zz=1.0f){x=xx;y=yy;z=zz;}
-
-  /// Initialize with color
-  FXVec3f(FXColor color);
-
-  /// Return a non-const reference to the ith element
-  FXfloat& operator[](FXint i){return (&x)[i];}
-
-  /// Return a const reference to the ith element
-  const FXfloat& operator[](FXint i) const {return (&x)[i];}
-
-  /// Assign color
-  FXVec3f& operator=(FXColor color);
-
-  /// Assignment
-  FXVec3f& operator=(const FXVec3f& v){x=v.x;y=v.y;z=v.z;return *this;}
-
-  /// Assignment from array of floats
-  FXVec3f& operator=(const FXfloat v[]){x=v[0];y=v[1];z=v[2];return *this;}
-
-  /// Set value from another vector
-  FXVec3f& set(const FXVec3f& v){x=v.x;y=v.y;z=v.z;return *this;}
-
-  /// Set value from array of floats
-  FXVec3f& set(const FXfloat v[]){x=v[0];y=v[1];z=v[2];return *this;}
-
-  /// Set value from components
-  FXVec3f& set(FXfloat xx,FXfloat yy,FXfloat zz){x=xx;y=yy;z=zz;return *this;}
-
-  /// Assigning operators
-  FXVec3f& operator*=(FXfloat n){x*=n;y*=n;z*=n;return *this;}
-  FXVec3f& operator/=(FXfloat n){x/=n;y/=n;z/=n;return *this;}
-  FXVec3f& operator+=(const FXVec3f& v){x+=v.x;y+=v.y;z+=v.z;return *this;}
-  FXVec3f& operator-=(const FXVec3f& v){x-=v.x;y-=v.y;z-=v.z;return *this;}
-
-  /// Conversions
-  operator FXfloat*(){return &x;}
-  operator const FXfloat*() const {return &x;}
-  operator FXVec2f&(){return *reinterpret_cast<FXVec2f*>(this);}
-  operator const FXVec2f&() const {return *reinterpret_cast<const FXVec2f*>(this);}
-
-  /// Convert to color
-  operator FXColor() const;
-
-  /// Unary
-  FXVec3f operator+() const { return *this; }
-  FXVec3f operator-() const { return FXVec3f(-x,-y,-z); }
-
-  /// Vector and vector
-  FXVec3f operator+(const FXVec3f& v) const { return FXVec3f(x+v.x,y+v.y,z+v.z); }
-  FXVec3f operator-(const FXVec3f& v) const { return FXVec3f(x-v.x,y-v.y,z-v.z); }
-
-  /// Vector and matrix
-  FXVec3f operator*(const FXMat3f& m) const;
-  FXVec3f operator*(const FXMat4f& m) const;
-
-  /// Scaling
-  friend inline FXVec3f operator*(const FXVec3f& a,FXfloat n);
-  friend inline FXVec3f operator*(FXfloat n,const FXVec3f& a);
-  friend inline FXVec3f operator/(const FXVec3f& a,FXfloat n);
-  friend inline FXVec3f operator/(FXfloat n,const FXVec3f& a);
-
-  /// Dot product
-  FXfloat operator*(const FXVec3f& v) const { return x*v.x+y*v.y+z*v.z; }
-
-  /// Cross product
-  FXVec3f operator^(const FXVec3f& v) const { return FXVec3f(y*v.z-z*v.y, z*v.x-x*v.z, x*v.y-y*v.x); }
-
-  /// Test if zero
-  bool operator!() const { return x==0.0f && y==0.0f && z==0.0f; }
-
-  /// Equality tests
-  bool operator==(const FXVec3f& v) const { return x==v.x && y==v.y && z==v.z; }
-  bool operator!=(const FXVec3f& v) const { return x!=v.x || y!=v.y || z!=v.z; }
-
-  friend inline bool operator==(const FXVec3f& a,FXfloat n);
-  friend inline bool operator!=(const FXVec3f& a,FXfloat n);
-  friend inline bool operator==(FXfloat n,const FXVec3f& a);
-  friend inline bool operator!=(FXfloat n,const FXVec3f& a);
-
-  /// Inequality tests
-  bool operator<(const FXVec3f& v) const { return x<v.x && y<v.y && z<v.z; }
-  bool operator<=(const FXVec3f& v) const { return x<=v.x && y<=v.y && z<=v.z; }
-  bool operator>(const FXVec3f& v) const { return x>v.x && y>v.y && z>v.z; }
-  bool operator>=(const FXVec3f& v) const { return x>=v.x && y>=v.y && z>=v.z; }
-
-  friend inline bool operator<(const FXVec3f& a,FXfloat n);
-  friend inline bool operator<=(const FXVec3f& a,FXfloat n);
-  friend inline bool operator>(const FXVec3f& a,FXfloat n);
-  friend inline bool operator>=(const FXVec3f& a,FXfloat n);
-
-  friend inline bool operator<(FXfloat n,const FXVec3f& a);
-  friend inline bool operator<=(FXfloat n,const FXVec3f& a);
-  friend inline bool operator>(FXfloat n,const FXVec3f& a);
-  friend inline bool operator>=(FXfloat n,const FXVec3f& a);
-
-  /// Length and square of length
-  FXfloat length2() const { return x*x+y*y+z*z; }
-  FXfloat length() const { return sqrtf(length2()); }
-
-  /// Clamp values of vector between limits
-  FXVec3f& clamp(FXfloat lo,FXfloat hi){x=FXCLAMP(lo,x,hi);y=FXCLAMP(lo,y,hi);z=FXCLAMP(lo,z,hi);return *this;}
-
-  /// Lowest or highest components
-  friend inline FXVec3f lo(const FXVec3f& a,const FXVec3f& b);
-  friend inline FXVec3f hi(const FXVec3f& a,const FXVec3f& b);
-
-  /// Compute normal from three points a,b,c
-  friend FXAPI FXVec3f normal(const FXVec3f& a,const FXVec3f& b,const FXVec3f& c);
-
-  /// Compute approximate normal from four points a,b,c,d
-  friend FXAPI FXVec3f normal(const FXVec3f& a,const FXVec3f& b,const FXVec3f& c,const FXVec3f& d);
-
-  /// Normalize vector
-  friend FXAPI FXVec3f normalize(const FXVec3f& v);
-
-  /// Save vector to a stream
-  friend FXAPI FXStream& operator<<(FXStream& store,const FXVec3f& v);
-
-  /// Load vector from a stream
-  friend FXAPI FXStream& operator>>(FXStream& store,FXVec3f& v);
-  };
-
-
-inline FXVec3f operator*(const FXVec3f& a,FXfloat n){return FXVec3f(a.x*n,a.y*n,a.z*n);}
-inline FXVec3f operator*(FXfloat n,const FXVec3f& a){return FXVec3f(n*a.x,n*a.y,n*a.z);}
-inline FXVec3f operator/(const FXVec3f& a,FXfloat n){return FXVec3f(a.x/n,a.y/n,a.z/n);}
-inline FXVec3f operator/(FXfloat n,const FXVec3f& a){return FXVec3f(n/a.x,n/a.y,n/a.z);}
-
-inline bool operator==(const FXVec3f& a,FXfloat n){return a.x==n && a.y==n && a.z==n;}
-inline bool operator!=(const FXVec3f& a,FXfloat n){return a.x!=n || a.y!=n || a.z!=n;}
-inline bool operator==(FXfloat n,const FXVec3f& a){return n==a.x && n==a.y && n==a.z;}
-inline bool operator!=(FXfloat n,const FXVec3f& a){return n!=a.x || n!=a.y || n!=a.z;}
-
-inline bool operator<(const FXVec3f& a,FXfloat n){return a.x<n && a.y<n && a.z<n;}
-inline bool operator<=(const FXVec3f& a,FXfloat n){return a.x<=n && a.y<=n && a.z<=n;}
-inline bool operator>(const FXVec3f& a,FXfloat n){return a.x>n && a.y>n && a.z>n;}
-inline bool operator>=(const FXVec3f& a,FXfloat n){return a.x>=n && a.y>=n && a.z>=n;}
-
-inline bool operator<(FXfloat n,const FXVec3f& a){return n<a.x && n<a.y && n<a.z;}
-inline bool operator<=(FXfloat n,const FXVec3f& a){return n<=a.x && n<=a.y && n<=a.z;}
-inline bool operator>(FXfloat n,const FXVec3f& a){return n>a.x && n>a.y && n>a.z;}
-inline bool operator>=(FXfloat n,const FXVec3f& a){return n>=a.x && n>=a.y && n>=a.z;}
-
-inline FXVec3f lo(const FXVec3f& a,const FXVec3f& b){return FXVec3f(FXMIN(a.x,b.x),FXMIN(a.y,b.y),FXMIN(a.z,b.z));}
-inline FXVec3f hi(const FXVec3f& a,const FXVec3f& b){return FXVec3f(FXMAX(a.x,b.x),FXMAX(a.y,b.y),FXMAX(a.z,b.z));}
-
-extern FXAPI FXVec3f normal(const FXVec3f& a,const FXVec3f& b,const FXVec3f& c);
-extern FXAPI FXVec3f normal(const FXVec3f& a,const FXVec3f& b,const FXVec3f& c,const FXVec3f& d);
-
-extern FXAPI FXVec3f normalize(const FXVec3f& v);
-
-extern FXAPI FXStream& operator<<(FXStream& store,const FXVec3f& v);
-extern FXAPI FXStream& operator>>(FXStream& store,FXVec3f& v);
-
-}
-
-#endif
diff --git a/fox-includes/FXVec4d.h b/fox-includes/FXVec4d.h
deleted file mode 100755
index 1cc604ab..00000000
--- a/fox-includes/FXVec4d.h
+++ /dev/null
@@ -1,218 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*       D o u b l e - P r e c i s i o n   4 - E l e m e n t   V e c t o r       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1994,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXVec4d.h 2346 2006-02-14 03:26:11Z lyle $                           *
-********************************************************************************/
-#ifndef FXVEC4D_H
-#define FXVEC4D_H
-
-
-namespace FX {
-
-
-class FXMat4d;
-
-
-/// Double-precision 4-element vector
-class FXAPI FXVec4d {
-public:
-  FXdouble x;
-  FXdouble y;
-  FXdouble z;
-  FXdouble w;
-public:
-
-  /// Default constructor
-  FXVec4d(){}
-
-  /// Initialize from another vector
-  FXVec4d(const FXVec4d& v){x=v.x;y=v.y;z=v.z;w=v.w;}
-
-  /// Construct with 3-vector and optional scalar
-  FXVec4d(const FXVec3d& v,FXdouble ww=1.0){x=v.x;y=v.y;z=v.z;w=ww;}
-
-  /// Initialize from array of doubles
-  FXVec4d(const FXdouble v[]){x=v[0];y=v[1];z=v[2];w=v[3];}
-
-  /// Initialize with components
-  FXVec4d(FXdouble xx,FXdouble yy,FXdouble zz,FXdouble ww=1.0){x=xx;y=yy;z=zz;w=ww;}
-
-  /// Initialize with color
-  FXVec4d(FXColor color);
-
-  /// Return a non-const reference to the ith element
-  FXdouble& operator[](FXint i){return (&x)[i];}
-
-  /// Return a const reference to the ith element
-  const FXdouble& operator[](FXint i) const {return (&x)[i];}
-
-  /// Assign color
-  FXVec4d& operator=(FXColor color);
-
-  /// Assignment
-  FXVec4d& operator=(const FXVec3d& v){x=v.x;y=v.y;z=v.z;w=1.0;return *this;}
-  FXVec4d& operator=(const FXVec4d& v){x=v.x;y=v.y;z=v.z;w=v.w;return *this;}
-
-  /// Assignment from array of doubles
-  FXVec4d& operator=(const FXdouble v[]){x=v[0];y=v[1];z=v[2];w=v[3];return *this;}
-
-  /// Set value from another vector
-  FXVec4d& set(const FXVec4d& v){x=v.x;y=v.y;z=v.z;w=v.w;return *this;}
-
-  /// Set value from array of floats
-  FXVec4d& set(const FXdouble v[]){x=v[0];y=v[1];z=v[2];w=v[3];return *this;}
-
-  /// Set value from components
-  FXVec4d& set(FXdouble xx,FXdouble yy,FXdouble zz,FXdouble ww){x=xx;y=yy;z=zz;w=ww;return *this;}
-
-  /// Assigning operators
-  FXVec4d& operator*=(FXdouble n){x*=n;y*=n;z*=n;w*=n;return *this;}
-  FXVec4d& operator/=(FXdouble n){x/=n;y/=n;z/=n;w/=n;return *this;}
-  FXVec4d& operator+=(const FXVec4d& v){x+=v.x;y+=v.y;z+=v.z;w+=v.w;return *this;}
-  FXVec4d& operator-=(const FXVec4d& v){x-=v.x;y-=v.y;z-=v.z;w-=v.w;return *this;}
-
-  /// Conversion
-  operator FXdouble*(){return &x;}
-  operator const FXdouble*() const {return &x;}
-  operator FXVec3d&(){return *reinterpret_cast<FXVec3d*>(this);}
-  operator const FXVec3d&() const {return *reinterpret_cast<const FXVec3d*>(this);}
-
-  /// Convert to color
-  operator FXColor() const;
-
-  /// Unary
-  FXVec4d operator+() const { return *this; }
-  FXVec4d operator-() const { return FXVec4d(-x,-y,-z,-w); }
-
-  /// Vector and vector
-  FXVec4d operator+(const FXVec4d& v) const { return FXVec4d(x+v.x,y+v.y,z+v.z,w+v.w); }
-  FXVec4d operator-(const FXVec4d& v) const { return FXVec4d(x-v.x,y-v.y,z-v.z,w-v.w); }
-
-  /// Vector and matrix
-  FXVec4d operator*(const FXMat4d& m) const;
-
-  /// Scaling
-  friend inline FXVec4d operator*(const FXVec4d& a,FXdouble n);
-  friend inline FXVec4d operator*(FXdouble n,const FXVec4d& a);
-  friend inline FXVec4d operator/(const FXVec4d& a,FXdouble n);
-  friend inline FXVec4d operator/(FXdouble n,const FXVec4d& a);
-
-  /// Dot product
-  FXdouble operator*(const FXVec4d& v) const { return x*v.x+y*v.y+z*v.z+w*v.w; }
-
-  /// Test if zero
-  bool operator!() const {return x==0.0 && y==0.0 && z==0.0 && w==0.0; }
-
-  /// Equality tests
-  bool operator==(const FXVec4d& v) const { return x==v.x && y==v.y && z==v.z && w==v.w; }
-  bool operator!=(const FXVec4d& v) const { return x!=v.x || y!=v.y || z!=v.z || w!=v.w; }
-
-  friend inline bool operator==(const FXVec4d& a,FXdouble n);
-  friend inline bool operator!=(const FXVec4d& a,FXdouble n);
-  friend inline bool operator==(FXdouble n,const FXVec4d& a);
-  friend inline bool operator!=(FXdouble n,const FXVec4d& a);
-
-  /// Inequality tests
-  bool operator<(const FXVec4d& v) const { return x<v.x && y<v.y && z<v.z && w<v.w; }
-  bool operator<=(const FXVec4d& v) const { return x<=v.x && y<=v.y && z<=v.z && w<=v.w; }
-  bool operator>(const FXVec4d& v) const { return x>v.x && y>v.y && z>v.z && w>v.w; }
-  bool operator>=(const FXVec4d& v) const { return x>=v.x && y>=v.y && z>=v.z && w>=v.w; }
-
-  friend inline bool operator<(const FXVec4d& a,FXdouble n);
-  friend inline bool operator<=(const FXVec4d& a,FXdouble n);
-  friend inline bool operator>(const FXVec4d& a,FXdouble n);
-  friend inline bool operator>=(const FXVec4d& a,FXdouble n);
-
-  friend inline bool operator<(FXdouble n,const FXVec4d& a);
-  friend inline bool operator<=(FXdouble n,const FXVec4d& a);
-  friend inline bool operator>(FXdouble n,const FXVec4d& a);
-  friend inline bool operator>=(FXdouble n,const FXVec4d& a);
-
-  /// Length and square of length
-  FXdouble length2() const { return x*x+y*y+z*z+w*w; }
-  FXdouble length() const { return sqrt(length2()); }
-
-  /// Clamp values of vector between limits
-  FXVec4d& clamp(FXdouble lo,FXdouble hi){x=FXCLAMP(lo,x,hi);y=FXCLAMP(lo,y,hi);z=FXCLAMP(lo,z,hi);w=FXCLAMP(lo,w,hi);return *this;}
-
-  /// Lowest or highest components
-  friend inline FXVec4d lo(const FXVec4d& a,const FXVec4d& b);
-  friend inline FXVec4d hi(const FXVec4d& a,const FXVec4d& b);
-
-  /// Compute normalized plane equation ax+by+cz+d=0
-  friend FXAPI FXVec4d plane(const FXVec4d& vec);
-  friend FXAPI FXVec4d plane(const FXVec3d& vec,FXdouble dist);
-  friend FXAPI FXVec4d plane(const FXVec3d& vec,const FXVec3d& p);
-  friend FXAPI FXVec4d plane(const FXVec3d& a,const FXVec3d& b,const FXVec3d& c);
-
-  /// Signed distance normalized plane and point
-  FXdouble distance(const FXVec3d& p) const;
-
-  /// Return true if edge a-b crosses plane
-  bool crosses(const FXVec3d& a,const FXVec3d& b) const;
-
-  /// Normalize vector
-  friend FXAPI FXVec4d normalize(const FXVec4d& v);
-
-  /// Save to a stream
-  friend FXAPI FXStream& operator<<(FXStream& store,const FXVec4d& v);
-
-  /// Load from a stream
-  friend FXAPI FXStream& operator>>(FXStream& store,FXVec4d& v);
-  };
-
-
-inline FXVec4d operator*(const FXVec4d& a,FXdouble n){return FXVec4d(a.x*n,a.y*n,a.z*n,a.w*n);}
-inline FXVec4d operator*(FXdouble n,const FXVec4d& a){return FXVec4d(n*a.x,n*a.y,n*a.z,n*a.w);}
-inline FXVec4d operator/(const FXVec4d& a,FXdouble n){return FXVec4d(a.x/n,a.y/n,a.z/n,a.w/n);}
-inline FXVec4d operator/(FXdouble n,const FXVec4d& a){return FXVec4d(n/a.x,n/a.y,n/a.z,n/a.w);}
-
-inline bool operator==(const FXVec4d& a,FXdouble n){return a.x==n && a.y==n && a.z==n && a.w==n;}
-inline bool operator!=(const FXVec4d& a,FXdouble n){return a.x!=n || a.y!=n || a.z!=n || a.w!=n;}
-inline bool operator==(FXdouble n,const FXVec4d& a){return n==a.x && n==a.y && n==a.z && n==a.w;}
-inline bool operator!=(FXdouble n,const FXVec4d& a){return n!=a.x || n!=a.y || n!=a.z || n!=a.w;}
-
-inline bool operator<(const FXVec4d& a,FXdouble n){return a.x<n && a.y<n && a.z<n && a.w<n;}
-inline bool operator<=(const FXVec4d& a,FXdouble n){return a.x<=n && a.y<=n && a.z<=n && a.w<=n;}
-inline bool operator>(const FXVec4d& a,FXdouble n){return a.x>n && a.y>n && a.z>n && a.w>n;}
-inline bool operator>=(const FXVec4d& a,FXdouble n){return a.x>=n && a.y>=n && a.z>=n && a.w>=n;}
-
-inline bool operator<(FXdouble n,const FXVec4d& a){return n<a.x && n<a.y && n<a.z && n<a.w;}
-inline bool operator<=(FXdouble n,const FXVec4d& a){return n<=a.x && n<=a.y && n<=a.z && n<=a.w;}
-inline bool operator>(FXdouble n,const FXVec4d& a){return n>a.x && n>a.y && n>a.z && n>a.w;}
-inline bool operator>=(FXdouble n,const FXVec4d& a){return n>=a.x && n>=a.y && n>=a.z && n>=a.w;}
-
-inline FXVec4d lo(const FXVec4d& a,const FXVec4d& b){return FXVec4d(FXMIN(a.x,b.x),FXMIN(a.y,b.y),FXMIN(a.z,b.z),FXMIN(a.w,b.w));}
-inline FXVec4d hi(const FXVec4d& a,const FXVec4d& b){return FXVec4d(FXMAX(a.x,b.x),FXMAX(a.y,b.y),FXMAX(a.z,b.z),FXMAX(a.w,b.w));}
-
-extern FXAPI FXVec4d plane(const FXVec4d& vec);
-extern FXAPI FXVec4d plane(const FXVec3d& vec,FXdouble dist);
-extern FXAPI FXVec4d plane(const FXVec3d& vec,const FXVec3d& p);
-extern FXAPI FXVec4d plane(const FXVec3d& a,const FXVec3d& b,const FXVec3d& c);
-
-extern FXAPI FXVec4d normalize(const FXVec4d& v);
-
-extern FXAPI FXStream& operator<<(FXStream& store,const FXVec4d& v);
-extern FXAPI FXStream& operator>>(FXStream& store,FXVec4d& v);
-
-}
-
-#endif
diff --git a/fox-includes/FXVec4f.h b/fox-includes/FXVec4f.h
deleted file mode 100755
index cba50963..00000000
--- a/fox-includes/FXVec4f.h
+++ /dev/null
@@ -1,218 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*       S i n g l e - P r e c i s i o n   4 - E l e m e n t   V e c t o r       *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1994,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXVec4f.h 2346 2006-02-14 03:26:11Z lyle $                           *
-********************************************************************************/
-#ifndef FXVEC4F_H
-#define FXVEC4F_H
-
-
-namespace FX {
-
-
-class FXMat4f;
-
-
-/// Single-precision 4-element vector
-class FXAPI FXVec4f {
-public:
-  FXfloat x;
-  FXfloat y;
-  FXfloat z;
-  FXfloat w;
-public:
-
-  /// Default constructor
-  FXVec4f(){}
-
-  /// Initialize from another vector
-  FXVec4f(const FXVec4f& v){x=v.x;y=v.y;z=v.z;w=v.w;}
-
-  /// Construct with 3-vector and optional scalar
-  FXVec4f(const FXVec3f& v,FXfloat ww=1.0f){x=v.x;y=v.y;z=v.z;w=ww;}
-
-  /// Construct from array of floats
-  FXVec4f(const FXfloat v[]){x=v[0];y=v[1];z=v[2];w=v[3];}
-
-  /// Construct from components
-  FXVec4f(FXfloat xx,FXfloat yy,FXfloat zz,FXfloat ww=1.0f){x=xx;y=yy;z=zz;w=ww;}
-
-  /// Construct from color
-  FXVec4f(FXColor color);
-
-  /// Return a non-const reference to the ith element
-  FXfloat& operator[](FXint i){return (&x)[i];}
-
-  /// Return a const reference to the ith element
-  const FXfloat& operator[](FXint i) const {return (&x)[i];}
-
-  /// Assign color
-  FXVec4f& operator=(FXColor color);
-
-  /// Assignment
-  FXVec4f& operator=(const FXVec3f& v){x=v.x;y=v.y;z=v.z;w=1.0f;return *this;}
-  FXVec4f& operator=(const FXVec4f& v){x=v.x;y=v.y;z=v.z;w=v.w;return *this;}
-
-  /// Assignment from array of floats
-  FXVec4f& operator=(const FXfloat v[]){x=v[0];y=v[1];z=v[2];w=v[3];return *this;}
-
-  /// Set value from another vector
-  FXVec4f& set(const FXVec4f& v){x=v.x;y=v.y;z=v.z;w=v.w;return *this;}
-
-  /// Set value from array of floats
-  FXVec4f& set(const FXfloat v[]){x=v[0];y=v[1];z=v[2];w=v[3];return *this;}
-
-  /// Set value from components
-  FXVec4f& set(FXfloat xx,FXfloat yy,FXfloat zz,FXfloat ww){x=xx;y=yy;z=zz;w=ww;return *this;}
-
-  /// Assigning operators
-  FXVec4f& operator*=(FXfloat n){x*=n;y*=n;z*=n;w*=n;return *this;}
-  FXVec4f& operator/=(FXfloat n){x/=n;y/=n;z/=n;w/=n;return *this;}
-  FXVec4f& operator+=(const FXVec4f& v){x+=v.x;y+=v.y;z+=v.z;w+=v.w;return *this;}
-  FXVec4f& operator-=(const FXVec4f& v){x-=v.x;y-=v.y;z-=v.z;w-=v.w;return *this;}
-
-  /// Conversion
-  operator FXfloat*(){return &x;}
-  operator const FXfloat*() const {return &x;}
-  operator FXVec3f&(){return *reinterpret_cast<FXVec3f*>(this);}
-  operator const FXVec3f&() const {return *reinterpret_cast<const FXVec3f*>(this);}
-
-  /// Convert to color
-  operator FXColor() const;
-
-  /// Unary
-  FXVec4f operator+() const { return *this; }
-  FXVec4f operator-() const { return FXVec4f(-x,-y,-z,-w); }
-
-  /// Vector and vector
-  FXVec4f operator+(const FXVec4f& v) const { return FXVec4f(x+v.x,y+v.y,z+v.z,w+v.w); }
-  FXVec4f operator-(const FXVec4f& v) const { return FXVec4f(x-v.x,y-v.y,z-v.z,w-v.w); }
-
-  /// Vector and matrix
-  FXVec4f operator*(const FXMat4f& m) const;
-
-  /// Scaling
-  friend inline FXVec4f operator*(const FXVec4f& a,FXfloat n);
-  friend inline FXVec4f operator*(FXfloat n,const FXVec4f& a);
-  friend inline FXVec4f operator/(const FXVec4f& a,FXfloat n);
-  friend inline FXVec4f operator/(FXfloat n,const FXVec4f& a);
-
-  /// Dot product
-  FXfloat operator*(const FXVec4f& v) const { return x*v.x+y*v.y+z*v.z+w*v.w; }
-
-  /// Test if zero
-  bool operator!() const { return x==0.0f && y==0.0f && z==0.0f && w==0.0f; }
-
-  /// Equality tests
-  bool operator==(const FXVec4f& v) const {return x==v.x && y==v.y && z==v.z && w==v.w; }
-  bool operator!=(const FXVec4f& v) const {return x!=v.x || y!=v.y || z!=v.z || w!=v.w; }
-
-  friend inline bool operator==(const FXVec4f& a,FXfloat n);
-  friend inline bool operator!=(const FXVec4f& a,FXfloat n);
-  friend inline bool operator==(FXfloat n,const FXVec4f& a);
-  friend inline bool operator!=(FXfloat n,const FXVec4f& a);
-
-  /// Inequality tests
-  bool operator<(const FXVec4f& v) const { return x<v.x && y<v.y && z<v.z && w<v.w; }
-  bool operator<=(const FXVec4f& v) const { return x<=v.x && y<=v.y && z<=v.z && w<=v.w; }
-  bool operator>(const FXVec4f& v) const { return x>v.x && y>v.y && z>v.z && w>v.w; }
-  bool operator>=(const FXVec4f& v) const { return x>=v.x && y>=v.y && z>=v.z && w>=v.w; }
-
-  friend inline bool operator<(const FXVec4f& a,FXfloat n);
-  friend inline bool operator<=(const FXVec4f& a,FXfloat n);
-  friend inline bool operator>(const FXVec4f& a,FXfloat n);
-  friend inline bool operator>=(const FXVec4f& a,FXfloat n);
-
-  friend inline bool operator<(FXfloat n,const FXVec4f& a);
-  friend inline bool operator<=(FXfloat n,const FXVec4f& a);
-  friend inline bool operator>(FXfloat n,const FXVec4f& a);
-  friend inline bool operator>=(FXfloat n,const FXVec4f& a);
-
-  /// Length and square of length
-  FXfloat length2() const { return x*x+y*y+z*z+w*w; }
-  FXfloat length() const { return sqrtf(length2()); }
-
-  /// Clamp values of vector between limits
-  FXVec4f& clamp(FXfloat lo,FXfloat hi){x=FXCLAMP(lo,x,hi);y=FXCLAMP(lo,y,hi);z=FXCLAMP(lo,z,hi);w=FXCLAMP(lo,w,hi);return *this;}
-
-  /// Lowest or highest components
-  friend inline FXVec4f lo(const FXVec4f& a,const FXVec4f& b);
-  friend inline FXVec4f hi(const FXVec4f& a,const FXVec4f& b);
-
-  /// Compute normalized plane equation ax+by+cz+d=0
-  friend FXAPI FXVec4f plane(const FXVec4f& vec);
-  friend FXAPI FXVec4f plane(const FXVec3f& vec,FXfloat dist);
-  friend FXAPI FXVec4f plane(const FXVec3f& vec,const FXVec3f& p);
-  friend FXAPI FXVec4f plane(const FXVec3f& a,const FXVec3f& b,const FXVec3f& c);
-
-  /// Signed distance normalized plane and point
-  FXfloat distance(const FXVec3f& p) const;
-
-  /// Return true if edge a-b crosses plane
-  bool crosses(const FXVec3f& a,const FXVec3f& b) const;
-
-  /// Normalize vector
-  friend FXAPI FXVec4f normalize(const FXVec4f& v);
-
-  /// Save to a stream
-  friend FXAPI FXStream& operator<<(FXStream& store,const FXVec4f& v);
-
-  /// Load from a stream
-  friend FXAPI FXStream& operator>>(FXStream& store,FXVec4f& v);
-  };
-
-
-inline FXVec4f operator*(const FXVec4f& a,FXfloat n){return FXVec4f(a.x*n,a.y*n,a.z*n,a.w*n);}
-inline FXVec4f operator*(FXfloat n,const FXVec4f& a){return FXVec4f(n*a.x,n*a.y,n*a.z,n*a.w);}
-inline FXVec4f operator/(const FXVec4f& a,FXfloat n){return FXVec4f(a.x/n,a.y/n,a.z/n,a.w/n);}
-inline FXVec4f operator/(FXfloat n,const FXVec4f& a){return FXVec4f(n/a.x,n/a.y,n/a.z,n/a.w);}
-
-inline bool operator==(const FXVec4f& a,FXfloat n){return a.x==n && a.y==n && a.z==n && a.w==n;}
-inline bool operator!=(const FXVec4f& a,FXfloat n){return a.x!=n || a.y!=n || a.z!=n || a.w!=n;}
-inline bool operator==(FXfloat n,const FXVec4f& a){return n==a.x && n==a.y && n==a.z && n==a.w;}
-inline bool operator!=(FXfloat n,const FXVec4f& a){return n!=a.x || n!=a.y || n!=a.z || n!=a.w;}
-
-inline bool operator<(const FXVec4f& a,FXfloat n){return a.x<n && a.y<n && a.z<n && a.w<n;}
-inline bool operator<=(const FXVec4f& a,FXfloat n){return a.x<=n && a.y<=n && a.z<=n && a.w<=n;}
-inline bool operator>(const FXVec4f& a,FXfloat n){return a.x>n && a.y>n && a.z>n && a.w>n;}
-inline bool operator>=(const FXVec4f& a,FXfloat n){return a.x>=n && a.y>=n && a.z>=n && a.w>=n;}
-
-inline bool operator<(FXfloat n,const FXVec4f& a){return n<a.x && n<a.y && n<a.z && n<a.w;}
-inline bool operator<=(FXfloat n,const FXVec4f& a){return n<=a.x && n<=a.y && n<=a.z && n<=a.w;}
-inline bool operator>(FXfloat n,const FXVec4f& a){return n>a.x && n>a.y && n>a.z && n>a.w;}
-inline bool operator>=(FXfloat n,const FXVec4f& a){return n>=a.x && n>=a.y && n>=a.z && n>=a.w;}
-
-inline FXVec4f lo(const FXVec4f& a,const FXVec4f& b){return FXVec4f(FXMIN(a.x,b.x),FXMIN(a.y,b.y),FXMIN(a.z,b.z),FXMIN(a.w,b.w));}
-inline FXVec4f hi(const FXVec4f& a,const FXVec4f& b){return FXVec4f(FXMAX(a.x,b.x),FXMAX(a.y,b.y),FXMAX(a.z,b.z),FXMAX(a.w,b.w));}
-
-extern FXAPI FXVec4f plane(const FXVec4f& vec);
-extern FXAPI FXVec4f plane(const FXVec3f& vec,FXfloat dist);
-extern FXAPI FXVec4f plane(const FXVec3f& vec,const FXVec3f& p);
-extern FXAPI FXVec4f plane(const FXVec3f& a,const FXVec3f& b,const FXVec3f& c);
-
-extern FXAPI FXVec4f normalize(const FXVec4f& v);
-
-extern FXAPI FXStream& operator<<(FXStream& store,const FXVec4f& v);
-extern FXAPI FXStream& operator>>(FXStream& store,FXVec4f& v);
-
-}
-
-#endif
diff --git a/fox-includes/FXVerticalFrame.h b/fox-includes/FXVerticalFrame.h
deleted file mode 100755
index 47798048..00000000
--- a/fox-includes/FXVerticalFrame.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                 V e r t i c a l   C o n t a i n e r   W i d g e t             *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2003 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXVerticalFrame.h 1536 2003-05-14 21:41:00Z lyle $                   *
-********************************************************************************/
-#ifndef FXVERTICALFRAME_H
-#define FXVERTICALFRAME_H
-
-#ifndef FXPACKER_H
-#include "FXPacker.h"
-#endif
-
-namespace FX {
-
-
-/**
-* Vertical frame layout manager widget is used to automatically
-* place child-windows vertically from top-to-bottom, or bottom-to-top,
-* depending on the child window's layout hints.
-*/
-class FXAPI FXVerticalFrame : public FXPacker {
-  FXDECLARE(FXVerticalFrame)
-protected:
-  FXVerticalFrame(){}
-private:
-  FXVerticalFrame(const FXVerticalFrame&);
-  FXVerticalFrame& operator=(const FXVerticalFrame&);
-public:
-
-  /// Construct a vertical frame layout manager
-  FXVerticalFrame(FXComposite *p,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=DEFAULT_SPACING,FXint pr=DEFAULT_SPACING,FXint pt=DEFAULT_SPACING,FXint pb=DEFAULT_SPACING,FXint hs=DEFAULT_SPACING,FXint vs=DEFAULT_SPACING);
-
-  /// Perform layout
-  virtual void layout();
-
-  /// Return default width
-  virtual FXint getDefaultWidth();
-
-  /// Return default height
-  virtual FXint getDefaultHeight();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXVisual.h b/fox-includes/FXVisual.h
deleted file mode 100755
index 8781addb..00000000
--- a/fox-includes/FXVisual.h
+++ /dev/null
@@ -1,184 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                            V i s u a l   C l a s s                            *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1999,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXVisual.h 2343 2006-02-12 20:26:26Z lyle $                          *
-********************************************************************************/
-#ifndef FXVISUAL_H
-#define FXVISUAL_H
-
-#ifndef FXID_H
-#include "FXId.h"
-#endif
-
-namespace FX {
-
-
-/// Construction options for FXVisual class
-enum FXVisualOptions {
-  VISUAL_DEFAULT      = 0,            /// Default visual
-  VISUAL_MONOCHROME   = 1,            /// Must be monochrome visual
-  VISUAL_BEST         = 2,            /// Best (deepest) visual
-  VISUAL_INDEXCOLOR   = 4,            /// Palette visual
-  VISUAL_GRAYSCALE    = 8,            /// Gray scale visual
-  VISUAL_TRUECOLOR    = 16,           /// Must be true color visual
-  VISUAL_OWNCOLORMAP  = 32,           /// Allocate private colormap
-  VISUAL_DOUBLEBUFFER = 64,           /// Double-buffered [FXGLVisual]
-  VISUAL_STEREO       = 128,          /// Stereo [FXGLVisual]
-  VISUAL_NOACCEL      = 256,          /// No hardware acceleration [for broken h/w]
-  VISUAL_SWAP_COPY    = 512           /// Buffer swap by copying [FXGLVisual]
-  };
-
-
-/// Visual type
-enum FXVisualType {
-  VISUALTYPE_UNKNOWN,                 /// Undetermined visual type
-  VISUALTYPE_MONO,                    /// Visual for drawing into 1-bpp surfaces
-  VISUALTYPE_TRUE,                    /// True color
-  VISUALTYPE_INDEX,                   /// Index [palette] color
-  VISUALTYPE_GRAY                     /// Gray scale
-  };
-
-
-class FXApp;
-class FXWindow;
-class FXGLContext;
-class FXGLCanvas;
-class FXImage;
-class FXIcon;
-class FXBitmap;
-class FXDCWindow;
-
-
-/// Visual describes pixel format of a drawable
-class FXAPI FXVisual : public FXId {
-  FXDECLARE(FXVisual)
-  friend class FXApp;
-  friend class FXWindow;
-  friend class FXImage;
-  friend class FXIcon;
-  friend class FXBitmap;
-  friend class FXDCWindow;
-  friend class FXGLCanvas;
-  friend class FXGLContext;
-protected:
-  FXuint        flags;                  // Visual flags
-  FXuint        hint;                   // Depth Hint
-  FXuint        depth;                  // Visual depth, significant bits/pixel
-  FXuint        numred;                 // Number of reds
-  FXuint        numgreen;               // Number of greens
-  FXuint        numblue;                // Number of blues
-  FXuint        numcolors;              // Total number of colors
-  FXuint        maxcolors;              // Maximum number of colors
-  FXVisualType  type;                   // Visual type
-  void         *info;                   // Opaque data
-  void         *visual;                 // Application visual/pixel format
-  FXID          colormap;               // Color map, if any
-  FXbool        freemap;                // We allocated the map
-#ifndef WIN32
-protected:
-  void         *gc;                     // Drawing GC
-  void         *scrollgc;               // Scrolling GC
-  FXPixel       rpix[16][256];          // Mapping from red -> pixel
-  FXPixel       gpix[16][256];          // Mapping from green -> pixel
-  FXPixel       bpix[16][256];          // Mapping from blue -> pixel
-  FXPixel       lut[256];               // Color lookup table
-protected:
-  void* setupgc(FXbool);
-  void setuptruecolor();
-  void setupdirectcolor();
-  void setuppseudocolor();
-  void setupstaticcolor();
-  void setupgrayscale();
-  void setupstaticgray();
-  void setuppixmapmono();
-  void setupcolormap();
-#endif
-protected:
-  FXVisual();
-private:
-  FXVisual(const FXVisual&);
-  FXVisual &operator=(const FXVisual&);
-public:
-
-  /// Construct default visual
-  FXVisual(FXApp* a,FXuint flgs,FXuint d=32);
-
-  /// Get visual type
-  FXVisualType getType() const { return type; }
-
-  /// Get visual info
-  void* getInfo() const { return info; }
-
-  /// Get visual or pixel format
-  void* getVisual() const { return visual; }
-
-  /// Create visual
-  virtual void create();
-
-  /// Detach visual
-  virtual void detach();
-
-  /// Destroy visual
-  virtual void destroy();
-
-  /// Get flags (see FXVisualOptions)
-  FXuint getFlags() const { return flags; }
-
-  /// Get depth, i.e. number of significant bits in color representation
-  FXuint getDepth() const { return depth; }
-
-  /// Get number of colors
-  FXuint getNumColors() const { return numcolors; }
-
-  /// Get number of reds
-  FXuint getNumRed() const { return numred; }
-
-  /// Get number of greens
-  FXuint getNumGreen() const { return numgreen; }
-
-  /// Get number of blues
-  FXuint getNumBlue() const { return numblue; }
-
-  /// Get device pixel value for color
-  FXPixel getPixel(FXColor clr);
-
-  /// Get color value for device pixel value
-  FXColor getColor(FXPixel pix);
-
-  /// Set maximum number of colors to allocate
-  void setMaxColors(FXuint maxcols);
-
-  /// Get maximum number of colors
-  FXuint getMaxColors() const { return maxcolors; }
-
-  /// Save visual information to a stream
-  virtual void save(FXStream& store) const;
-
-  /// Load visual information from a stream
-  virtual void load(FXStream& store);
-
-  /// Destructor
-  virtual ~FXVisual();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXWindow.h b/fox-includes/FXWindow.h
deleted file mode 100755
index d86ddb31..00000000
--- a/fox-includes/FXWindow.h
+++ /dev/null
@@ -1,796 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                            W i n d o w   O b j e c t                          *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXWindow.h 2346 2006-02-14 03:26:11Z lyle $                         *
-********************************************************************************/
-#ifndef FXWINDOW_H
-#define FXWINDOW_H
-
-#ifndef FXDRAWABLE_H
-#include "FXDrawable.h"
-#endif
-
-
-namespace FX {
-
-
-/// Layout hints for child widgets
-enum {
-  LAYOUT_NORMAL      = 0,                                   /// Default layout mode
-  LAYOUT_SIDE_TOP    = 0,                                   /// Pack on top side (default)
-  LAYOUT_SIDE_BOTTOM = 0x00000001,                          /// Pack on bottom side
-  LAYOUT_SIDE_LEFT   = 0x00000002,                          /// Pack on left side
-  LAYOUT_SIDE_RIGHT  = LAYOUT_SIDE_LEFT|LAYOUT_SIDE_BOTTOM, /// Pack on right side
-  LAYOUT_FILL_COLUMN = 0x00000001,                          /// Matrix column is stretchable
-  LAYOUT_FILL_ROW    = 0x00000002,                          /// Matrix row is stretchable
-  LAYOUT_LEFT        = 0,                                   /// Stick on left (default)
-  LAYOUT_RIGHT       = 0x00000004,                          /// Stick on right
-  LAYOUT_CENTER_X    = 0x00000008,                          /// Center horizontally
-  LAYOUT_FIX_X       = LAYOUT_RIGHT|LAYOUT_CENTER_X,        /// X fixed
-  LAYOUT_TOP         = 0,                                   /// Stick on top (default)
-  LAYOUT_BOTTOM      = 0x00000010,                          /// Stick on bottom
-  LAYOUT_CENTER_Y    = 0x00000020,                          /// Center vertically
-  LAYOUT_FIX_Y       = LAYOUT_BOTTOM|LAYOUT_CENTER_Y,       /// Y fixed
-  LAYOUT_DOCK_SAME   = 0,                                   /// Dock on same galley if it fits
-  LAYOUT_DOCK_NEXT   = 0x00000040,                          /// Dock on next galley
-  LAYOUT_RESERVED_1  = 0x00000080,
-  LAYOUT_FIX_WIDTH   = 0x00000100,                          /// Width fixed
-  LAYOUT_FIX_HEIGHT  = 0x00000200,                          /// height fixed
-  LAYOUT_MIN_WIDTH   = 0,                                   /// Minimum width is the default
-  LAYOUT_MIN_HEIGHT  = 0,                                   /// Minimum height is the default
-  LAYOUT_FILL_X      = 0x00000400,                          /// Stretch or shrink horizontally
-  LAYOUT_FILL_Y      = 0x00000800,                          /// Stretch or shrink vertically
-  LAYOUT_FILL        = LAYOUT_FILL_X|LAYOUT_FILL_Y,         /// Stretch or shrink in both directions
-  LAYOUT_EXPLICIT    = LAYOUT_FIX_X|LAYOUT_FIX_Y|LAYOUT_FIX_WIDTH|LAYOUT_FIX_HEIGHT   /// Explicit placement
-  };
-
-
-/// Frame border appearance styles (for subclasses)
-enum {
-  FRAME_NONE   = 0,                                     /// Default is no frame
-  FRAME_SUNKEN = 0x00001000,                            /// Sunken border
-  FRAME_RAISED = 0x00002000,                            /// Raised border
-  FRAME_THICK  = 0x00004000,                            /// Thick border
-  FRAME_GROOVE = FRAME_THICK,                           /// A groove or etched-in border
-  FRAME_RIDGE  = FRAME_THICK|FRAME_RAISED|FRAME_SUNKEN, /// A ridge or embossed border
-  FRAME_LINE   = FRAME_RAISED|FRAME_SUNKEN,             /// Simple line border
-  FRAME_NORMAL = FRAME_SUNKEN|FRAME_THICK               /// Regular raised/thick border
-  };
-
-
-/// Packing style (for packers)
-enum {
-  PACK_NORMAL         = 0,              /// Default is each its own size
-  PACK_UNIFORM_HEIGHT = 0x00008000,     /// Uniform height
-  PACK_UNIFORM_WIDTH  = 0x00010000      /// Uniform width
-  };
-
-
-class FXIcon;
-class FXBitmap;
-class FXCursor;
-class FXRegion;
-class FXComposite;
-class FXAccelTable;
-class FXComposeContext;
-
-
-/// Base class for all windows
-class FXAPI FXWindow : public FXDrawable {
-  FXDECLARE(FXWindow)
-  friend class FXApp;
-private:
-  FXWindow         *parent;             // Parent Window
-  FXWindow         *owner;              // Owner Window
-  FXWindow         *first;              // First Child
-  FXWindow         *last;               // Last Child
-  FXWindow         *next;               // Next Sibling
-  FXWindow         *prev;               // Previous Sibling
-  FXWindow         *focus;              // Focus Child
-  FXuint            wk;                 // Window Key
-protected:
-  FXComposeContext *composeContext;     // Compose context
-  FXCursor         *defaultCursor;      // Normal Cursor
-  FXCursor         *dragCursor;         // Cursor during drag
-  FXAccelTable     *accelTable;         // Accelerator table
-  FXObject         *target;             // Target object
-  FXSelector        message;            // Message ID
-  FXint             xpos;               // Window X Position
-  FXint             ypos;               // Window Y Position
-  FXColor           backColor;          // Window background color
-  FXString          tag;                // Help tag
-  FXuint            flags;              // Window state flags
-  FXuint            options;            // Window options
-public:
-  static FXDragType octetType;          // Raw octet stream
-  static FXDragType deleteType;         // Delete request
-  static FXDragType textType;           // Ascii text request
-  static FXDragType utf8Type;           // UTF-8 text request
-  static FXDragType utf16Type;          // UTF-16 text request
-  static FXDragType colorType;          // Color
-  static FXDragType urilistType;        // URI List
-  static const FXDragType stringType;   // Clipboard text type (pre-registered)
-  static const FXDragType imageType;    // Clipboard image type (pre-registered)
-protected:
-  FXWindow();
-  FXWindow(FXApp* a,FXVisual *vis);
-  FXWindow(FXApp* a,FXWindow* own,FXuint opts,FXint x,FXint y,FXint w,FXint h);
-  static FXWindow* findDefault(FXWindow* window);
-  static FXWindow* findInitial(FXWindow* window);
-  virtual bool doesOverrideRedirect() const;
-protected:
-#ifdef WIN32
-  virtual FXID GetDC() const;
-  virtual int ReleaseDC(FXID) const;
-  virtual const char* GetClass() const;
-#else
-  void addColormapWindows();
-  void remColormapWindows();
-#endif
-private:
-  FXWindow(const FXWindow&);
-  FXWindow& operator=(const FXWindow&);
-protected:
-
-  // Window state flags
-  enum {
-    FLAG_SHOWN        = 0x00000001,     // Is shown
-    FLAG_ENABLED      = 0x00000002,     // Able to receive input
-    FLAG_UPDATE       = 0x00000004,     // Is subject to GUI update
-    FLAG_DROPTARGET   = 0x00000008,     // Drop target
-    FLAG_FOCUSED      = 0x00000010,     // Has focus
-    FLAG_DIRTY        = 0x00000020,     // Needs layout
-    FLAG_RECALC       = 0x00000040,     // Needs recalculation
-    FLAG_TIP          = 0x00000080,     // Show tip
-    FLAG_HELP         = 0x00000100,     // Show help
-    FLAG_DEFAULT      = 0x00000200,     // Default widget
-    FLAG_INITIAL      = 0x00000400,     // Initial widget
-    FLAG_SHELL        = 0x00000800,     // Shell window
-    FLAG_ACTIVE       = 0x00001000,     // Window is active
-    FLAG_PRESSED      = 0x00002000,     // Button has been pressed
-    FLAG_KEY          = 0x00004000,     // Keyboard key pressed
-    FLAG_CARET        = 0x00008000,     // Caret is on
-    FLAG_CHANGED      = 0x00010000,     // Window data changed
-    FLAG_LASSO        = 0x00020000,     // Lasso mode
-    FLAG_TRYDRAG      = 0x00040000,     // Tentative drag mode
-    FLAG_DODRAG       = 0x00080000,     // Doing drag mode
-    FLAG_SCROLLINSIDE = 0x00100000,     // Scroll only when inside
-    FLAG_SCROLLING    = 0x00200000,     // Right mouse scrolling
-    FLAG_OWNED        = 0x00400000
-    };
-
-public:
-
-  // Message handlers
-  long onPaint(FXObject*,FXSelector,void*);
-  long onMap(FXObject*,FXSelector,void*);
-  long onUnmap(FXObject*,FXSelector,void*);
-  long onConfigure(FXObject*,FXSelector,void*);
-  long onUpdate(FXObject*,FXSelector,void*);
-  long onMotion(FXObject*,FXSelector,void*);
-  long onMouseWheel(FXObject*,FXSelector,void*);
-  long onEnter(FXObject*,FXSelector,void*);
-  long onLeave(FXObject*,FXSelector,void*);
-  long onLeftBtnPress(FXObject*,FXSelector,void*);
-  long onLeftBtnRelease(FXObject*,FXSelector,void*);
-  long onMiddleBtnPress(FXObject*,FXSelector,void*);
-  long onMiddleBtnRelease(FXObject*,FXSelector,void*);
-  long onRightBtnPress(FXObject*,FXSelector,void*);
-  long onRightBtnRelease(FXObject*,FXSelector,void*);
-  long onBeginDrag(FXObject*,FXSelector,void*);
-  long onEndDrag(FXObject*,FXSelector,void*);
-  long onDragged(FXObject*,FXSelector,void*);
-  long onKeyPress(FXObject*,FXSelector,void*);
-  long onKeyRelease(FXObject*,FXSelector,void*);
-  long onUngrabbed(FXObject*,FXSelector,void*);
-  long onDestroy(FXObject*,FXSelector,void*);
-  long onFocusSelf(FXObject*,FXSelector,void*);
-  long onFocusIn(FXObject*,FXSelector,void*);
-  long onFocusOut(FXObject*,FXSelector,void*);
-  long onSelectionLost(FXObject*,FXSelector,void*);
-  long onSelectionGained(FXObject*,FXSelector,void*);
-  long onSelectionRequest(FXObject*,FXSelector,void*);
-  long onClipboardLost(FXObject*,FXSelector,void*);
-  long onClipboardGained(FXObject*,FXSelector,void*);
-  long onClipboardRequest(FXObject*,FXSelector,void*);
-  long onDNDEnter(FXObject*,FXSelector,void*);
-  long onDNDLeave(FXObject*,FXSelector,void*);
-  long onDNDMotion(FXObject*,FXSelector,void*);
-  long onDNDDrop(FXObject*,FXSelector,void*);
-  long onDNDRequest(FXObject*,FXSelector,void*);
-  long onQueryHelp(FXObject*,FXSelector,void*);
-  long onQueryTip(FXObject*,FXSelector,void*);
-  long onCmdShow(FXObject*,FXSelector,void*);
-  long onCmdHide(FXObject*,FXSelector,void*);
-  long onUpdToggleShown(FXObject*,FXSelector,void*);
-  long onCmdToggleShown(FXObject*,FXSelector,void*);
-  long onCmdRaise(FXObject*,FXSelector,void*);
-  long onCmdLower(FXObject*,FXSelector,void*);
-  long onCmdEnable(FXObject*,FXSelector,void*);
-  long onCmdDisable(FXObject*,FXSelector,void*);
-  long onUpdToggleEnabled(FXObject*,FXSelector,void*);
-  long onCmdToggleEnabled(FXObject*,FXSelector,void*);
-  long onCmdUpdate(FXObject*,FXSelector,void*);
-  long onUpdYes(FXObject*,FXSelector,void*);
-  long onCmdDelete(FXObject*,FXSelector,void*);
-
-public:
-
-  // Message ID's common to most Windows
-  enum {
-    ID_NONE,
-    ID_HIDE,            // ID_HIDE+FALSE
-    ID_SHOW,            // ID_HIDE+TRUE
-    ID_TOGGLESHOWN,
-    ID_LOWER,
-    ID_RAISE,
-    ID_DELETE,
-    ID_DISABLE,         // ID_DISABLE+FALSE
-    ID_ENABLE,          // ID_DISABLE+TRUE
-    ID_TOGGLEENABLED,
-    ID_UNCHECK,         // ID_UNCHECK+FALSE
-    ID_CHECK,           // ID_UNCHECK+TRUE
-    ID_UNKNOWN,         // ID_UNCHECK+MAYBE
-    ID_UPDATE,
-    ID_AUTOSCROLL,
-    ID_TIPTIMER,
-    ID_HSCROLLED,
-    ID_VSCROLLED,
-    ID_SETVALUE,
-    ID_SETINTVALUE,
-    ID_SETREALVALUE,
-    ID_SETSTRINGVALUE,
-    ID_SETICONVALUE,
-    ID_SETINTRANGE,
-    ID_SETREALRANGE,
-    ID_GETINTVALUE,
-    ID_GETREALVALUE,
-    ID_GETSTRINGVALUE,
-    ID_GETICONVALUE,
-    ID_GETINTRANGE,
-    ID_GETREALRANGE,
-    ID_SETHELPSTRING,
-    ID_GETHELPSTRING,
-    ID_SETTIPSTRING,
-    ID_GETTIPSTRING,
-    ID_QUERY_MENU,
-    ID_HOTKEY,
-    ID_ACCEL,
-    ID_UNPOST,
-    ID_POST,
-    ID_MDI_TILEHORIZONTAL,
-    ID_MDI_TILEVERTICAL,
-    ID_MDI_CASCADE,
-    ID_MDI_MAXIMIZE,
-    ID_MDI_MINIMIZE,
-    ID_MDI_RESTORE,
-    ID_MDI_CLOSE,
-    ID_MDI_WINDOW,
-    ID_MDI_MENUWINDOW,
-    ID_MDI_MENUMINIMIZE,
-    ID_MDI_MENURESTORE,
-    ID_MDI_MENUCLOSE,
-    ID_MDI_NEXT,
-    ID_MDI_PREV,
-    ID_LAST
-    };
-
-public:
-
-  // Common DND type names
-  static const FXchar octetTypeName[];
-  static const FXchar deleteTypeName[];
-  static const FXchar textTypeName[];
-  static const FXchar colorTypeName[];
-  static const FXchar urilistTypeName[];
-  static const FXchar utf8TypeName[];
-  static const FXchar utf16TypeName[];
-
-public:
-
-  /// Constructor
-  FXWindow(FXComposite* p,FXuint opts=0,FXint x=0,FXint y=0,FXint w=0,FXint h=0);
-
-  /// Return a pointer to the parent window
-  FXWindow* getParent() const { return parent; }
-
-  /// Return a pointer to the owner window
-  FXWindow* getOwner() const { return owner; }
-
-  /// Return a pointer to the shell window
-  FXWindow* getShell() const;
-
-  /// Return a pointer to the root window
-  FXWindow* getRoot() const;
-
-  /// Return a pointer to the next (sibling) window, if any
-  FXWindow* getNext() const { return next; }
-
-  /// Return a pointer to the previous (sibling) window , if any
-  FXWindow* getPrev() const { return prev; }
-
-  /// Return a pointer to this window's first child window , if any
-  FXWindow* getFirst() const { return first; }
-
-  /// Return a pointer to this window's last child window, if any
-  FXWindow* getLast() const { return last; }
-
-  /// Return a pointer to the currently focused child window
-  FXWindow* getFocus() const { return focus; }
-
-  /// Change window key
-  void setKey(FXuint k){ wk=k; }
-
-  /// Return window key
-  FXuint getKey() const { return wk; }
-
-  /// Set the message target object for this window
-  void setTarget(FXObject *t){ target=t; }
-
-  /// Get the message target object for this window, if any
-  FXObject* getTarget() const { return target; }
-
-  /// Set the message identifier for this window
-  void setSelector(FXSelector sel){ message=sel; }
-
-  /// Get the message identifier for this window
-  FXSelector getSelector() const { return message; }
-
-  /// Get this window's x-coordinate, in the parent's coordinate system
-  FXint getX() const { return xpos; }
-
-  /// Get this window's y-coordinate, in the parent's coordinate system
-  FXint getY() const { return ypos; }
-
-  /// Return the default width of this window
-  virtual FXint getDefaultWidth();
-
-  /// Return the default height of this window
-  virtual FXint getDefaultHeight();
-
-  /// Return width for given height
-  virtual FXint getWidthForHeight(FXint givenheight);
-
-  /// Return height for given width
-  virtual FXint getHeightForWidth(FXint givenwidth);
-
-  /// Set this window's x-coordinate, in the parent's coordinate system
-  void setX(FXint x);
-
-  /// Set this window's y-coordinate, in the parent's coordinate system
-  void setY(FXint y);
-
-  /**
-  * Set the window width; and flag the widget as being in need of
-  * layout by its parent.  This does not immediately update the server-
-  * side representation of the widget.
-  */
-  void setWidth(FXint w);
-
-  /**
-  * Set the window height; and flag the widget as being in need of
-  * layout by its parent.  This does not immediately update the server-
-  * side representation of the widget.
-  */
-  void setHeight(FXint h);
-
-  /// Set layout hints for this window
-  void setLayoutHints(FXuint lout);
-
-  /// Get layout hints for this window
-  FXuint getLayoutHints() const;
-
-  /// Return a pointer to the accelerator table
-  FXAccelTable* getAccelTable() const { return accelTable; }
-
-  /// Set the accelerator table
-  void setAccelTable(FXAccelTable* acceltable){ accelTable=acceltable; }
-
-  /// Add a hot key
-  void addHotKey(FXHotKey code);
-
-  /// Remove a hot key
-  void remHotKey(FXHotKey code);
-
-  /// Change help tag for this widget
-  void setHelpTag(const FXString&  text){ tag=text; }
-
-  /// Get the help tag for this widget
-  const FXString& getHelpTag() const { return tag; }
-
-  /// Return true if window is a shell window
-  bool isShell() const;
-
-  /// Return true if specified window is owned by this window
-  bool isOwnerOf(const FXWindow* window) const;
-
-  /// Return true if specified window is ancestor of this window
-  bool isChildOf(const FXWindow* window) const;
-
-  /// Return true if this window contains child in its subtree
-  bool containsChild(const FXWindow* child) const;
-
-  /// Return the child window at specified coordinates
-  FXWindow* getChildAt(FXint x,FXint y) const;
-
-  /// Return the number of child windows for this window
-  FXint numChildren() const;
-
-  /**
-  * Return the index (starting from zero) of the specified child window,
-  * or -1 if the window is not a child or NULL
-  */
-  FXint indexOfChild(const FXWindow *window) const;
-
-  /**
-  * Return the child window at specified index,
-  * or NULL if the index is negative or out of range
-  */
-  FXWindow* childAtIndex(FXint index) const;
-
-  /// Return the common ancestor of window a and window b
-  static FXWindow* commonAncestor(FXWindow* a,FXWindow* b);
-
-  /// Return TRUE if sibling a <= sibling b in list
-  static bool before(const FXWindow *a,const FXWindow* b);
-
-  /// Return TRUE if sibling a >= sibling b in list
-  static bool after(const FXWindow *a,const FXWindow* b);
-
-  /// Return compose context
-  FXComposeContext* getComposeContext() const { return composeContext; }
-
-  /// Create compose context
-  void createComposeContext();
-
-  /// Destroy compose context
-  void destroyComposeContext();
-
-  /// Set the default cursor for this window
-  void setDefaultCursor(FXCursor* cur);
-
-  /// Return the default cursor for this window
-  FXCursor* getDefaultCursor() const { return defaultCursor; }
-
-  /// Set the drag cursor for this window
-  void setDragCursor(FXCursor* cur);
-
-  /// Return the drag cursor for this window
-  FXCursor* getDragCursor() const { return dragCursor; }
-
-  /// Return the cursor position and mouse button-state
-  FXint getCursorPosition(FXint& x,FXint& y,FXuint& buttons) const;
-
-  /// Warp the cursor to the new position
-  FXint setCursorPosition(FXint x,FXint y);
-
-  /// Return true if this window is able to receive mouse and keyboard events
-  bool isEnabled() const;
-
-  /// Return true if the window is active
-  bool isActive() const;
-
-  /// Return true if this window is a control capable of receiving the focus
-  virtual bool canFocus() const;
-
-  /// Return true if this window has the focus
-  bool hasFocus() const;
-
-  /// Return true if this window is in focus chain
-  bool inFocusChain() const;
-
-  /// Move the focus to this window
-  virtual void setFocus();
-
-  /// Remove the focus from this window
-  virtual void killFocus();
-
-  /// Notification that focus moved to new child
-  virtual void changeFocus(FXWindow *child);
-
-  /**
-  * This changes the default window which responds to the Return
-  * key in a dialog. If enable is TRUE, this window becomes the default
-  * window; when enable is FALSE, this window will be no longer the
-  * default window.  Finally, when enable is MAYBE, the default window
-  * will revert to the initial default window.
-  */
-  virtual void setDefault(FXbool enable=TRUE);
-
-  /// Return true if this is the default window
-  bool isDefault() const;
-
-  /// Make this window the initial default window
-  void setInitial(bool enable=true);
-
-  /// Return true if this is the initial default window
-  bool isInitial() const;
-
-  /// Enable the window to receive mouse and keyboard events
-  virtual void enable();
-
-  /// Disable the window from receiving mouse and keyboard events
-  virtual void disable();
-
-  /// Create all of the server-side resources for this window
-  virtual void create();
-
-  /// Attach foreign window handle to this window
-  virtual void attach(FXID w);
-
-  /// Detach the server-side resources for this window
-  virtual void detach();
-
-  /// Destroy the server-side resources for this window
-  virtual void destroy();
-
-  /// Set window shape by means of region
-  virtual void setShape(const FXRegion& region);
-
-  /// Set window shape by means of bitmap
-  virtual void setShape(FXBitmap* bitmap);
-
-  /// Set window shape by means of icon
-  virtual void setShape(FXIcon* icon);
-
-  /// Clear window shape
-  virtual void clearShape();
-
-  /// Raise this window to the top of the stacking order
-  virtual void raise();
-
-  /// Lower this window to the bottom of the stacking order
-  virtual void lower();
-
-  /**
-  * Move the window immediately, in the parent's coordinate system.
-  * Update the server representation as well if the window is realized.
-  * Perform layout of the children when necessary.
-  */
-  virtual void move(FXint x,FXint y);
-
-  /**
-  * Resize the window to the specified width and height immediately,
-  * updating the server representation as well, if the window was realized.
-  * Perform layout of the children when necessary.
-  */
-  virtual void resize(FXint w,FXint h);
-
-  /**
-  * Move and resize the window immediately, in the parent's coordinate system.
-  * Update the server representation as well if the window is realized.
-  * Perform layout of the children when necessary.
-  */
-  virtual void position(FXint x,FXint y,FXint w,FXint h);
-
-  /// Mark this window's layout as dirty for later layout
-  virtual void recalc();
-
-  /// Perform layout immediately
-  virtual void layout();
-
-  /// Generate a SEL_UPDATE message for the window and its children
-  void forceRefresh();
-
-  /// Reparent this window under new father before other
-  virtual void reparent(FXWindow* father,FXWindow *other=NULL);
-
-  /// Scroll rectangle x,y,w,h by a shift of dx,dy
-  void scroll(FXint x,FXint y,FXint w,FXint h,FXint dx,FXint dy) const;
-
-  /// Mark the specified rectangle to be repainted later
-  void update(FXint x,FXint y,FXint w,FXint h) const;
-
-  /// Mark the entire window to be repainted later
-  void update() const;
-
-  /// Process any outstanding repaint messages immediately, for the given rectangle
-  void repaint(FXint x,FXint y,FXint w,FXint h) const;
-
-  /// Process any outstanding repaint messages immediately
-  void repaint() const;
-
-  /**
-  * Grab the mouse to this window; future mouse events will be
-  * reported to this window even while the cursor goes outside of this window
-  */
-  void grab();
-
-  /// Release the mouse grab
-  void ungrab();
-
-  /// Return true if the window has been grabbed
-  bool grabbed() const;
-
-  /// Grab keyboard device
-  void grabKeyboard();
-
-  /// Ungrab keyboard device
-  void ungrabKeyboard();
-
-  /// Return true if active grab is in effect
-  bool grabbedKeyboard() const;
-
-  /// Show this window
-  virtual void show();
-
-  /// Hide this window
-  virtual void hide();
-
-  /// Return true if the window is shown
-  bool shown() const;
-
-  /// Return true if the window is composite
-  virtual bool isComposite() const;
-
-  /// Return true if the window is under the cursor
-  bool underCursor() const;
-
-  /// Return true if this window owns the primary selection
-  bool hasSelection() const;
-
-  /// Try to acquire the primary selection, given a list of drag types
-  bool acquireSelection(const FXDragType *types,FXuint numtypes);
-
-  /// Release the primary selection
-  bool releaseSelection();
-
-  /// Return true if this window owns the clipboard
-  bool hasClipboard() const;
-
-  /// Try to acquire the clipboard, given a list of drag types
-  bool acquireClipboard(const FXDragType *types,FXuint numtypes);
-
-  /// Release the clipboard
-  bool releaseClipboard();
-
-  /// Enable this window to receive drops
-  virtual void dropEnable();
-
-  /// Disable this window from receiving drops
-  virtual void dropDisable();
-
-  /// Return true if this window is able to receive drops
-  bool isDropEnabled() const;
-
-  /// Return true if a drag operaion has been initiated from this window
-  bool isDragging() const;
-
-  /// Initiate a drag operation with a list of previously registered drag types
-  bool beginDrag(const FXDragType *types,FXuint numtypes);
-
-  /**
-  * When dragging, inform the drop-target of the new position and
-  * the drag action
-  */
-  bool handleDrag(FXint x,FXint y,FXDragAction action=DRAG_COPY);
-
-  /**
-  * Terminate the drag operation with or without actually dropping the data
-  * Returns the action performed by the target
-  */
-  FXDragAction endDrag(bool drop=true);
-
-  /// Return true if this window is the target of a drop
-  bool isDropTarget() const;
-
-  /**
-  * When being dragged over, indicate that no further SEL_DND_MOTION messages
-  * are required while the cursor is inside the given rectangle
-  */
-  void setDragRectangle(FXint x,FXint y,FXint w,FXint h,bool wantupdates=true) const;
-
-  /**
-  * When being dragged over, indicate we want to receive SEL_DND_MOTION messages
-  * every time the cursor moves
-  */
-  void clearDragRectangle() const;
-
-  /// When being dragged over, indicate acceptance or rejection of the dragged data
-  void acceptDrop(FXDragAction action=DRAG_ACCEPT) const;
-
-  /// The target accepted our drop
-  FXDragAction didAccept() const;
-
-  /**
-  * Sent by the drop target in response to SEL_DND_DROP.  The drag action
-  * should be the same as the action the drop target reported to the drag
-  * source in reponse to the SEL_DND_MOTION message.
-  * This function notifies the drag source that its part of the drop transaction
-  * is finished, and that it is free to release any resources involved in the
-  * drag operation.
-  * Calling dropFinished() is advisable in cases where the drop target needs
-  * to perform complex processing on the data received from the drag source,
-  * prior to returning from the SEL_DND_DROP message handler.
-  */
-  void dropFinished(FXDragAction action=DRAG_REJECT) const;
-
-  /// When being dragged over, inquire the drag types which are being offered
-  bool inquireDNDTypes(FXDNDOrigin origin,FXDragType*& types,FXuint& numtypes) const;
-
-  /// When being dragged over, return true if we are offered the given drag type
-  bool offeredDNDType(FXDNDOrigin origin,FXDragType type) const;
-
-  /// When being dragged over, return the drag action
-  FXDragAction inquireDNDAction() const;
-
-  /**
-  * Set DND data; the array must be allocated with FXMALLOC and ownership is
-  * transferred to the system
-  */
-  bool setDNDData(FXDNDOrigin origin,FXDragType type,FXuchar* data,FXuint size) const;
-
-  /**
-  * Set DND data from string value.
-  */
-  bool setDNDData(FXDNDOrigin origin,FXDragType type,const FXString& string) const;
-
-  /**
-  * Get DND data; the caller becomes the owner of the array and must free it
-  * with FXFREE
-  */
-  bool getDNDData(FXDNDOrigin origin,FXDragType type,FXuchar*& data,FXuint& size) const;
-
-  /**
-  * Get DND data into string value.
-  */
-  bool getDNDData(FXDNDOrigin origin,FXDragType type,FXString& string) const;
-
-  /// Return true if window logically contains the given point
-  virtual bool contains(FXint parentx,FXint parenty) const;
-
-  /// Translate coordinates from fromwindow's coordinate space to this window's coordinate space
-  void translateCoordinatesFrom(FXint& tox,FXint& toy,const FXWindow* fromwindow,FXint fromx,FXint fromy) const;
-
-  /// Translate coordinates from this window's coordinate space to towindow's coordinate space
-  void translateCoordinatesTo(FXint& tox,FXint& toy,const FXWindow* towindow,FXint fromx,FXint fromy) const;
-
-  /// Set window background color
-  virtual void setBackColor(FXColor clr);
-
-  /// Get background color
-  FXColor getBackColor() const { return backColor; }
-
-  virtual bool doesSaveUnder() const;
-
-  /**
-  * Translate message for localization; using the current FXTranslator,
-  * an attempt is made to translate the given message into the current
-  * language.  An optional hint may be passed to break any ties in case
-  * more than one tranlation is possible for the given message text.
-  * In addition, the name of the widget is passed as context name so
-  * that controls in a single dialog may be grouped together.
-  */
-  virtual const FXchar* tr(const FXchar* message,const FXchar* hint=NULL) const;
-
-  /// Save window to stream
-  virtual void save(FXStream& store) const;
-
-  /// Restore window from stream
-  virtual void load(FXStream& store);
-
-  /// Destroy window
-  virtual ~FXWindow();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXWizard.h b/fox-includes/FXWizard.h
deleted file mode 100755
index c6071529..00000000
--- a/fox-includes/FXWizard.h
+++ /dev/null
@@ -1,132 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                           W i z a r d   W i d g e t                           *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2002,2003 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXWizard.h 1536 2003-05-14 21:41:00Z lyle $                           *
-********************************************************************************/
-#ifndef FXWIZARD_H
-#define FXWIZARD_H
-
-#ifndef FXDIALOGBOX_H
-#include "FXDialogBox.h"
-#endif
-
-namespace FX {
-
-
-class FXImage;
-class FXIcon;
-class FXImageFrame;
-class FXButton;
-class FXSwitcher;
-
-
-/**
-* A Wizard widget guides the user through a number of panels
-* in a predefined sequence; each step must be completed before
-* moving on to the next step.
-* For example, a Wizard may be used to install software components,
-* and ask various questions at each step in the installation.
-*/
-class FXAPI FXWizard : public FXDialogBox {
-  FXDECLARE(FXWizard)
-protected:
-  FXHorizontalFrame *buttons;           // Button frame
-  FXImageFrame      *sidebar;           // Sidebar comprising image
-  FXButton          *advance;           // Advance to next stage
-  FXButton          *retreat;           // Retreat to last stage
-  FXButton          *finish;            // Finish panel
-  FXButton          *cancel;            // Cancel button
-  FXSwitcher        *panels;            // Sub panels
-  FXIcon            *finishicon;
-  FXIcon            *nexticon;
-  FXIcon            *backicon;
-protected:
-  FXWizard(){}
-  void construct();
-private:
-  FXWizard(const FXWizard&);
-  FXWizard &operator=(const FXWizard&);
-public:
-  long onUpdFinish(FXObject*,FXSelector,void*);
-  long onCmdNext(FXObject*,FXSelector,void*);
-  long onUpdNext(FXObject*,FXSelector,void*);
-  long onCmdBack(FXObject*,FXSelector,void*);
-  long onUpdBack(FXObject*,FXSelector,void*);
-public:
-  enum {
-    ID_NEXT=FXDialogBox::ID_LAST,
-    ID_BACK,
-    ID_LAST
-    };
-public:
-
-  /// Construct free-floating Wizard
-  FXWizard(FXApp* a,const FXString& name,FXImage *image,FXuint opts=DECOR_TITLE|DECOR_BORDER|DECOR_RESIZE,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=10,FXint pr=10,FXint pt=10,FXint pb=10,FXint hs=10,FXint vs=10);
-
-  /// Construct Wizard which will always float over the owner window
-  FXWizard(FXWindow* owner,const FXString& name,FXImage *image,FXuint opts=DECOR_TITLE|DECOR_BORDER|DECOR_RESIZE,FXint x=0,FXint y=0,FXint w=0,FXint h=0,FXint pl=10,FXint pr=10,FXint pt=10,FXint pb=10,FXint hs=10,FXint vs=10);
-
-  /// Return a pointer to the button frame
-  FXHorizontalFrame *buttonFrame() const { return buttons; }
-
-  /// Return a pointer to the "Advance" button
-  FXButton *advanceButton() const { return advance; }
-
-  /// Return a pointer to the "Retreat" button
-  FXButton *retreatButton() const { return retreat; }
-
-  /// Return a pointer to the "Finish" button
-  FXButton *finishButton() const { return finish; }
-
-  /// Return a pointer to the "Cancel" button
-  FXButton *cancelButton() const { return cancel; }
-
-  /// Return the container used as parent for the subpanels
-  FXSwitcher *getContainer() const { return panels; }
-
-  /// Change the image being displayed
-  void setImage(FXImage* img);
-
-  /// Return the current image
-  FXImage* getImage() const;
-
-  /// Return number of panels
-  FXint getNumPanels() const;
-
-  /// Bring the child window at index to the top
-  void setCurrentPanel(FXint index);
-
-  /// Return the index of the child window currently on top
-  FXint getCurrentPanel() const;
-
-  /// Save to stream
-  virtual void save(FXStream& store) const;
-
-  /// Load from stream
-  virtual void load(FXStream& store);
-
-  // Destroy
-  virtual ~FXWizard();
-  };
-
-}
-
-#endif
diff --git a/fox-includes/FXXBMIcon.h b/fox-includes/FXXBMIcon.h
deleted file mode 100755
index 02b0e277..00000000
--- a/fox-includes/FXXBMIcon.h
+++ /dev/null
@@ -1,101 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        X B M   I c o n   O b j e c t                          *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2003,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXXBMIcon.h 2343 2006-02-12 20:26:26Z lyle $                         *
-********************************************************************************/
-#ifndef FXXBMICON_H
-#define FXXBMICON_H
-
-#ifndef FXICON_H
-#include "FXIcon.h"
-#endif
-
-namespace FX {
-
-
-/// X Bitmap icon
-class FXAPI FXXBMIcon : public FXIcon {
-  FXDECLARE(FXXBMIcon)
-protected:
-  FXXBMIcon(){}
-private:
-  FXXBMIcon(const FXXBMIcon&);
-  FXXBMIcon &operator=(const FXXBMIcon&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct icon from memory stream formatted in X Bitmap format
-  FXXBMIcon(FXApp* a,const FXuchar *pixels=NULL,const FXuchar *mask=NULL,FXColor clr=FXRGB(192,192,192),FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Save pixels into stream in X Bitmap format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in X Bitmap format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy icon
-  virtual ~FXXBMIcon();
-  };
-
-
-#ifndef FXLOADXBM
-#define FXLOADXBM
-
-/**
-* Check if stream contains a XBM, return TRUE if so.
-*/
-extern FXAPI bool fxcheckXBM(FXStream& store);
-
-/**
-* Load an XBM (X Bitmap) from pixel array and mask array.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadXBM(FXColor*& data,const FXuchar *pix,const FXuchar *msk,FXint width,FXint height);
-
-
-/**
-* Load an XBM (X Bitmap) file from a stream.
-* Upon successful return, the pixel array and size, and hot-spot are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadXBM(FXStream& store,FXColor*& data,FXint& width,FXint& height,FXint& hotx,FXint& hoty);
-
-
-/**
-* Save an XBM (X Bitmap) file to a stream; if the parameters hotx and hoty are set
-* to -1, no hotspot location is saved.
-*/
-extern FXAPI bool fxsaveXBM(FXStream& store,const FXColor *data,FXint width,FXint height,FXint hotx=-1,FXint hoty=-1);
-
-/**
-* Save a PostScript file to a stream; format the picture to the maximal
-* size that fits within the given margins of the indicated paper size.
-*/
-extern FXAPI bool fxsavePS(FXStream& store,const FXColor *data,FXint width,FXint height,FXint paperw=612,FXint paperh=792,FXint margin=35,bool color=true);
-
-#endif
-
-}
-
-#endif
diff --git a/fox-includes/FXXBMImage.h b/fox-includes/FXXBMImage.h
deleted file mode 100755
index c427f217..00000000
--- a/fox-includes/FXXBMImage.h
+++ /dev/null
@@ -1,101 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                            X B M   I m a g e   O b j e c t                    *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2003,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXXBMImage.h 2343 2006-02-12 20:26:26Z lyle $                        *
-********************************************************************************/
-#ifndef FXXBMIMAGE_H
-#define FXXBMIMAGE_H
-
-#ifndef FXIMAGE_H
-#include "FXImage.h"
-#endif
-
-namespace FX {
-
-
-/// X Bitmap image
-class FXAPI FXXBMImage : public FXImage {
-  FXDECLARE(FXXBMImage)
-protected:
-  FXXBMImage(){}
-private:
-  FXXBMImage(const FXXBMImage&);
-  FXXBMImage &operator=(const FXXBMImage&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct image from memory stream formatted in X Bitmap format
-  FXXBMImage(FXApp* a,const FXuchar *pixels=NULL,const FXuchar *mask=NULL,FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Save pixels into stream in X Bitmap format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in X Bitmap format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy icon
-  virtual ~FXXBMImage();
-  };
-
-
-#ifndef FXLOADXBM
-#define FXLOADXBM
-
-/**
-* Check if stream contains a XBM, return TRUE if so.
-*/
-extern FXAPI bool fxcheckXBM(FXStream& store);
-
-/**
-* Load an XBM (X Bitmap) from pixel array and mask array.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadXBM(FXColor*& data,const FXuchar *pix,const FXuchar *msk,FXint width,FXint height);
-
-
-/**
-* Load an XBM (X Bitmap) file from a stream.
-* Upon successful return, the pixel array and size, and hot-spot are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadXBM(FXStream& store,FXColor*& data,FXint& width,FXint& height,FXint& hotx,FXint& hoty);
-
-
-/**
-* Save an XBM (X Bitmap) file to a stream; if the parameters hotx and hoty are set
-* to -1, no hotspot location is saved.
-*/
-extern FXAPI bool fxsaveXBM(FXStream& store,const FXColor *data,FXint width,FXint height,FXint hotx=-1,FXint hoty=-1);
-
-/**
-* Save a PostScript file to a stream; format the picture to the maximal
-* size that fits within the given margins of the indicated paper size.
-*/
-extern FXAPI bool fxsavePS(FXStream& store,const FXColor *data,FXint width,FXint height,FXint paperw=612,FXint paperh=792,FXint margin=35,bool color=true);
-
-#endif
-
-}
-
-#endif
diff --git a/fox-includes/FXXPMIcon.h b/fox-includes/FXXPMIcon.h
deleted file mode 100755
index 1a3548b9..00000000
--- a/fox-includes/FXXPMIcon.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                        X P M   I c o n   O b j e c t                          *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2000,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXXPMIcon.h 2343 2006-02-12 20:26:26Z lyle $                         *
-********************************************************************************/
-#ifndef FXXPMICON_H
-#define FXXPMICON_H
-
-#ifndef FXICON_H
-#include "FXIcon.h"
-#endif
-
-namespace FX {
-
-
-/// X Pixmap icon
-class FXAPI FXXPMIcon : public FXIcon {
-  FXDECLARE(FXXPMIcon)
-protected:
-  FXXPMIcon(){}
-private:
-  FXXPMIcon(const FXXPMIcon&);
-  FXXPMIcon &operator=(const FXXPMIcon&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct icon from compiled-in X Pixmap format
-  FXXPMIcon(FXApp* a,const FXchar **pix=NULL,FXColor clr=FXRGB(192,192,192),FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Save pixels into stream in X Pixmap format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in X Pixmap format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy icon
-  virtual ~FXXPMIcon();
-  };
-
-
-#ifndef FXLOADXPM
-#define FXLOADXPM
-
-/**
-* Check if stream contains a XPM, return TRUE if so.
-*/
-extern FXAPI bool fxcheckXPM(FXStream& store);
-
-
-/**
-* Load an XPM (X Pixmap) from array of strings.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadXPM(const FXchar **pix,FXColor*& data,FXint& width,FXint& height);
-
-
-/**
-* Load an XPM (X Pixmap) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadXPM(FXStream& store,FXColor*& data,FXint& width,FXint& height);
-
-
-/**
-* Save an XPM (X Pixmap) file to a stream.
-*/
-extern FXAPI bool fxsaveXPM(FXStream& store,const FXColor *data,FXint width,FXint height,bool fast=true);
-
-#endif
-
-}
-
-#endif
diff --git a/fox-includes/FXXPMImage.h b/fox-includes/FXXPMImage.h
deleted file mode 100755
index 1982b318..00000000
--- a/fox-includes/FXXPMImage.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                            X P M   I m a g e   O b j e c t                    *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2000,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: FXXPMImage.h 2343 2006-02-12 20:26:26Z lyle $                        *
-********************************************************************************/
-#ifndef FXXPMIMAGE_H
-#define FXXPMIMAGE_H
-
-#ifndef FXIMAGE_H
-#include "FXImage.h"
-#endif
-
-namespace FX {
-
-
-/// X Pixmap image
-class FXAPI FXXPMImage : public FXImage {
-  FXDECLARE(FXXPMImage)
-protected:
-  FXXPMImage(){}
-private:
-  FXXPMImage(const FXXPMImage&);
-  FXXPMImage &operator=(const FXXPMImage&);
-public:
-  static const FXchar fileExt[];
-  static const FXchar mimeType[];
-public:
-
-  /// Construct image from compiled-in X Pixmap format
-  FXXPMImage(FXApp* a,const FXchar **pix=NULL,FXuint opts=0,FXint w=1,FXint h=1);
-
-  /// Save pixels into stream in X Pixmap format
-  virtual bool savePixels(FXStream& store) const;
-
-  /// Load pixels from stream in X Pixmap format
-  virtual bool loadPixels(FXStream& store);
-
-  /// Destroy icon
-  virtual ~FXXPMImage();
-  };
-
-
-#ifndef FXLOADXPM
-#define FXLOADXPM
-
-/**
-* Check if stream contains a XPM, return TRUE if so.
-*/
-extern FXAPI bool fxcheckXPM(FXStream& store);
-
-
-/**
-* Load an XPM (X Pixmap) from array of strings.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadXPM(const FXchar **pix,FXColor*& data,FXint& width,FXint& height);
-
-
-/**
-* Load an XPM (X Pixmap) file from a stream.
-* Upon successful return, the pixel array and size are returned.
-* If an error occurred, the pixel array is set to NULL.
-*/
-extern FXAPI bool fxloadXPM(FXStream& store,FXColor*& data,FXint& width,FXint& height);
-
-
-/**
-* Save an XPM (X Pixmap) file to a stream.
-*/
-extern FXAPI bool fxsaveXPM(FXStream& store,const FXColor *data,FXint width,FXint height,bool fast=true);
-
-#endif
-
-}
-
-#endif
diff --git a/fox-includes/README b/fox-includes/README
deleted file mode 100755
index 50ce3036..00000000
--- a/fox-includes/README
+++ /dev/null
@@ -1,4 +0,0 @@
-This directory just contains an archived copy of the include files from the
-standard FOX distribution on which this release of FXRuby is based. This
-gives the maintainer a good frame of reference for comparing against newer
-FOX releases, to see what's changed in the API.
diff --git a/fox-includes/fx.h b/fox-includes/fx.h
deleted file mode 100755
index 6425e8da..00000000
--- a/fox-includes/fx.h
+++ /dev/null
@@ -1,235 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                   M a i n   F O X   I n c l u d e   F i l e                   *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: fx.h 2344 2006-02-12 21:19:36Z lyle $                               *
-********************************************************************************/
-#ifndef FX_H
-#define FX_H
-
-// Basic includes
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdarg.h>
-#include <math.h>
-#include <string.h>
-
-// FOX defines
-#include "fxver.h"
-#include "fxdefs.h"
-#include "fxascii.h"
-#include "fxunicode.h"
-
-// FOX classes
-#include "FXHash.h"
-#include "FXException.h"
-#include "FXThread.h"
-#include "FXStream.h"
-#include "FXIO.h"
-#include "FXFile.h"
-#include "FXPipe.h"
-#include "FXSocket.h"
-#include "FXFileStream.h"
-#include "FXMemoryStream.h"
-#include "FXString.h"
-#include "FXSize.h"
-#include "FXPoint.h"
-#include "FXRectangle.h"
-#include "FXObject.h"
-#include "FXDelegator.h"
-#include "FXDict.h"
-#include "FXPath.h"
-#include "FXSystem.h"
-#include "FXStat.h"
-#include "FXDir.h"
-#include "FXDate.h"
-#include "FXURL.h"
-#include "FXStringDict.h"
-#include "FXSettings.h"
-#include "FXRegistry.h"
-#include "FXObjectList.h"
-#include "FXAccelTable.h"
-#include "FXRecentFiles.h"
-#include "FXApp.h"
-#include "FXId.h"
-#include "FXVisual.h"
-#include "FXFont.h"
-#include "FXCursor.h"
-#include "FXGUISignal.h"
-#include "FXCURCursor.h"
-#include "FXGIFCursor.h"
-#include "FXDrawable.h"
-#include "FXBitmap.h"
-#include "FXImage.h"
-#include "FXIcon.h"
-#include "FXGIFImage.h"
-#include "FXIFFImage.h"
-#include "FXBMPImage.h"
-#include "FXICOImage.h"
-#include "FXXBMImage.h"
-#include "FXXPMImage.h"
-#include "FXPCXImage.h"
-#include "FXTGAImage.h"
-#include "FXRGBImage.h"
-#include "FXPPMImage.h"
-#include "FXRASImage.h"
-#include "FXGIFIcon.h"
-#include "FXIFFIcon.h"
-#include "FXBMPIcon.h"
-#include "FXICOIcon.h"
-#include "FXXBMIcon.h"
-#include "FXXPMIcon.h"
-#include "FXPCXIcon.h"
-#include "FXTGAIcon.h"
-#include "FXRGBIcon.h"
-#include "FXPPMIcon.h"
-#include "FXRASIcon.h"
-#include "FXRegion.h"
-#include "FXDC.h"
-#include "FXDCWindow.h"
-#include "FXDCPrint.h"
-#include "FXIconSource.h"
-#include "FXIconDict.h"
-#include "FXFileDict.h"
-#include "FXWindow.h"
-#include "FXFrame.h"
-#include "FXSeparator.h"
-#include "FXLabel.h"
-#include "FX7Segment.h"
-#include "FXDial.h"
-#include "FXKnob.h"
-#include "FXColorBar.h"
-#include "FXColorRing.h"
-#include "FXColorWell.h"
-#include "FXColorWheel.h"
-#include "FXTextField.h"
-#include "FXButton.h"
-#include "FXPicker.h"
-#include "FXToggleButton.h"
-#include "FXTriStateButton.h"
-#include "FXCheckButton.h"
-#include "FXRadioButton.h"
-#include "FXArrowButton.h"
-#include "FXMenuButton.h"
-#include "FXComposite.h"
-#include "FXPacker.h"
-#include "FXHorizontalFrame.h"
-#include "FXVerticalFrame.h"
-#include "FXSpring.h"
-#include "FXMatrix.h"
-#include "FXSpinner.h"
-#include "FXRealSpinner.h"
-#include "FXRootWindow.h"
-#include "FXCanvas.h"
-#include "FXGroupBox.h"
-#include "FXShell.h"
-#include "FXToolTip.h"
-#include "FXPopup.h"
-#include "FXTopWindow.h"
-#include "FXDialogBox.h"
-#include "FXMainWindow.h"
-#include "FXMenuPane.h"
-#include "FXScrollPane.h"
-#include "FXMenuCaption.h"
-#include "FXMenuSeparator.h"
-#include "FXMenuTitle.h"
-#include "FXMenuCascade.h"
-#include "FXMenuCommand.h"
-#include "FXMenuCheck.h"
-#include "FXMenuRadio.h"
-#include "FXMenuBar.h"
-#include "FXOptionMenu.h"
-#include "FXSwitcher.h"
-#include "FXTabBar.h"
-#include "FXTabBook.h"
-#include "FXTabItem.h"
-#include "FXScrollBar.h"
-#include "FXScrollArea.h"
-#include "FXScrollWindow.h"
-#include "FXList.h"
-#include "FXComboBox.h"
-#include "FXListBox.h"
-#include "FXTreeList.h"
-#include "FXTreeListBox.h"
-#include "FXFoldingList.h"
-#include "FXBitmapView.h"
-#include "FXBitmapFrame.h"
-#include "FXImageView.h"
-#include "FXImageFrame.h"
-#include "FXTable.h"
-#include "FXDragCorner.h"
-#include "FXStatusBar.h"
-#include "FXStatusLine.h"
-#include "FXChoiceBox.h"
-#include "FXMessageBox.h"
-#include "FXDirList.h"
-#include "FXSlider.h"
-#include "FXRealSlider.h"
-#include "FXSplitter.h"
-#include "FX4Splitter.h"
-#include "FXHeader.h"
-#include "FXShutter.h"
-#include "FXIconList.h"
-#include "FXFileList.h"
-#include "FXDirBox.h"
-#include "FXDriveBox.h"
-#include "FXDirSelector.h"
-#include "FXDirDialog.h"
-#include "FXFileSelector.h"
-#include "FXFileDialog.h"
-#include "FXColorSelector.h"
-#include "FXColorDialog.h"
-#include "FXFontSelector.h"
-#include "FXFontDialog.h"
-#include "FXUndoList.h"
-#include "FXRex.h"
-#include "FXText.h"
-#include "FXDataTarget.h"
-#include "FXProgressBar.h"
-#include "FXReplaceDialog.h"
-#include "FXRuler.h"
-#include "FXRulerView.h"
-#include "FXSearchDialog.h"
-#include "FXInputDialog.h"
-#include "FXProgressDialog.h"
-#include "FXWizard.h"
-#include "FXMDIButton.h"
-#include "FXMDIClient.h"
-#include "FXMDIChild.h"
-#include "FXDocument.h"
-#include "FXDockSite.h"
-#include "FXDockBar.h"
-#include "FXToolBar.h"
-#include "FXDockHandler.h"
-#include "FXDockTitle.h"
-#include "FXToolBarGrip.h"
-#include "FXToolBarShell.h"
-#include "FXToolBarTab.h"
-#include "FXPrintDialog.h"
-#include "FXDebugTarget.h"
-#include "FXSplashWindow.h"
-
-
-#ifndef FX_NO_GLOBAL_NAMESPACE
-using namespace FX;
-#endif
-
-
-#endif
diff --git a/fox-includes/fx3d.h b/fox-includes/fx3d.h
deleted file mode 100755
index 817832ec..00000000
--- a/fox-includes/fx3d.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*      A d d i t i o n a l   F O X   I n c l u d e   F i l e   F o r   3 D      *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2005 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: fx3d.h 2247 2005-11-10 02:10:59Z lyle $                              *
-********************************************************************************/
-#ifndef FX3D_H
-#define FX3D_H
-
-// OpenGL includes
-#ifdef WIN32
-#ifndef STRICT
-#define STRICT
-#endif
-#include <windows.h>
-#endif
-#ifdef HAVE_GL_H
-#include <GL/gl.h>
-#endif
-#ifndef GLAPIENTRY
-#define GLAPIENTRY
-#endif
-#ifndef GLAPI
-#define GLAPI
-#endif
-#ifdef HAVE_GLU_H
-#include <GL/glu.h>
-#endif
-
-// Additional FOX includes
-#include "FXVec2f.h"
-#include "FXVec2d.h"
-#include "FXVec3f.h"
-#include "FXVec3d.h"
-#include "FXVec4f.h"
-#include "FXVec4d.h"
-#include "FXQuatf.h"
-#include "FXQuatd.h"
-#include "FXMat3f.h"
-#include "FXMat3d.h"
-#include "FXMat4f.h"
-#include "FXMat4d.h"
-#include "FXRangef.h"
-#include "FXRanged.h"
-#include "FXSpheref.h"
-#include "FXSphered.h"
-#include "FXExtentf.h"
-#include "FXExtentd.h"
-#include "FXGLVisual.h"
-#include "FXGLContext.h"
-#include "FXGLCanvas.h"
-#include "FXGLViewer.h"
-#include "FXGLObject.h"
-#include "FXGLShape.h"
-#include "FXGLCone.h"
-#include "FXGLCube.h"
-#include "FXGLCylinder.h"
-#include "FXGLSphere.h"
-#include "FXGLTriangleMesh.h"
-
-#ifndef FX_NO_GLOBAL_NAMESPACE
-using namespace FX;
-#endif
-
-#endif
diff --git a/fox-includes/fxascii.h b/fox-includes/fxascii.h
deleted file mode 100644
index db4b92d5..00000000
--- a/fox-includes/fxascii.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                    A S C I I   C h a r a c t e r   I n f o                    *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2005 by Jeroen van der Zijp.   All Rights Reserved.             *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: fxascii.h 2291 2005-12-05 03:37:36Z lyle $                            *
-********************************************************************************/
-#ifndef FXASCII_H
-#define FXASCII_H
-
-
-namespace FX {
-
-namespace Ascii {
-
-/// Get numeric value of character (this includes hex value)
-extern FXAPI FXint digitValue(FXchar asc);
-
-/// Ascii-only common functions
-extern FXAPI bool hasCase(FXchar asc);
-extern FXAPI bool isUpper(FXchar asc);
-extern FXAPI bool isLower(FXchar asc);
-extern FXAPI bool isTitle(FXchar asc);
-extern FXAPI bool isAscii(FXchar asc);
-extern FXAPI bool isLetter(FXchar asc);
-extern FXAPI bool isDigit(FXchar asc);
-extern FXAPI bool isAlphaNumeric(FXchar asc);
-extern FXAPI bool isControl(FXchar asc);
-extern FXAPI bool isSpace(FXchar asc);
-extern FXAPI bool isBlank(FXchar asc);
-extern FXAPI bool isPunct(FXchar asc);
-extern FXAPI bool isGraph(FXchar asc);
-extern FXAPI bool isPrint(FXchar asc);
-extern FXAPI bool isHexDigit(FXchar asc);
-extern FXAPI bool isSymbol(FXchar asc);
-extern FXAPI bool isSep(FXchar asc);
-
-/// Case conversion
-extern FXAPI FXchar toUpper(FXchar asc);
-extern FXAPI FXchar toLower(FXchar asc);
-extern FXAPI FXchar toTitle(FXchar asc);
-
-}
-
-}
-
-#endif
diff --git a/fox-includes/fxdefs.h b/fox-includes/fxdefs.h
deleted file mode 100755
index 5d9e4adf..00000000
--- a/fox-includes/fxdefs.h
+++ /dev/null
@@ -1,841 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                     FOX Definitions, Types, and Macros                        *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: fxdefs.h 2360 2006-03-29 04:10:56Z lyle $                           *
-********************************************************************************/
-#ifndef FXDEFS_H
-#define FXDEFS_H
-
-
-/********************************  Definitions  ********************************/
-
-// Truth values
-#ifndef TRUE
-#define TRUE 1
-#endif
-#ifndef FALSE
-#define FALSE 0
-#endif
-#ifndef MAYBE
-#define MAYBE 2
-#endif
-#ifndef NULL
-#define NULL 0
-#endif
-
-/// Pi
-#ifndef PI
-#define PI      3.1415926535897932384626433833
-#endif
-
-/// Euler constant
-#define EULER   2.7182818284590452353602874713
-
-/// Multiplier for degrees to radians
-#define DTOR    0.0174532925199432957692369077
-
-/// Multiplier for radians to degrees
-#define RTOD    57.295779513082320876798154814
-
-
-// Path separator
-#ifdef WIN32
-#define PATHSEP '\\'
-#define PATHSEPSTRING "\\"
-#define PATHLISTSEP ';'
-#define PATHLISTSEPSTRING ";"
-#define ISPATHSEP(c) ((c)=='/' || (c)=='\\')
-#else
-#define PATHSEP '/'
-#define PATHSEPSTRING "/"
-#define PATHLISTSEP ':'
-#define PATHLISTSEPSTRING ":"
-#define ISPATHSEP(c) ((c)=='/')
-#endif
-
-// End Of Line
-#ifdef WIN32
-#define ENDLINE "\r\n"
-#else
-#define ENDLINE "\n"
-#endif
-
-
-// For Windows
-#ifdef _DEBUG
-#ifndef DEBUG
-#define DEBUG
-#endif
-#endif
-#ifdef _NDEBUG
-#ifndef NDEBUG
-#define NDEBUG
-#endif
-#endif
-
-
-// Shared library support
-#ifdef WIN32
-#define FXLOCAL
-#define FXEXPORT __declspec(dllexport)
-#define FXIMPORT __declspec(dllimport)
-#else
-#if defined(__GNUC__) && (__GNUC__ >= 4)
-#define FXLOCAL  __attribute__ ((visibility("hidden")))
-#define FXEXPORT __attribute__ ((visibility("default")))
-#define FXIMPORT
-#else
-#define FXLOCAL
-#define FXEXPORT
-#define FXIMPORT
-#endif
-#endif
-
-// Define FXAPI for DLL builds
-#ifdef FOXDLL
-#ifdef FOXDLL_EXPORTS
-#define FXAPI FXEXPORT
-#else
-#define FXAPI FXIMPORT
-#endif
-#else
-#define FXAPI
-#endif
-
-// Callback
-#ifdef WIN32
-#ifndef CALLBACK
-#define CALLBACK __stdcall
-#endif
-#endif
-
-
-// Templates with DLL linkage
-#ifdef _MSC_VER
-#pragma warning(disable: 4251)
-#endif
-
-// Checking printf and scanf format strings
-#if defined(_CC_GNU_) || defined(__GNUG__) || defined(__GNUC__)
-#define FX_PRINTF(fmt,arg) __attribute__((format(printf,fmt,arg)))
-#define FX_SCANF(fmt,arg)  __attribute__((format(scanf,fmt,arg)))
-#else
-#define FX_PRINTF(fmt,arg)
-#define FX_SCANF(fmt,arg)
-#endif
-
-// Raw event type
-#ifndef WIN32
-union _XEvent;
-#else
-struct tagMSG;
-#endif
-
-
-namespace FX {
-
-
-// FOX System Defined Selector Types
-enum FXSelType {
-  SEL_NONE,
-  SEL_KEYPRESS,                         /// Key pressed
-  SEL_KEYRELEASE,                       /// Key released
-  SEL_LEFTBUTTONPRESS,                  /// Left mouse button pressed
-  SEL_LEFTBUTTONRELEASE,                /// Left mouse button released
-  SEL_MIDDLEBUTTONPRESS,                /// Middle mouse button pressed
-  SEL_MIDDLEBUTTONRELEASE,              /// Middle mouse button released
-  SEL_RIGHTBUTTONPRESS,                 /// Right mouse button pressed
-  SEL_RIGHTBUTTONRELEASE,               /// Right mouse button released
-  SEL_MOTION,                           /// Mouse motion
-  SEL_ENTER,                            /// Mouse entered window
-  SEL_LEAVE,                            /// Mouse left window
-  SEL_FOCUSIN,                          /// Focus into window
-  SEL_FOCUSOUT,                         /// Focus out of window
-  SEL_KEYMAP,
-  SEL_UNGRABBED,                        /// Lost the grab (Windows)
-  SEL_PAINT,                            /// Must repaint window
-  SEL_CREATE,
-  SEL_DESTROY,
-  SEL_UNMAP,                            /// Window was hidden
-  SEL_MAP,                              /// Window was shown
-  SEL_CONFIGURE,                        /// Resize
-  SEL_SELECTION_LOST,                   /// Widget lost selection
-  SEL_SELECTION_GAINED,                 /// Widget gained selection
-  SEL_SELECTION_REQUEST,                /// Inquire selection data
-  SEL_RAISED,                           /// Window to top of stack
-  SEL_LOWERED,                          /// Window to bottom of stack
-  SEL_CLOSE,                            /// Close window
-  SEL_DELETE,                           /// Delete window
-  SEL_MINIMIZE,                         /// Iconified
-  SEL_RESTORE,                          /// No longer iconified or maximized
-  SEL_MAXIMIZE,                         /// Maximized
-  SEL_UPDATE,                           /// GUI update
-  SEL_COMMAND,                          /// GUI command
-  SEL_CLICKED,                          /// Clicked
-  SEL_DOUBLECLICKED,                    /// Double-clicked
-  SEL_TRIPLECLICKED,                    /// Triple-clicked
-  SEL_MOUSEWHEEL,                       /// Mouse wheel
-  SEL_CHANGED,                          /// GUI has changed
-  SEL_VERIFY,                           /// Verify change
-  SEL_DESELECTED,                       /// Deselected
-  SEL_SELECTED,                         /// Selected
-  SEL_INSERTED,                         /// Inserted
-  SEL_REPLACED,                         /// Replaced
-  SEL_DELETED,                          /// Deleted
-  SEL_OPENED,                           /// Opened
-  SEL_CLOSED,                           /// Closed
-  SEL_EXPANDED,                         /// Expanded
-  SEL_COLLAPSED,                        /// Collapsed
-  SEL_BEGINDRAG,                        /// Start a drag
-  SEL_ENDDRAG,                          /// End a drag
-  SEL_DRAGGED,                          /// Dragged
-  SEL_LASSOED,                          /// Lassoed
-  SEL_TIMEOUT,                          /// Timeout occurred
-  SEL_SIGNAL,                           /// Signal received
-  SEL_CLIPBOARD_LOST,                   /// Widget lost clipboard
-  SEL_CLIPBOARD_GAINED,                 /// Widget gained clipboard
-  SEL_CLIPBOARD_REQUEST,                /// Inquire clipboard data
-  SEL_CHORE,                            /// Background chore
-  SEL_FOCUS_SELF,                       /// Focus on widget itself
-  SEL_FOCUS_RIGHT,                      /// Focus moved right
-  SEL_FOCUS_LEFT,                       /// Focus moved left
-  SEL_FOCUS_DOWN,                       /// Focus moved down
-  SEL_FOCUS_UP,                         /// Focus moved up
-  SEL_FOCUS_NEXT,                       /// Focus moved to next widget
-  SEL_FOCUS_PREV,                       /// Focus moved to previous widget
-  SEL_DND_ENTER,                        /// Drag action entering potential drop target
-  SEL_DND_LEAVE,                        /// Drag action leaving potential drop target
-  SEL_DND_DROP,                         /// Drop on drop target
-  SEL_DND_MOTION,                       /// Drag position changed over potential drop target
-  SEL_DND_REQUEST,                      /// Inquire drag and drop data
-  SEL_IO_READ,                          /// Read activity on a pipe
-  SEL_IO_WRITE,                         /// Write activity on a pipe
-  SEL_IO_EXCEPT,                        /// Except activity on a pipe
-  SEL_PICKED,                           /// Picked some location
-  SEL_QUERY_TIP,                        /// Message inquiring about tooltip
-  SEL_QUERY_HELP,                       /// Message inquiring about statusline help
-  SEL_DOCKED,                           /// Toolbar docked
-  SEL_FLOATED,                          /// Toolbar floated
-  SEL_SESSION_NOTIFY,                   /// Session is about to close
-  SEL_SESSION_CLOSED,                   /// Session is closed
-  SEL_LAST
-  };
-
-
-/// FOX Keyboard and Button states
-enum {
-  SHIFTMASK        = 0x001,           /// Shift key is down
-  CAPSLOCKMASK     = 0x002,           /// Caps Lock key is down
-  CONTROLMASK      = 0x004,           /// Ctrl key is down
-#ifdef __APPLE__
-  ALTMASK          = 0x2000,          /// Alt key is down
-  METAMASK         = 0x10,            /// Meta key is down
-#else
-  ALTMASK          = 0x008,           /// Alt key is down
-  METAMASK         = 0x040,           /// Meta key is down
-#endif
-  NUMLOCKMASK      = 0x010,           /// Num Lock key is down
-  SCROLLLOCKMASK   = 0x0E0,           /// Scroll Lock key is down (seems to vary)
-  LEFTBUTTONMASK   = 0x100,           /// Left mouse button is down
-  MIDDLEBUTTONMASK = 0x200,           /// Middle mouse button is down
-  RIGHTBUTTONMASK  = 0x400            /// Right mouse button is down
-  };
-
-
-/// FOX Mouse buttons
-enum {
-  LEFTBUTTON       = 1,
-  MIDDLEBUTTON     = 2,
-  RIGHTBUTTON      = 3
-  };
-
-
-/// FOX window crossing modes
-enum {
-  CROSSINGNORMAL,		     /// Normal crossing event
-  CROSSINGGRAB,			     /// Crossing due to mouse grab
-  CROSSINGUNGRAB		     /// Crossing due to mouse ungrab
-  };
-
-
-/// FOX window visibility modes
-enum {
-  VISIBILITYTOTAL,
-  VISIBILITYPARTIAL,
-  VISIBILITYNONE
-  };
-
-
-/// Options for fxfilematch
-enum {
-  FILEMATCH_FILE_NAME   = 1,        /// No wildcard can ever match `/'
-  FILEMATCH_NOESCAPE    = 2,        /// Backslashes don't quote special chars
-  FILEMATCH_PERIOD      = 4,        /// Leading `.' is matched only explicitly
-  FILEMATCH_LEADING_DIR = 8,        /// Ignore `/...' after a match
-  FILEMATCH_CASEFOLD    = 16        /// Compare without regard to case
-  };
-
-
-/// Drag and drop actions
-enum FXDragAction {
-  DRAG_REJECT  = 0,                 /// Reject all drop actions
-  DRAG_ACCEPT  = 1,                 /// Accept any drop action
-  DRAG_COPY    = 2,                 /// Copy
-  DRAG_MOVE    = 3,                 /// Move
-  DRAG_LINK    = 4,                 /// Link
-  DRAG_PRIVATE = 5                  /// Private
-  };
-
-
-/// Origin of data
-enum FXDNDOrigin {
-  FROM_SELECTION  = 0,              /// Primary selection
-  FROM_CLIPBOARD  = 1,              /// Clipboard
-  FROM_DRAGNDROP  = 2               /// Drag and drop source
-  };
-
-
-/// Exponent display
-enum FXExponent {
-  EXP_NEVER=FALSE,                  /// Never use exponential notation
-  EXP_ALWAYS=TRUE,                  /// Always use exponential notation
-  EXP_AUTO=MAYBE                    /// Use exponential notation if needed
-  };
-
-
-/// Search modes for search/replace dialogs
-enum {
-  SEARCH_FORWARD      = 0,    /// Search forward (default)
-  SEARCH_BACKWARD     = 1,    /// Search backward
-  SEARCH_NOWRAP       = 0,    /// Don't wrap (default)
-  SEARCH_WRAP         = 2,    /// Wrap around to start
-  SEARCH_EXACT        = 0,    /// Exact match (default)
-  SEARCH_IGNORECASE   = 4,    /// Ignore case
-  SEARCH_REGEX        = 8,    /// Regular expression match
-  SEARCH_PREFIX       = 16    /// Prefix of subject string
-  };
-
-
-/*********************************  Typedefs  **********************************/
-
-// Forward declarations
-class                          FXObject;
-class                          FXStream;
-class                          FXString;
-
-
-// Streamable types; these are fixed size!
-typedef char                   FXchar;
-typedef unsigned char          FXuchar;
-typedef FXuchar                FXbool;
-typedef unsigned short         FXushort;
-typedef short                  FXshort;
-typedef unsigned int           FXuint;
-typedef int                    FXint;
-typedef float                  FXfloat;
-typedef double                 FXdouble;
-typedef FXObject              *FXObjectPtr;
-#ifdef WIN32
-typedef unsigned int           FXwchar;
-#if defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED)
-typedef unsigned short         FXnchar;
-#elif defined(__WATCOM_INT64__)
-typedef long char FXnchar;
-#else
-typedef wchar_t                FXnchar;
-#endif
-#else
-typedef wchar_t                FXwchar;
-typedef unsigned short         FXnchar;
-#endif
-#if defined(__LP64__) || defined(_LP64) || (_MIPS_SZLONG == 64) || (__WORDSIZE == 64)
-typedef unsigned long          FXulong;
-typedef long                   FXlong;
-#elif defined(_MSC_VER) || (defined(__BCPLUSPLUS__) && __BORLANDC__ > 0x500) || defined(__WATCOM_INT64__)
-typedef unsigned __int64       FXulong;
-typedef __int64                FXlong;
-#elif defined(__GNUG__) || defined(__GNUC__) || defined(__SUNPRO_CC) || defined(__MWERKS__) || defined(__SC__) || defined(_LONGLONG)
-typedef unsigned long long     FXulong;
-typedef long long              FXlong;
-#else
-#error "FXlong and FXulong not defined for this architecture!"
-#endif
-
-// Integral types large enough to hold value of a pointer
-#if defined(_MSC_VER) && defined(_WIN64)
-typedef __int64                FXival;
-typedef unsigned __int64       FXuval;
-#else
-typedef long                   FXival;
-typedef unsigned long          FXuval;
-#endif
-
-
-// Handle to something in server
-#ifndef WIN32
-typedef unsigned long          FXID;
-#else
-typedef void*                  FXID;
-#endif
-
-// Time since January 1, 1970 (UTC)
-typedef long                   FXTime;
-
-// Pixel type (could be color index)
-typedef unsigned long          FXPixel;
-
-// RGBA pixel value
-typedef FXuint                 FXColor;
-
-// Hot key
-typedef FXuint                 FXHotKey;
-
-// Drag type
-#ifndef WIN32
-typedef FXID                   FXDragType;
-#else
-typedef FXushort               FXDragType;
-#endif
-
-// Input source handle type
-#ifndef WIN32
-typedef FXint                  FXInputHandle;
-#else
-typedef void*                  FXInputHandle;
-#endif
-
-// Raw event type
-#ifndef WIN32
-typedef _XEvent                FXRawEvent;
-#else
-typedef tagMSG                 FXRawEvent;
-#endif
-
-
-/**********************************  Macros  ***********************************/
-
-
-/// Abolute value
-#define FXABS(val) (((val)>=0)?(val):-(val))
-
-/// Return the maximum of a or b
-#define FXMAX(a,b) (((a)>(b))?(a):(b))
-
-/// Return the minimum of a or b
-#define FXMIN(a,b) (((a)>(b))?(b):(a))
-
-/// Return the minimum of x, y and z
-#define FXMIN3(x,y,z) ((x)<(y)?FXMIN(x,z):FXMIN(y,z))
-
-/// Return the maximum of x, y and z
-#define FXMAX3(x,y,z) ((x)>(y)?FXMAX(x,z):FXMAX(y,z))
-
-/// Return the minimum of x, y, z, and w
-#define FXMIN4(x,y,z,w) (FXMIN(FXMIN(x,y),FXMIN(z,w)))
-
-/// Return the maximum of of x, y, z, and w
-#define FXMAX4(x,y,z,w) (FXMAX(FXMAX(x,y),FXMAX(z,w)))
-
-/// Return minimum and maximum of a, b
-#define FXMINMAX(lo,hi,a,b) ((a)<(b)?((lo)=(a),(hi)=(b)):((lo)=(b),(hi)=(a)))
-
-/// Clamp value x to range [lo..hi]
-#define FXCLAMP(lo,x,hi) ((x)<(lo)?(lo):((x)>(hi)?(hi):(x)))
-
-/// Swap a pair of numbers
-#define FXSWAP(a,b,t) ((t)=(a),(a)=(b),(b)=(t))
-
-/// Linear interpolation between a and b, where 0<=f<=1
-#define FXLERP(a,b,f) ((a)+((b)-(a))*(f))
-
-/// Offset of member in a structure
-#define STRUCTOFFSET(str,member) (((char *)(&(((str *)0)->member)))-((char *)0))
-
-/// Number of elements in a static array
-#define ARRAYNUMBER(array) (sizeof(array)/sizeof(array[0]))
-
-/// Container class of a member class
-#define CONTAINER(ptr,str,mem) ((str*)(((char*)(ptr))-STRUCTOFFSET(str,mem)))
-
-/// Make int out of two shorts
-#define MKUINT(l,h) ((((FX::FXuint)(l))&0xffff) | (((FX::FXuint)(h))<<16))
-
-/// Make selector from message type and message id
-#define FXSEL(type,id) ((((FX::FXuint)(id))&0xffff) | (((FX::FXuint)(type))<<16))
-
-/// Get type from selector
-#define FXSELTYPE(s) ((FX::FXushort)(((s)>>16)&0xffff))
-
-/// Get ID from selector
-#define FXSELID(s) ((FX::FXushort)((s)&0xffff))
-
-/// Reverse bits in byte
-#define FXBITREVERSE(b) (((b&0x01)<<7)|((b&0x02)<<5)|((b&0x04)<<3)|((b&0x08)<<1)|((b&0x10)>>1)|((b&0x20)>>3)|((b&0x40)>>5)|((b&0x80)>>7))
-
-/// Test if character c is at the start of a utf8 sequence
-#define FXISUTF(c) (((c)&0xC0)!=0x80)
-
-
-// Definitions for big-endian machines
-#if FOX_BIGENDIAN == 1
-
-/// Make RGBA color
-#define FXRGBA(r,g,b,a)    (((FX::FXuint)(FX::FXuchar)(r)<<24) | ((FX::FXuint)(FX::FXuchar)(g)<<16) | ((FX::FXuint)(FX::FXuchar)(b)<<8) | ((FX::FXuint)(FX::FXuchar)(a)))
-
-/// Make RGB color
-#define FXRGB(r,g,b)       (((FX::FXuint)(FX::FXuchar)(r)<<24) | ((FX::FXuint)(FX::FXuchar)(g)<<16) | ((FX::FXuint)(FX::FXuchar)(b)<<8) | 0x000000ff)
-
-/// Get red value from RGBA color
-#define FXREDVAL(rgba)     ((FX::FXuchar)(((rgba)>>24)&0xff))
-
-/// Get green value from RGBA color
-#define FXGREENVAL(rgba)   ((FX::FXuchar)(((rgba)>>16)&0xff))
-
-/// Get blue value from RGBA color
-#define FXBLUEVAL(rgba)    ((FX::FXuchar)(((rgba)>>8)&0xff))
-
-/// Get alpha value from RGBA color
-#define FXALPHAVAL(rgba)   ((FX::FXuchar)((rgba)&0xff))
-
-/// Get component value of RGBA color
-#define FXRGBACOMPVAL(rgba,comp) ((FX::FXuchar)(((rgba)>>((3-(comp))<<3))&0xff))
-
-#endif
-
-
-// Definitions for little-endian machines
-#if FOX_BIGENDIAN == 0
-
-/// Make RGBA color
-#define FXRGBA(r,g,b,a)    (((FX::FXuint)(FX::FXuchar)(r)) | ((FX::FXuint)(FX::FXuchar)(g)<<8) | ((FX::FXuint)(FX::FXuchar)(b)<<16) | ((FX::FXuint)(FX::FXuchar)(a)<<24))
-
-/// Make RGB color
-#define FXRGB(r,g,b)       (((FX::FXuint)(FX::FXuchar)(r)) | ((FX::FXuint)(FX::FXuchar)(g)<<8) | ((FX::FXuint)(FX::FXuchar)(b)<<16) | 0xff000000)
-
-/// Get red value from RGBA color
-#define FXREDVAL(rgba)     ((FX::FXuchar)((rgba)&0xff))
-
-/// Get green value from RGBA color
-#define FXGREENVAL(rgba)   ((FX::FXuchar)(((rgba)>>8)&0xff))
-
-/// Get blue value from RGBA color
-#define FXBLUEVAL(rgba)    ((FX::FXuchar)(((rgba)>>16)&0xff))
-
-/// Get alpha value from RGBA color
-#define FXALPHAVAL(rgba)   ((FX::FXuchar)(((rgba)>>24)&0xff))
-
-/// Get component value of RGBA color
-#define FXRGBACOMPVAL(rgba,comp) ((FX::FXuchar)(((rgba)>>((comp)<<3))&0xff))
-
-#endif
-
-
-/**
-* FXASSERT() prints out a message when the expression fails,
-* and nothing otherwise.  Unlike assert(), FXASSERT() will not
-* terminate the execution of the application.
-* When compiling your application for release, all assertions
-* are compiled out; thus there is no impact on execution speed.
-*/
-#ifndef NDEBUG
-#define FXASSERT(exp) ((exp)?((void)0):(void)FX::fxassert(#exp,__FILE__,__LINE__))
-#else
-#define FXASSERT(exp) ((void)0)
-#endif
-
-
-/**
-* FXTRACE() allows you to trace the execution of your application
-* with increasing levels of detail the higher the trace level.
-* The trace level is determined by variable fxTraceLevel, which
-* may be set from the command line with "-tracelevel <level>".
-* When compiling your application for release, all trace statements
-* are compiled out, just like FXASSERT.
-* A statement like: FXTRACE((10,"The value of x=%d\n",x)) will
-* generate output only if fxTraceLevel is set to 11 or greater.
-* The default value fxTraceLevel=0 will block all trace outputs.
-* Note the double parentheses!
-*/
-#ifndef NDEBUG
-#define FXTRACE(arguments) FX::fxtrace arguments
-#else
-#define FXTRACE(arguments) ((void)0)
-#endif
-
-
-/**
-* Allocate a memory block of no elements of type and store a pointer
-* to it into the address pointed to by ptr.
-* Return FALSE if size!=0 and allocation fails, TRUE otherwise.
-* An allocation of a zero size block returns a NULL pointer.
-*/
-#define FXMALLOC(ptr,type,no)     (FX::fxmalloc((void **)(ptr),sizeof(type)*(no)))
-
-/**
-* Allocate a zero-filled memory block no elements of type and store a pointer
-* to it into the address pointed to by ptr.
-* Return FALSE if size!=0 and allocation fails, TRUE otherwise.
-* An allocation of a zero size block returns a NULL pointer.
-*/
-#define FXCALLOC(ptr,type,no)     (FX::fxcalloc((void **)(ptr),sizeof(type)*(no)))
-
-/**
-* Resize the memory block referred to by the pointer at the address ptr, to a
-* hold no elements of type.
-* Returns FALSE if size!=0 and reallocation fails, TRUE otherwise.
-* If reallocation fails, pointer is left to point to old block; a reallocation
-* to a zero size block has the effect of freeing it.
-* The ptr argument must be the address where the pointer to the allocated
-* block is to be stored.
-*/
-#define FXRESIZE(ptr,type,no)     (FX::fxresize((void **)(ptr),sizeof(type)*(no)))
-
-/**
-* Allocate and initialize memory from another block.
-* Return FALSE if size!=0 and source!=NULL and allocation fails, TRUE otherwise.
-* An allocation of a zero size block returns a NULL pointer.
-* The ptr argument must be the address where the pointer to the allocated
-* block is to be stored.
-*/
-#define FXMEMDUP(ptr,src,type,no) (FX::fxmemdup((void **)(ptr),(const void*)(src),sizeof(type)*(no)))
-
-/**
-* Free a block of memory allocated with either FXMALLOC, FXCALLOC, FXRESIZE, or FXMEMDUP.
-* It is OK to call free a NULL pointer.  The argument must be the address of the
-* pointer to the block to be released.  The pointer is set to NULL to prevent
-* any further references to the block after releasing it.
-*/
-#define FXFREE(ptr)               (FX::fxfree((void **)(ptr)))
-
-
-/**
-* These are some of the ISO C99 standard single-precision transcendental functions.
-* On LINUX, specify _GNU_SOURCE or _ISOC99_SOURCE to enable native implementation;
-* otherwise, these macros will be used.  Apple OS-X implements fabsf(x), ceilf(x),
-* floorf(x), and fmodf(x,y).
-* Define FLOAT_MATH_FUNCTIONS if these functions are available in some other
-* library you're linking to.
-*/
-#ifdef __OpenBSD__
-#define FLOAT_MATH_FUNCTIONS
-#endif
-#ifndef FLOAT_MATH_FUNCTIONS
-#ifndef __USE_ISOC99
-#ifndef __APPLE__
-#define fabsf(x)    ((float)fabs((double)(x)))
-#define ceilf(x)    ((float)ceil((double)(x)))
-#define floorf(x)   ((float)floor((double)(x)))
-#define fmodf(x,y)  ((float)fmod((double)(x),(double)(y)))
-#endif
-#define sqrtf(x)    ((float)sqrt((double)(x)))
-#define sinf(x)     ((float)sin((double)(x)))
-#define cosf(x)     ((float)cos((double)(x)))
-#define tanf(x)     ((float)tan((double)(x)))
-#define asinf(x)    ((float)asin((double)(x)))
-#define acosf(x)    ((float)acos((double)(x)))
-#define atanf(x)    ((float)atan((double)(x)))
-#define atan2f(y,x) ((float)atan2((double)(y),(double)(x)))
-#define powf(x,y)   ((float)pow((double)(x),(double)(y)))
-#define expf(x)     ((float)exp((double)(x)))
-#define logf(x)     ((float)log((double)(x)))
-#define log10f(x)   ((float)log10((double)(x)))
-#endif
-#endif
-
-
-/**********************************  Globals  **********************************/
-
-/// Simple, thread-safe, random number generator
-extern FXAPI FXuint fxrandom(FXuint& seed);
-
-/// Allocate memory
-extern FXAPI FXint fxmalloc(void** ptr,unsigned long size);
-
-/// Allocate cleaned memory
-extern FXAPI FXint fxcalloc(void** ptr,unsigned long size);
-
-/// Resize memory
-extern FXAPI FXint fxresize(void** ptr,unsigned long size);
-
-/// Duplicate memory
-extern FXAPI FXint fxmemdup(void** ptr,const void* src,unsigned long size);
-
-/// Free memory, resets ptr to NULL afterward
-extern FXAPI void fxfree(void** ptr);
-
-/// Error routine
-extern FXAPI void fxerror(const char* format,...) FX_PRINTF(1,2) ;
-
-/// Warning routine
-extern FXAPI void fxwarning(const char* format,...) FX_PRINTF(1,2) ;
-
-/// Log message to [typically] stderr
-extern FXAPI void fxmessage(const char* format,...) FX_PRINTF(1,2) ;
-
-/// Assert failed routine:- usually not called directly but called through FXASSERT
-extern FXAPI void fxassert(const char* expression,const char* filename,unsigned int lineno);
-
-/// Trace printout routine:- usually not called directly but called through FXTRACE
-extern FXAPI void fxtrace(unsigned int level,const char* format,...) FX_PRINTF(2,3) ;
-
-/// Sleep n microseconds
-extern FXAPI void fxsleep(unsigned int n);
-
-/// Match a file name with a pattern
-extern FXAPI bool fxfilematch(const char *pattern,const char *string,FXuint flags=(FILEMATCH_NOESCAPE|FILEMATCH_FILE_NAME));
-
-/// Get highlight color
-extern FXAPI FXColor makeHiliteColor(FXColor clr);
-
-/// Get shadow color
-extern FXAPI FXColor makeShadowColor(FXColor clr);
-
-/// Get process id
-extern FXAPI FXint fxgetpid();
-
-/// Convert string of length len to MSDOS; return new string and new length
-extern FXAPI bool fxtoDOS(FXchar*& string,FXint& len);
-
-/// Convert string of length len from MSDOS; return new string and new length
-extern FXAPI bool fxfromDOS(FXchar*& string,FXint& len);
-
-/// Duplicate string
-extern FXAPI FXchar *fxstrdup(const FXchar* str);
-
-/// Calculate a hash value from a string
-extern FXAPI FXuint fxstrhash(const FXchar* str);
-
-/// Get RGB value from color name
-extern FXAPI FXColor fxcolorfromname(const FXchar* colorname);
-
-/// Get name of (closest) color to RGB
-extern FXAPI FXchar* fxnamefromcolor(FXchar *colorname,FXColor color);
-
-/// Convert RGB to HSV
-extern FXAPI void fxrgb_to_hsv(FXfloat& h,FXfloat& s,FXfloat& v,FXfloat r,FXfloat g,FXfloat b);
-
-/// Convert HSV to RGB
-extern FXAPI void fxhsv_to_rgb(FXfloat& r,FXfloat& g,FXfloat& b,FXfloat h,FXfloat s,FXfloat v);
-
-/// Floating point number classification: 0=OK, +/-1=Inf, +/-2=NaN
-extern FXAPI FXint fxieeefloatclass(FXfloat number);
-extern FXAPI FXint fxieeedoubleclass(FXdouble number);
-
-/// Convert keysym to unicode character
-extern FXAPI FXwchar fxkeysym2ucs(FXwchar sym);
-
-/// Convert unicode character to keysym
-extern FXAPI FXwchar fxucs2keysym(FXwchar ucs);
-
-/// Parse geometry, a-la X11 geometry specification
-extern FXAPI FXint fxparsegeometry(const FXchar *string,FXint& x,FXint& y,FXint& w,FXint& h);
-
-/// True if executable with given path is a console application
-extern FXAPI FXbool fxisconsole(const FXchar *path);
-
-/// Version number that the library has been compiled with
-extern FXAPI const FXuchar fxversion[3];
-
-/// Controls tracing level
-extern FXAPI unsigned int fxTraceLevel;
-
-/// Return wide character from utf8 string at ptr
-extern FXAPI FXwchar wc(const FXchar *ptr);
-
-/// Return wide character from utf16 string at ptr
-extern FXAPI FXwchar wc(const FXnchar *ptr);
-
-/// Return number of FXchar's of wide character at ptr
-extern FXAPI FXint wclen(const FXchar *ptr);
-
-/// Return number of FXnchar's of narrow character at ptr
-extern FXAPI FXint wclen(const FXnchar *ptr);
-
-/// Return start of utf8 character containing position
-extern FXAPI FXint wcvalidate(const FXchar* string,FXint pos);
-
-/// Return start of utf16 character containing position
-extern FXAPI FXint wcvalidate(const FXnchar *string,FXint pos);
-
-/// Advance to next utf8 character start
-extern FXAPI FXint wcinc(const FXchar* string,FXint pos);
-
-/// Advance to next utf16 character start
-extern FXAPI FXint wcinc(const FXnchar *string,FXint pos);
-
-/// Retreat to previous utf8 character start
-extern FXAPI FXint wcdec(const FXchar* string,FXint pos);
-
-/// Retreat to previous utf16 character start
-extern FXAPI FXint wcdec(const FXnchar *string,FXint pos);
-
-/// Length of utf8 representation of wide characters string str of length n
-extern FXAPI FXint utfslen(const FXwchar *str,FXint n);
-
-/// Length of utf8 representation of wide character string str
-extern FXAPI FXint utfslen(const FXwchar *str);
-
-/// Length of utf8 representation of narrow characters string str of length n
-extern FXAPI FXint utfslen(const FXnchar *str,FXint n);
-
-/// Length of utf8 representation of narrow characters string str
-extern FXAPI FXint utfslen(const FXnchar *str);
-
-/// Length of wide character representation of utf8 string str of length n
-extern FXAPI FXint wcslen(const FXchar *str,FXint n);
-
-/// Length of wide character representation of utf8 string str
-extern FXAPI FXint wcslen(const FXchar *str);
-
-/// Length of narrow character representation of utf8 string str of length n
-extern FXAPI FXint ncslen(const FXchar *str,FXint n);
-
-/// Length of narrow character representation of utf8 string str
-extern FXAPI FXint ncslen(const FXchar *str);
-
-/// Copy utf8 string of length n to wide character string dst
-extern FXAPI FXint utf2wcs(FXwchar *dst,const FXchar *src,FXint n);
-
-/// Copy utf8 string to wide character string dst
-extern FXAPI FXint utf2wcs(FXwchar *dst,const FXchar *src);
-
-/// Copy utf8 string of length n to narrow character string dst
-extern FXAPI FXint utf2ncs(FXnchar *dst,const FXchar *src,FXint n);
-
-/// Copy utf8 string to narrow character string dst
-extern FXAPI FXint utf2ncs(FXnchar *dst,const FXchar *src);
-
-/// Copy wide character substring of length n to dst
-extern FXAPI FXint wc2utfs(FXchar* dst,const FXwchar *src,FXint n);
-
-/// Copy wide character string to dst
-extern FXAPI FXint wc2utfs(FXchar* dst,const FXwchar *src);
-
-/// Copy narrow character substring of length n to dst
-extern FXAPI FXint nc2utfs(FXchar* dst,const FXnchar *src,FXint n);
-
-/// Copy narrow character string to dst
-extern FXAPI FXint nc2utfs(FXchar* dst,const FXnchar *src);
-
-
-}
-
-#endif
diff --git a/fox-includes/fxkeys.h b/fox-includes/fxkeys.h
deleted file mode 100755
index 506ca141..00000000
--- a/fox-includes/fxkeys.h
+++ /dev/null
@@ -1,1413 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*        F O X   K e y b o a r d   S y m b o l   D e f i n i t i o n s          *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: fxkeys.h 2360 2006-03-29 04:10:56Z lyle $                            *
-********************************************************************************/
-#ifndef FXKEYS_H
-#define FXKEYS_H
-
-namespace FX {
-
-enum {
-
-  // Void symbol
-  KEY_VoidSymbol                    = 0,
-
-  // Miscellaneous
-  KEY_BackSpace                     = 0xFF08,
-  KEY_Tab                           = 0xFF09,
-  KEY_Linefeed                      = 0xFF0A,
-  KEY_Clear                         = 0xFF0B,
-  KEY_Return                        = 0xFF0D,
-  KEY_Pause                         = 0xFF13,
-  KEY_Scroll_Lock                   = 0xFF14,
-  KEY_Sys_Req                       = 0xFF15,
-  KEY_Escape                        = 0xFF1B,
-  KEY_Delete                        = 0xFFFF,
-  KEY_Multi_key                     = 0xFF20,
-
-  // Japanese
-  KEY_Kanji                         = 0xFF21,
-  KEY_Muhenkan                      = 0xFF22,
-  KEY_Henkan_Mode                   = 0xFF23,
-  KEY_Henkan                        = 0xFF23,
-  KEY_Romaji                        = 0xFF24,
-  KEY_Hiragana                      = 0xFF25,
-  KEY_Katakana                      = 0xFF26,
-  KEY_Hiragana_Katakana             = 0xFF27,
-  KEY_Zenkaku                       = 0xFF28,
-  KEY_Hankaku                       = 0xFF29,
-  KEY_Zenkaku_Hankaku               = 0xFF2A,
-  KEY_Touroku                       = 0xFF2B,
-  KEY_Massyo                        = 0xFF2C,
-  KEY_Kana_Lock                     = 0xFF2D,
-  KEY_Kana_Shift                    = 0xFF2E,
-  KEY_Eisu_Shift                    = 0xFF2F,
-  KEY_Eisu_toggle                   = 0xFF30,
-
-  // Cursor
-  KEY_Home                          = 0xFF50,
-  KEY_Left                          = 0xFF51,
-  KEY_Up                            = 0xFF52,
-  KEY_Right                         = 0xFF53,
-  KEY_Down                          = 0xFF54,
-  KEY_Prior                         = 0xFF55,
-  KEY_Page_Up                       = 0xFF55,
-  KEY_Next                          = 0xFF56,
-  KEY_Page_Down                     = 0xFF56,
-  KEY_End                           = 0xFF57,
-  KEY_Begin                         = 0xFF58,
-
-  // Functions
-  KEY_Select                        = 0xFF60,
-  KEY_Print                         = 0xFF61,
-  KEY_Execute                       = 0xFF62,
-  KEY_Insert                        = 0xFF63,
-  KEY_Undo                          = 0xFF65,
-  KEY_Redo                          = 0xFF66,
-  KEY_Menu                          = 0xFF67,
-  KEY_Find                          = 0xFF68,
-  KEY_Cancel                        = 0xFF69,
-  KEY_Help                          = 0xFF6A,
-  KEY_Break                         = 0xFF6B,
-  KEY_Mode_switch                   = 0xFF7E,
-  KEY_script_switch                 = 0xFF7E,
-  KEY_Num_Lock                      = 0xFF7F,
-
-  // Keypad
-  KEY_KP_Space                      = 0xFF80,
-  KEY_KP_Tab                        = 0xFF89,
-  KEY_KP_Enter                      = 0xFF8D,
-  KEY_KP_F1                         = 0xFF91,
-  KEY_KP_F2                         = 0xFF92,
-  KEY_KP_F3                         = 0xFF93,
-  KEY_KP_F4                         = 0xFF94,
-  KEY_KP_Home                       = 0xFF95,
-  KEY_KP_Left                       = 0xFF96,
-  KEY_KP_Up                         = 0xFF97,
-  KEY_KP_Right                      = 0xFF98,
-  KEY_KP_Down                       = 0xFF99,
-  KEY_KP_Prior                      = 0xFF9A,
-  KEY_KP_Page_Up                    = 0xFF9A,
-  KEY_KP_Next                       = 0xFF9B,
-  KEY_KP_Page_Down                  = 0xFF9B,
-  KEY_KP_End                        = 0xFF9C,
-  KEY_KP_Begin                      = 0xFF9D,
-  KEY_KP_Insert                     = 0xFF9E,
-  KEY_KP_Delete                     = 0xFF9F,
-  KEY_KP_Equal                      = 0xFFBD,
-  KEY_KP_Multiply                   = 0xFFAA,
-  KEY_KP_Add                        = 0xFFAB,
-  KEY_KP_Separator                  = 0xFFAC,
-  KEY_KP_Subtract                   = 0xFFAD,
-  KEY_KP_Decimal                    = 0xFFAE,
-  KEY_KP_Divide                     = 0xFFAF,
-
-  // Keypad numbers
-  KEY_KP_0                          = 0xFFB0,
-  KEY_KP_1                          = 0xFFB1,
-  KEY_KP_2                          = 0xFFB2,
-  KEY_KP_3                          = 0xFFB3,
-  KEY_KP_4                          = 0xFFB4,
-  KEY_KP_5                          = 0xFFB5,
-  KEY_KP_6                          = 0xFFB6,
-  KEY_KP_7                          = 0xFFB7,
-  KEY_KP_8                          = 0xFFB8,
-  KEY_KP_9                          = 0xFFB9,
-
-  // Function keys
-  KEY_F1                            = 0xFFBE,
-  KEY_F2                            = 0xFFBF,
-  KEY_F3                            = 0xFFC0,
-  KEY_F4                            = 0xFFC1,
-  KEY_F5                            = 0xFFC2,
-  KEY_F6                            = 0xFFC3,
-  KEY_F7                            = 0xFFC4,
-  KEY_F8                            = 0xFFC5,
-  KEY_F9                            = 0xFFC6,
-  KEY_F10                           = 0xFFC7,
-  KEY_F11                           = 0xFFC8,
-  KEY_L1                            = 0xFFC8,
-  KEY_F12                           = 0xFFC9,
-  KEY_L2                            = 0xFFC9,
-  KEY_F13                           = 0xFFCA,
-  KEY_L3                            = 0xFFCA,
-  KEY_F14                           = 0xFFCB,
-  KEY_L4                            = 0xFFCB,
-  KEY_F15                           = 0xFFCC,
-  KEY_L5                            = 0xFFCC,
-  KEY_F16                           = 0xFFCD,
-  KEY_L6                            = 0xFFCD,
-  KEY_F17                           = 0xFFCE,
-  KEY_L7                            = 0xFFCE,
-  KEY_F18                           = 0xFFCF,
-  KEY_L8                            = 0xFFCF,
-  KEY_F19                           = 0xFFD0,
-  KEY_L9                            = 0xFFD0,
-  KEY_F20                           = 0xFFD1,
-  KEY_L10                           = 0xFFD1,
-  KEY_F21                           = 0xFFD2,
-  KEY_R1                            = 0xFFD2,
-  KEY_F22                           = 0xFFD3,
-  KEY_R2                            = 0xFFD3,
-  KEY_F23                           = 0xFFD4,
-  KEY_R3                            = 0xFFD4,
-  KEY_F24                           = 0xFFD5,
-  KEY_R4                            = 0xFFD5,
-  KEY_F25                           = 0xFFD6,
-  KEY_R5                            = 0xFFD6,
-  KEY_F26                           = 0xFFD7,
-  KEY_R6                            = 0xFFD7,
-  KEY_F27                           = 0xFFD8,
-  KEY_R7                            = 0xFFD8,
-  KEY_F28                           = 0xFFD9,
-  KEY_R8                            = 0xFFD9,
-  KEY_F29                           = 0xFFDA,
-  KEY_R9                            = 0xFFDA,
-  KEY_F30                           = 0xFFDB,
-  KEY_R10                           = 0xFFDB,
-  KEY_F31                           = 0xFFDC,
-  KEY_R11                           = 0xFFDC,
-  KEY_F32                           = 0xFFDD,
-  KEY_R12                           = 0xFFDD,
-  KEY_F33                           = 0xFFDE,
-  KEY_R13                           = 0xFFDE,
-  KEY_F34                           = 0xFFDF,
-  KEY_R14                           = 0xFFDF,
-  KEY_F35                           = 0xFFE0,
-  KEY_R15                           = 0xFFE0,
-
-  // Modifiers
-  KEY_Shift_L                       = 0xFFE1,
-  KEY_Shift_R                       = 0xFFE2,
-  KEY_Control_L                     = 0xFFE3,
-  KEY_Control_R                     = 0xFFE4,
-  KEY_Caps_Lock                     = 0xFFE5,
-  KEY_Shift_Lock                    = 0xFFE6,
-
-  KEY_Meta_L                        = 0xFFE7,
-  KEY_Meta_R                        = 0xFFE8,
-  KEY_Alt_L                         = 0xFFE9,
-  KEY_Alt_R                         = 0xFFEA,
-  KEY_Super_L                       = 0xFFEB,
-  KEY_Super_R                       = 0xFFEC,
-  KEY_Hyper_L                       = 0xFFED,
-  KEY_Hyper_R                       = 0xFFEE,
-
-
-  // ISO 9995
-  KEY_ISO_Lock                      = 0xFE01,
-  KEY_ISO_Level2_Latch              = 0xFE02,
-  KEY_ISO_Level3_Shift              = 0xFE03,
-  KEY_ISO_Level3_Latch              = 0xFE04,
-  KEY_ISO_Level3_Lock               = 0xFE05,
-  KEY_ISO_Group_Shift               = 0xFF7E,
-  KEY_ISO_Group_Latch               = 0xFE06,
-  KEY_ISO_Group_Lock                = 0xFE07,
-  KEY_ISO_Next_Group                = 0xFE08,
-  KEY_ISO_Next_Group_Lock           = 0xFE09,
-  KEY_ISO_Prev_Group                = 0xFE0A,
-  KEY_ISO_Prev_Group_Lock           = 0xFE0B,
-  KEY_ISO_First_Group               = 0xFE0C,
-  KEY_ISO_First_Group_Lock          = 0xFE0D,
-  KEY_ISO_Last_Group                = 0xFE0E,
-  KEY_ISO_Last_Group_Lock           = 0xFE0F,
-  KEY_ISO_Left_Tab                  = 0xFE20,
-  KEY_ISO_Move_Line_Up              = 0xFE21,
-  KEY_ISO_Move_Line_Down            = 0xFE22,
-  KEY_ISO_Partial_Line_Up           = 0xFE23,
-  KEY_ISO_Partial_Line_Down         = 0xFE24,
-  KEY_ISO_Partial_Space_Left        = 0xFE25,
-  KEY_ISO_Partial_Space_Right       = 0xFE26,
-  KEY_ISO_Set_Margin_Left           = 0xFE27,
-  KEY_ISO_Set_Margin_Right          = 0xFE28,
-  KEY_ISO_Release_Margin_Left       = 0xFE29,
-  KEY_ISO_Release_Margin_Right      = 0xFE2A,
-  KEY_ISO_Release_Both_Margins      = 0xFE2B,
-  KEY_ISO_Fast_Cursor_Left          = 0xFE2C,
-  KEY_ISO_Fast_Cursor_Right         = 0xFE2D,
-  KEY_ISO_Fast_Cursor_Up            = 0xFE2E,
-  KEY_ISO_Fast_Cursor_Down          = 0xFE2F,
-  KEY_ISO_Continuous_Underline      = 0xFE30,
-  KEY_ISO_Discontinuous_Underline   = 0xFE31,
-  KEY_ISO_Emphasize                 = 0xFE32,
-  KEY_ISO_Center_Object             = 0xFE33,
-  KEY_ISO_Enter                     = 0xFE34,
-
-  KEY_dead_grave                    = 0xFE50,
-  KEY_dead_acute                    = 0xFE51,
-  KEY_dead_circumflex               = 0xFE52,
-  KEY_dead_tilde                    = 0xFE53,
-  KEY_dead_macron                   = 0xFE54,
-  KEY_dead_breve                    = 0xFE55,
-  KEY_dead_abovedot                 = 0xFE56,
-  KEY_dead_diaeresis                = 0xFE57,
-  KEY_dead_abovering                = 0xFE58,
-  KEY_dead_doubleacute              = 0xFE59,
-  KEY_dead_caron                    = 0xFE5A,
-  KEY_dead_cedilla                  = 0xFE5B,
-  KEY_dead_ogonek                   = 0xFE5C,
-  KEY_dead_iota                     = 0xFE5D,
-  KEY_dead_voiced_sound             = 0xFE5E,
-  KEY_dead_semivoiced_sound         = 0xFE5F,
-  KEY_dead_belowdot                 = 0xFE60,
-
-  KEY_First_Virtual_Screen          = 0xFED0,
-  KEY_Prev_Virtual_Screen           = 0xFED1,
-  KEY_Next_Virtual_Screen           = 0xFED2,
-  KEY_Last_Virtual_Screen           = 0xFED4,
-  KEY_Terminate_Server              = 0xFED5,
-
-  KEY_AccessX_Enable                = 0xFE70,
-  KEY_AccessX_Feedback_Enable       = 0xFE71,
-  KEY_RepeatKeys_Enable             = 0xFE72,
-  KEY_SlowKeys_Enable               = 0xFE73,
-  KEY_BounceKeys_Enable             = 0xFE74,
-  KEY_StickyKeys_Enable             = 0xFE75,
-  KEY_MouseKeys_Enable              = 0xFE76,
-  KEY_MouseKeys_Accel_Enable        = 0xFE77,
-  KEY_Overlay1_Enable               = 0xFE78,
-  KEY_Overlay2_Enable               = 0xFE79,
-  KEY_AudibleBell_Enable            = 0xFE7A,
-
-  KEY_Pointer_Left                  = 0xFEE0,
-  KEY_Pointer_Right                 = 0xFEE1,
-  KEY_Pointer_Up                    = 0xFEE2,
-  KEY_Pointer_Down                  = 0xFEE3,
-  KEY_Pointer_UpLeft                = 0xFEE4,
-  KEY_Pointer_UpRight               = 0xFEE5,
-  KEY_Pointer_DownLeft              = 0xFEE6,
-  KEY_Pointer_DownRight             = 0xFEE7,
-  KEY_Pointer_Button_Dflt           = 0xFEE8,
-  KEY_Pointer_Button1               = 0xFEE9,
-  KEY_Pointer_Button2               = 0xFEEA,
-  KEY_Pointer_Button3               = 0xFEEB,
-  KEY_Pointer_Button4               = 0xFEEC,
-  KEY_Pointer_Button5               = 0xFEED,
-  KEY_Pointer_DblClick_Dflt         = 0xFEEE,
-  KEY_Pointer_DblClick1             = 0xFEEF,
-  KEY_Pointer_DblClick2             = 0xFEF0,
-  KEY_Pointer_DblClick3             = 0xFEF1,
-  KEY_Pointer_DblClick4             = 0xFEF2,
-  KEY_Pointer_DblClick5             = 0xFEF3,
-  KEY_Pointer_Drag_Dflt             = 0xFEF4,
-  KEY_Pointer_Drag1                 = 0xFEF5,
-  KEY_Pointer_Drag2                 = 0xFEF6,
-  KEY_Pointer_Drag3                 = 0xFEF7,
-  KEY_Pointer_Drag4                 = 0xFEF8,
-  KEY_Pointer_Drag5                 = 0xFEFD,
-
-  KEY_Pointer_EnableKeys            = 0xFEF9,
-  KEY_Pointer_Accelerate            = 0xFEFA,
-  KEY_Pointer_DfltBtnNext           = 0xFEFB,
-  KEY_Pointer_DfltBtnPrev           = 0xFEFC,
-
-  // 3270 Terminal
-  KEY_3270_Duplicate                = 0xFD01,
-  KEY_3270_FieldMark                = 0xFD02,
-  KEY_3270_Right2                   = 0xFD03,
-  KEY_3270_Left2                    = 0xFD04,
-  KEY_3270_BackTab                  = 0xFD05,
-  KEY_3270_EraseEOF                 = 0xFD06,
-  KEY_3270_EraseInput               = 0xFD07,
-  KEY_3270_Reset                    = 0xFD08,
-  KEY_3270_Quit                     = 0xFD09,
-  KEY_3270_PA1                      = 0xFD0A,
-  KEY_3270_PA2                      = 0xFD0B,
-  KEY_3270_PA3                      = 0xFD0C,
-  KEY_3270_Test                     = 0xFD0D,
-  KEY_3270_Attn                     = 0xFD0E,
-  KEY_3270_CursorBlink              = 0xFD0F,
-  KEY_3270_AltCursor                = 0xFD10,
-  KEY_3270_KeyClick                 = 0xFD11,
-  KEY_3270_Jump                     = 0xFD12,
-  KEY_3270_Ident                    = 0xFD13,
-  KEY_3270_Rule                     = 0xFD14,
-  KEY_3270_Copy                     = 0xFD15,
-  KEY_3270_Play                     = 0xFD16,
-  KEY_3270_Setup                    = 0xFD17,
-  KEY_3270_Record                   = 0xFD18,
-  KEY_3270_ChangeScreen             = 0xFD19,
-  KEY_3270_DeleteWord               = 0xFD1A,
-  KEY_3270_ExSelect                 = 0xFD1B,
-  KEY_3270_CursorSelect             = 0xFD1C,
-  KEY_3270_PrintScreen              = 0xFD1D,
-  KEY_3270_Enter                    = 0xFD1E,
-
-  // Latin 1
-  KEY_space                         = 0x0020,
-  KEY_exclam                        = 0x0021,
-  KEY_quotedbl                      = 0x0022,
-  KEY_numbersign                    = 0x0023,
-  KEY_dollar                        = 0x0024,
-  KEY_percent                       = 0x0025,
-  KEY_ampersand                     = 0x0026,
-  KEY_apostrophe                    = 0x0027,
-  KEY_quoteright                    = 0x0027,
-  KEY_parenleft                     = 0x0028,
-  KEY_parenright                    = 0x0029,
-  KEY_asterisk                      = 0x002A,
-  KEY_plus                          = 0x002B,
-  KEY_comma                         = 0x002C,
-  KEY_minus                         = 0x002D,
-  KEY_period                        = 0x002E,
-  KEY_slash                         = 0x002F,
-  KEY_0                             = 0x0030,
-  KEY_1                             = 0x0031,
-  KEY_2                             = 0x0032,
-  KEY_3                             = 0x0033,
-  KEY_4                             = 0x0034,
-  KEY_5                             = 0x0035,
-  KEY_6                             = 0x0036,
-  KEY_7                             = 0x0037,
-  KEY_8                             = 0x0038,
-  KEY_9                             = 0x0039,
-  KEY_colon                         = 0x003A,
-  KEY_semicolon                     = 0x003B,
-  KEY_less                          = 0x003C,
-  KEY_equal                         = 0x003D,
-  KEY_greater                       = 0x003E,
-  KEY_question                      = 0x003F,
-  KEY_at                            = 0x0040,
-  KEY_A                             = 0x0041,
-  KEY_B                             = 0x0042,
-  KEY_C                             = 0x0043,
-  KEY_D                             = 0x0044,
-  KEY_E                             = 0x0045,
-  KEY_F                             = 0x0046,
-  KEY_G                             = 0x0047,
-  KEY_H                             = 0x0048,
-  KEY_I                             = 0x0049,
-  KEY_J                             = 0x004A,
-  KEY_K                             = 0x004B,
-  KEY_L                             = 0x004C,
-  KEY_M                             = 0x004D,
-  KEY_N                             = 0x004E,
-  KEY_O                             = 0x004F,
-  KEY_P                             = 0x0050,
-  KEY_Q                             = 0x0051,
-  KEY_R                             = 0x0052,
-  KEY_S                             = 0x0053,
-  KEY_T                             = 0x0054,
-  KEY_U                             = 0x0055,
-  KEY_V                             = 0x0056,
-  KEY_W                             = 0x0057,
-  KEY_X                             = 0x0058,
-  KEY_Y                             = 0x0059,
-  KEY_Z                             = 0x005A,
-  KEY_bracketleft                   = 0x005B,
-  KEY_backslash                     = 0x005C,
-  KEY_bracketright                  = 0x005D,
-  KEY_asciicircum                   = 0x005E,
-  KEY_underscore                    = 0x005F,
-  KEY_grave                         = 0x0060,
-  KEY_quoteleft                     = 0x0060,
-  KEY_a                             = 0x0061,
-  KEY_b                             = 0x0062,
-  KEY_c                             = 0x0063,
-  KEY_d                             = 0x0064,
-  KEY_e                             = 0x0065,
-  KEY_f                             = 0x0066,
-  KEY_g                             = 0x0067,
-  KEY_h                             = 0x0068,
-  KEY_i                             = 0x0069,
-  KEY_j                             = 0x006A,
-  KEY_k                             = 0x006B,
-  KEY_l                             = 0x006C,
-  KEY_m                             = 0x006D,
-  KEY_n                             = 0x006E,
-  KEY_o                             = 0x006F,
-  KEY_p                             = 0x0070,
-  KEY_q                             = 0x0071,
-  KEY_r                             = 0x0072,
-  KEY_s                             = 0x0073,
-  KEY_t                             = 0x0074,
-  KEY_u                             = 0x0075,
-  KEY_v                             = 0x0076,
-  KEY_w                             = 0x0077,
-  KEY_x                             = 0x0078,
-  KEY_y                             = 0x0079,
-  KEY_z                             = 0x007A,
-  KEY_braceleft                     = 0x007B,
-  KEY_bar                           = 0x007C,
-  KEY_braceright                    = 0x007D,
-  KEY_asciitilde                    = 0x007E,
-
-  KEY_nobreakspace                  = 0x00A0,
-  KEY_exclamdown                    = 0x00A1,
-  KEY_cent                          = 0x00A2,
-  KEY_sterling                      = 0x00A3,
-  KEY_currency                      = 0x00A4,
-  KEY_yen                           = 0x00A5,
-  KEY_brokenbar                     = 0x00A6,
-  KEY_section                       = 0x00A7,
-  KEY_diaeresis                     = 0x00A8,
-  KEY_copyright                     = 0x00A9,
-  KEY_ordfeminine                   = 0x00AA,
-  KEY_guillemotleft                 = 0x00AB,
-  KEY_notsign                       = 0x00AC,
-  KEY_hyphen                        = 0x00AD,
-  KEY_registered                    = 0x00AE,
-  KEY_macron                        = 0x00AF,
-  KEY_degree                        = 0x00B0,
-  KEY_plusminus                     = 0x00B1,
-  KEY_twosuperior                   = 0x00B2,
-  KEY_threesuperior                 = 0x00B3,
-  KEY_acute                         = 0x00B4,
-  KEY_mu                            = 0x00B5,
-  KEY_paragraph                     = 0x00B6,
-  KEY_periodcentered                = 0x00B7,
-  KEY_cedilla                       = 0x00B8,
-  KEY_onesuperior                   = 0x00B9,
-  KEY_masculine                     = 0x00BA,
-  KEY_guillemotright                = 0x00BB,
-  KEY_onequarter                    = 0x00BC,
-  KEY_onehalf                       = 0x00BD,
-  KEY_threequarters                 = 0x00BE,
-  KEY_questiondown                  = 0x00BF,
-  KEY_Agrave                        = 0x00C0,
-  KEY_Aacute                        = 0x00C1,
-  KEY_Acircumflex                   = 0x00C2,
-  KEY_Atilde                        = 0x00C3,
-  KEY_Adiaeresis                    = 0x00C4,
-  KEY_Aring                         = 0x00C5,
-  KEY_AE                            = 0x00C6,
-  KEY_Ccedilla                      = 0x00C7,
-  KEY_Egrave                        = 0x00C8,
-  KEY_Eacute                        = 0x00C9,
-  KEY_Ecircumflex                   = 0x00CA,
-  KEY_Ediaeresis                    = 0x00CB,
-  KEY_Igrave                        = 0x00CC,
-  KEY_Iacute                        = 0x00CD,
-  KEY_Icircumflex                   = 0x00CE,
-  KEY_Idiaeresis                    = 0x00CF,
-  KEY_ETH                           = 0x00D0,
-  KEY_Eth                           = 0x00D0,
-  KEY_Ntilde                        = 0x00D1,
-  KEY_Ograve                        = 0x00D2,
-  KEY_Oacute                        = 0x00D3,
-  KEY_Ocircumflex                   = 0x00D4,
-  KEY_Otilde                        = 0x00D5,
-  KEY_Odiaeresis                    = 0x00D6,
-  KEY_multiply                      = 0x00D7,
-  KEY_Ooblique                      = 0x00D8,
-  KEY_Ugrave                        = 0x00D9,
-  KEY_Uacute                        = 0x00DA,
-  KEY_Ucircumflex                   = 0x00DB,
-  KEY_Udiaeresis                    = 0x00DC,
-  KEY_Yacute                        = 0x00DD,
-  KEY_THORN                         = 0x00DE,
-  KEY_Thorn                         = 0x00DE,
-  KEY_ssharp                        = 0x00DF,
-  KEY_agrave                        = 0x00E0,
-  KEY_aacute                        = 0x00E1,
-  KEY_acircumflex                   = 0x00E2,
-  KEY_atilde                        = 0x00E3,
-  KEY_adiaeresis                    = 0x00E4,
-  KEY_aring                         = 0x00E5,
-  KEY_ae                            = 0x00E6,
-  KEY_ccedilla                      = 0x00E7,
-  KEY_egrave                        = 0x00E8,
-  KEY_eacute                        = 0x00E9,
-  KEY_ecircumflex                   = 0x00EA,
-  KEY_ediaeresis                    = 0x00EB,
-  KEY_igrave                        = 0x00EC,
-  KEY_iacute                        = 0x00ED,
-  KEY_icircumflex                   = 0x00EE,
-  KEY_idiaeresis                    = 0x00EF,
-  KEY_eth                           = 0x00F0,
-  KEY_ntilde                        = 0x00F1,
-  KEY_ograve                        = 0x00F2,
-  KEY_oacute                        = 0x00F3,
-  KEY_ocircumflex                   = 0x00F4,
-  KEY_otilde                        = 0x00F5,
-  KEY_odiaeresis                    = 0x00F6,
-  KEY_division                      = 0x00F7,
-  KEY_oslash                        = 0x00F8,
-  KEY_ugrave                        = 0x00F9,
-  KEY_uacute                        = 0x00FA,
-  KEY_ucircumflex                   = 0x00FB,
-  KEY_udiaeresis                    = 0x00FC,
-  KEY_yacute                        = 0x00FD,
-  KEY_thorn                         = 0x00FE,
-  KEY_ydiaeresis                    = 0x00FF,
-
-  // Latin 2
-  KEY_Aogonek                       = 0x01A1,
-  KEY_breve                         = 0x01A2,
-  KEY_Lstroke                       = 0x01A3,
-  KEY_Lcaron                        = 0x01A5,
-  KEY_Sacute                        = 0x01A6,
-  KEY_Scaron                        = 0x01A9,
-  KEY_Scedilla                      = 0x01AA,
-  KEY_Tcaron                        = 0x01AB,
-  KEY_Zacute                        = 0x01AC,
-  KEY_Zcaron                        = 0x01AE,
-  KEY_Zabovedot                     = 0x01AF,
-  KEY_aogonek                       = 0x01B1,
-  KEY_ogonek                        = 0x01B2,
-  KEY_lstroke                       = 0x01B3,
-  KEY_lcaron                        = 0x01B5,
-  KEY_sacute                        = 0x01B6,
-  KEY_caron                         = 0x01B7,
-  KEY_scaron                        = 0x01B9,
-  KEY_scedilla                      = 0x01BA,
-  KEY_tcaron                        = 0x01BB,
-  KEY_zacute                        = 0x01BC,
-  KEY_doubleacute                   = 0x01BD,
-  KEY_zcaron                        = 0x01BE,
-  KEY_zabovedot                     = 0x01BF,
-  KEY_Racute                        = 0x01C0,
-  KEY_Abreve                        = 0x01C3,
-  KEY_Lacute                        = 0x01C5,
-  KEY_Cacute                        = 0x01C6,
-  KEY_Ccaron                        = 0x01C8,
-  KEY_Eogonek                       = 0x01CA,
-  KEY_Ecaron                        = 0x01CC,
-  KEY_Dcaron                        = 0x01CF,
-  KEY_Dstroke                       = 0x01D0,
-  KEY_Nacute                        = 0x01D1,
-  KEY_Ncaron                        = 0x01D2,
-  KEY_Odoubleacute                  = 0x01D5,
-  KEY_Rcaron                        = 0x01D8,
-  KEY_Uring                         = 0x01D9,
-  KEY_Udoubleacute                  = 0x01DB,
-  KEY_Tcedilla                      = 0x01DE,
-  KEY_racute                        = 0x01E0,
-  KEY_abreve                        = 0x01E3,
-  KEY_lacute                        = 0x01E5,
-  KEY_cacute                        = 0x01E6,
-  KEY_ccaron                        = 0x01E8,
-  KEY_eogonek                       = 0x01EA,
-  KEY_ecaron                        = 0x01EC,
-  KEY_dcaron                        = 0x01EF,
-  KEY_dstroke                       = 0x01F0,
-  KEY_nacute                        = 0x01F1,
-  KEY_ncaron                        = 0x01F2,
-  KEY_odoubleacute                  = 0x01F5,
-  KEY_udoubleacute                  = 0x01FB,
-  KEY_rcaron                        = 0x01F8,
-  KEY_uring                         = 0x01F9,
-  KEY_tcedilla                      = 0x01FE,
-  KEY_abovedot                      = 0x01FF,
-
-  // Latin 3
-  KEY_Hstroke                       = 0x02A1,
-  KEY_Hcircumflex                   = 0x02A6,
-  KEY_Iabovedot                     = 0x02A9,
-  KEY_Gbreve                        = 0x02AB,
-  KEY_Jcircumflex                   = 0x02AC,
-  KEY_hstroke                       = 0x02B1,
-  KEY_hcircumflex                   = 0x02B6,
-  KEY_idotless                      = 0x02B9,
-  KEY_gbreve                        = 0x02BB,
-  KEY_jcircumflex                   = 0x02BC,
-  KEY_Cabovedot                     = 0x02C5,
-  KEY_Ccircumflex                   = 0x02C6,
-  KEY_Gabovedot                     = 0x02D5,
-  KEY_Gcircumflex                   = 0x02D8,
-  KEY_Ubreve                        = 0x02DD,
-  KEY_Scircumflex                   = 0x02DE,
-  KEY_cabovedot                     = 0x02E5,
-  KEY_ccircumflex                   = 0x02E6,
-  KEY_gabovedot                     = 0x02F5,
-  KEY_gcircumflex                   = 0x02F8,
-  KEY_ubreve                        = 0x02FD,
-  KEY_scircumflex                   = 0x02FE,
-
-
-  // Latin 4
-  KEY_kra                           = 0x03A2,
-  KEY_kappa                         = 0x03A2,
-  KEY_Rcedilla                      = 0x03A3,
-  KEY_Itilde                        = 0x03A5,
-  KEY_Lcedilla                      = 0x03A6,
-  KEY_Emacron                       = 0x03AA,
-  KEY_Gcedilla                      = 0x03AB,
-  KEY_Tslash                        = 0x03AC,
-  KEY_rcedilla                      = 0x03B3,
-  KEY_itilde                        = 0x03B5,
-  KEY_lcedilla                      = 0x03B6,
-  KEY_emacron                       = 0x03BA,
-  KEY_gcedilla                      = 0x03BB,
-  KEY_tslash                        = 0x03BC,
-  KEY_ENG                           = 0x03BD,
-  KEY_eng                           = 0x03BF,
-  KEY_Amacron                       = 0x03C0,
-  KEY_Iogonek                       = 0x03C7,
-  KEY_Eabovedot                     = 0x03CC,
-  KEY_Imacron                       = 0x03CF,
-  KEY_Ncedilla                      = 0x03D1,
-  KEY_Omacron                       = 0x03D2,
-  KEY_Kcedilla                      = 0x03D3,
-  KEY_Uogonek                       = 0x03D9,
-  KEY_Utilde                        = 0x03DD,
-  KEY_Umacron                       = 0x03DE,
-  KEY_amacron                       = 0x03E0,
-  KEY_iogonek                       = 0x03E7,
-  KEY_eabovedot                     = 0x03EC,
-  KEY_imacron                       = 0x03EF,
-  KEY_ncedilla                      = 0x03F1,
-  KEY_omacron                       = 0x03F2,
-  KEY_kcedilla                      = 0x03F3,
-  KEY_uogonek                       = 0x03F9,
-  KEY_utilde                        = 0x03FD,
-  KEY_umacron                       = 0x03FE,
-
-  // Katakana
-  KEY_overline                      = 0x047E,
-  KEY_kana_fullstop                 = 0x04A1,
-  KEY_kana_openingbracket           = 0x04A2,
-  KEY_kana_closingbracket           = 0x04A3,
-  KEY_kana_comma                    = 0x04A4,
-  KEY_kana_conjunctive              = 0x04A5,
-  KEY_kana_middledot                = 0x04A5,
-  KEY_kana_WO                       = 0x04A6,
-  KEY_kana_a                        = 0x04A7,
-  KEY_kana_i                        = 0x04A8,
-  KEY_kana_u                        = 0x04A9,
-  KEY_kana_e                        = 0x04AA,
-  KEY_kana_o                        = 0x04AB,
-  KEY_kana_ya                       = 0x04AC,
-  KEY_kana_yu                       = 0x04AD,
-  KEY_kana_yo                       = 0x04AE,
-  KEY_kana_tsu                      = 0x04AF,
-  KEY_kana_tu                       = 0x04AF,
-  KEY_prolongedsound                = 0x04B0,
-  KEY_kana_A                        = 0x04B1,
-  KEY_kana_I                        = 0x04B2,
-  KEY_kana_U                        = 0x04B3,
-  KEY_kana_E                        = 0x04B4,
-  KEY_kana_O                        = 0x04B5,
-  KEY_kana_KA                       = 0x04B6,
-  KEY_kana_KI                       = 0x04B7,
-  KEY_kana_KU                       = 0x04B8,
-  KEY_kana_KE                       = 0x04B9,
-  KEY_kana_KO                       = 0x04BA,
-  KEY_kana_SA                       = 0x04BB,
-  KEY_kana_SHI                      = 0x04BC,
-  KEY_kana_SU                       = 0x04BD,
-  KEY_kana_SE                       = 0x04BE,
-  KEY_kana_SO                       = 0x04BF,
-  KEY_kana_TA                       = 0x04C0,
-  KEY_kana_CHI                      = 0x04C1,
-  KEY_kana_TI                       = 0x04C1,
-  KEY_kana_TSU                      = 0x04C2,
-  KEY_kana_TU                       = 0x04C2,
-  KEY_kana_TE                       = 0x04C3,
-  KEY_kana_TO                       = 0x04C4,
-  KEY_kana_NA                       = 0x04C5,
-  KEY_kana_NI                       = 0x04C6,
-  KEY_kana_NU                       = 0x04C7,
-  KEY_kana_NE                       = 0x04C8,
-  KEY_kana_NO                       = 0x04C9,
-  KEY_kana_HA                       = 0x04CA,
-  KEY_kana_HI                       = 0x04CB,
-  KEY_kana_FU                       = 0x04CC,
-  KEY_kana_HU                       = 0x04CC,
-  KEY_kana_HE                       = 0x04CD,
-  KEY_kana_HO                       = 0x04CE,
-  KEY_kana_MA                       = 0x04CF,
-  KEY_kana_MI                       = 0x04D0,
-  KEY_kana_MU                       = 0x04D1,
-  KEY_kana_ME                       = 0x04D2,
-  KEY_kana_MO                       = 0x04D3,
-  KEY_kana_YA                       = 0x04D4,
-  KEY_kana_YU                       = 0x04D5,
-  KEY_kana_YO                       = 0x04D6,
-  KEY_kana_RA                       = 0x04D7,
-  KEY_kana_RI                       = 0x04D8,
-  KEY_kana_RU                       = 0x04D9,
-  KEY_kana_RE                       = 0x04DA,
-  KEY_kana_RO                       = 0x04DB,
-  KEY_kana_WA                       = 0x04DC,
-  KEY_kana_N                        = 0x04DD,
-  KEY_voicedsound                   = 0x04DE,
-  KEY_semivoicedsound               = 0x04DF,
-  KEY_kana_switch                   = 0x0FF7,
-
-  // Arabic
-  KEY_Arabic_comma                  = 0x05AC,
-  KEY_Arabic_semicolon              = 0x05BB,
-  KEY_Arabic_question_mark          = 0x05BF,
-  KEY_Arabic_hamza                  = 0x05C1,
-  KEY_Arabic_maddaonalef            = 0x05C2,
-  KEY_Arabic_hamzaonalef            = 0x05C3,
-  KEY_Arabic_hamzaonwaw             = 0x05C4,
-  KEY_Arabic_hamzaunderalef         = 0x05C5,
-  KEY_Arabic_hamzaonyeh             = 0x05C6,
-  KEY_Arabic_alef                   = 0x05C7,
-  KEY_Arabic_beh                    = 0x05C8,
-  KEY_Arabic_tehmarbuta             = 0x05C9,
-  KEY_Arabic_teh                    = 0x05CA,
-  KEY_Arabic_theh                   = 0x05CB,
-  KEY_Arabic_jeem                   = 0x05CC,
-  KEY_Arabic_hah                    = 0x05CD,
-  KEY_Arabic_khah                   = 0x05CE,
-  KEY_Arabic_dal                    = 0x05CF,
-  KEY_Arabic_thal                   = 0x05D0,
-  KEY_Arabic_ra                     = 0x05D1,
-  KEY_Arabic_zain                   = 0x05D2,
-  KEY_Arabic_seen                   = 0x05D3,
-  KEY_Arabic_sheen                  = 0x05D4,
-  KEY_Arabic_sad                    = 0x05D5,
-  KEY_Arabic_dad                    = 0x05D6,
-  KEY_Arabic_tah                    = 0x05D7,
-  KEY_Arabic_zah                    = 0x05D8,
-  KEY_Arabic_ain                    = 0x05D9,
-  KEY_Arabic_ghain                  = 0x05DA,
-  KEY_Arabic_tatweel                = 0x05E0,
-  KEY_Arabic_feh                    = 0x05E1,
-  KEY_Arabic_qaf                    = 0x05E2,
-  KEY_Arabic_kaf                    = 0x05E3,
-  KEY_Arabic_lam                    = 0x05E4,
-  KEY_Arabic_meem                   = 0x05E5,
-  KEY_Arabic_noon                   = 0x05E6,
-  KEY_Arabic_ha                     = 0x05E7,
-  KEY_Arabic_heh                    = 0x05E7,
-  KEY_Arabic_waw                    = 0x05E8,
-  KEY_Arabic_alefmaksura            = 0x05E9,
-  KEY_Arabic_yeh                    = 0x05EA,
-  KEY_Arabic_fathatan               = 0x05EB,
-  KEY_Arabic_dammatan               = 0x05EC,
-  KEY_Arabic_kasratan               = 0x05ED,
-  KEY_Arabic_fatha                  = 0x05EE,
-  KEY_Arabic_damma                  = 0x05EF,
-  KEY_Arabic_kasra                  = 0x05F0,
-  KEY_Arabic_shadda                 = 0x05F1,
-  KEY_Arabic_sukun                  = 0x05F2,
-  KEY_Arabic_switch                 = 0xFF7E,
-
-  // Cyrillic
-  KEY_Serbian_dje                   = 0x06A1,
-  KEY_Macedonia_gje                 = 0x06A2,
-  KEY_Cyrillic_io                   = 0x06A3,
-  KEY_Ukrainian_ie                  = 0x06A4,
-  KEY_Ukranian_je                   = 0x06A4,
-  KEY_Macedonia_dse                 = 0x06A5,
-  KEY_Ukrainian_i                   = 0x06A6,
-  KEY_Ukranian_i                    = 0x06A6,
-  KEY_Ukrainian_yi                  = 0x06A7,
-  KEY_Ukranian_yi                   = 0x06A7,
-  KEY_Cyrillic_je                   = 0x06A8,
-  KEY_Serbian_je                    = 0x06A8,
-  KEY_Cyrillic_lje                  = 0x06A9,
-  KEY_Serbian_lje                   = 0x06A9,
-  KEY_Cyrillic_nje                  = 0x06AA,
-  KEY_Serbian_nje                   = 0x06AA,
-  KEY_Serbian_tshe                  = 0x06AB,
-  KEY_Macedonia_kje                 = 0x06AC,
-  KEY_Byelorussian_shortu           = 0x06AE,
-  KEY_Cyrillic_dzhe                 = 0x06AF,
-  KEY_Serbian_dze                   = 0x06AF,
-  KEY_numerosign                    = 0x06B0,
-  KEY_Serbian_DJE                   = 0x06B1,
-  KEY_Macedonia_GJE                 = 0x06B2,
-  KEY_Cyrillic_IO                   = 0x06B3,
-  KEY_Ukrainian_IE                  = 0x06B4,
-  KEY_Ukranian_JE                   = 0x06B4,
-  KEY_Macedonia_DSE                 = 0x06B5,
-  KEY_Ukrainian_I                   = 0x06B6,
-  KEY_Ukranian_I                    = 0x06B6,
-  KEY_Ukrainian_YI                  = 0x06B7,
-  KEY_Ukranian_YI                   = 0x06B7,
-  KEY_Cyrillic_JE                   = 0x06B8,
-  KEY_Serbian_JE                    = 0x06B8,
-  KEY_Cyrillic_LJE                  = 0x06B9,
-  KEY_Serbian_LJE                   = 0x06B9,
-  KEY_Cyrillic_NJE                  = 0x06BA,
-  KEY_Serbian_NJE                   = 0x06BA,
-  KEY_Serbian_TSHE                  = 0x06BB,
-  KEY_Macedonia_KJE                 = 0x06BC,
-  KEY_Byelorussian_SHORTU           = 0x06BE,
-  KEY_Cyrillic_DZHE                 = 0x06BF,
-  KEY_Serbian_DZE                   = 0x06BF,
-  KEY_Cyrillic_yu                   = 0x06C0,
-  KEY_Cyrillic_a                    = 0x06C1,
-  KEY_Cyrillic_be                   = 0x06C2,
-  KEY_Cyrillic_tse                  = 0x06C3,
-  KEY_Cyrillic_de                   = 0x06C4,
-  KEY_Cyrillic_ie                   = 0x06C5,
-  KEY_Cyrillic_ef                   = 0x06C6,
-  KEY_Cyrillic_ghe                  = 0x06C7,
-  KEY_Cyrillic_ha                   = 0x06C8,
-  KEY_Cyrillic_i                    = 0x06C9,
-  KEY_Cyrillic_shorti               = 0x06CA,
-  KEY_Cyrillic_ka                   = 0x06CB,
-  KEY_Cyrillic_el                   = 0x06CC,
-  KEY_Cyrillic_em                   = 0x06CD,
-  KEY_Cyrillic_en                   = 0x06CE,
-  KEY_Cyrillic_o                    = 0x06CF,
-  KEY_Cyrillic_pe                   = 0x06D0,
-  KEY_Cyrillic_ya                   = 0x06D1,
-  KEY_Cyrillic_er                   = 0x06D2,
-  KEY_Cyrillic_es                   = 0x06D3,
-  KEY_Cyrillic_te                   = 0x06D4,
-  KEY_Cyrillic_u                    = 0x06D5,
-  KEY_Cyrillic_zhe                  = 0x06D6,
-  KEY_Cyrillic_ve                   = 0x06D7,
-  KEY_Cyrillic_softsign             = 0x06D8,
-  KEY_Cyrillic_yeru                 = 0x06D9,
-  KEY_Cyrillic_ze                   = 0x06DA,
-  KEY_Cyrillic_sha                  = 0x06DB,
-  KEY_Cyrillic_e                    = 0x06DC,
-  KEY_Cyrillic_shcha                = 0x06DD,
-  KEY_Cyrillic_che                  = 0x06DE,
-  KEY_Cyrillic_hardsign             = 0x06DF,
-  KEY_Cyrillic_YU                   = 0x06E0,
-  KEY_Cyrillic_A                    = 0x06E1,
-  KEY_Cyrillic_BE                   = 0x06E2,
-  KEY_Cyrillic_TSE                  = 0x06E3,
-  KEY_Cyrillic_DE                   = 0x06E4,
-  KEY_Cyrillic_IE                   = 0x06E5,
-  KEY_Cyrillic_EF                   = 0x06E6,
-  KEY_Cyrillic_GHE                  = 0x06E7,
-  KEY_Cyrillic_HA                   = 0x06E8,
-  KEY_Cyrillic_I                    = 0x06E9,
-  KEY_Cyrillic_SHORTI               = 0x06EA,
-  KEY_Cyrillic_KA                   = 0x06EB,
-  KEY_Cyrillic_EL                   = 0x06EC,
-  KEY_Cyrillic_EM                   = 0x06ED,
-  KEY_Cyrillic_EN                   = 0x06EE,
-  KEY_Cyrillic_O                    = 0x06EF,
-  KEY_Cyrillic_PE                   = 0x06F0,
-  KEY_Cyrillic_YA                   = 0x06F1,
-  KEY_Cyrillic_ER                   = 0x06F2,
-  KEY_Cyrillic_ES                   = 0x06F3,
-  KEY_Cyrillic_TE                   = 0x06F4,
-  KEY_Cyrillic_U                    = 0x06F5,
-  KEY_Cyrillic_ZHE                  = 0x06F6,
-  KEY_Cyrillic_VE                   = 0x06F7,
-  KEY_Cyrillic_SOFTSIGN             = 0x06F8,
-  KEY_Cyrillic_YERU                 = 0x06F9,
-  KEY_Cyrillic_ZE                   = 0x06FA,
-  KEY_Cyrillic_SHA                  = 0x06FB,
-  KEY_Cyrillic_E                    = 0x06FC,
-  KEY_Cyrillic_SHCHA                = 0x06FD,
-  KEY_Cyrillic_CHE                  = 0x06FE,
-  KEY_Cyrillic_HARDSIGN             = 0x06FF,
-
-  // Greek
-  KEY_Greek_ALPHAaccent             = 0x07A1,
-  KEY_Greek_EPSILONaccent           = 0x07A2,
-  KEY_Greek_ETAaccent               = 0x07A3,
-  KEY_Greek_IOTAaccent              = 0x07A4,
-  KEY_Greek_IOTAdiaeresis           = 0x07A5,
-  KEY_Greek_OMICRONaccent           = 0x07A7,
-  KEY_Greek_UPSILONaccent           = 0x07A8,
-  KEY_Greek_UPSILONdieresis         = 0x07A9,
-  KEY_Greek_OMEGAaccent             = 0x07AB,
-  KEY_Greek_accentdieresis          = 0x07AE,
-  KEY_Greek_horizbar                = 0x07AF,
-  KEY_Greek_alphaaccent             = 0x07B1,
-  KEY_Greek_epsilonaccent           = 0x07B2,
-  KEY_Greek_etaaccent               = 0x07B3,
-  KEY_Greek_iotaaccent              = 0x07B4,
-  KEY_Greek_iotadieresis            = 0x07B5,
-  KEY_Greek_iotaaccentdieresis      = 0x07B6,
-  KEY_Greek_omicronaccent           = 0x07B7,
-  KEY_Greek_upsilonaccent           = 0x07B8,
-  KEY_Greek_upsilondieresis         = 0x07B9,
-  KEY_Greek_upsilonaccentdieresis   = 0x07BA,
-  KEY_Greek_omegaaccent             = 0x07BB,
-  KEY_Greek_ALPHA                   = 0x07C1,
-  KEY_Greek_BETA                    = 0x07C2,
-  KEY_Greek_GAMMA                   = 0x07C3,
-  KEY_Greek_DELTA                   = 0x07C4,
-  KEY_Greek_EPSILON                 = 0x07C5,
-  KEY_Greek_ZETA                    = 0x07C6,
-  KEY_Greek_ETA                     = 0x07C7,
-  KEY_Greek_THETA                   = 0x07C8,
-  KEY_Greek_IOTA                    = 0x07C9,
-  KEY_Greek_KAPPA                   = 0x07CA,
-  KEY_Greek_LAMDA                   = 0x07CB,
-  KEY_Greek_LAMBDA                  = 0x07CB,
-  KEY_Greek_MU                      = 0x07CC,
-  KEY_Greek_NU                      = 0x07CD,
-  KEY_Greek_XI                      = 0x07CE,
-  KEY_Greek_OMICRON                 = 0x07CF,
-  KEY_Greek_PI                      = 0x07D0,
-  KEY_Greek_RHO                     = 0x07D1,
-  KEY_Greek_SIGMA                   = 0x07D2,
-  KEY_Greek_TAU                     = 0x07D4,
-  KEY_Greek_UPSILON                 = 0x07D5,
-  KEY_Greek_PHI                     = 0x07D6,
-  KEY_Greek_CHI                     = 0x07D7,
-  KEY_Greek_PSI                     = 0x07D8,
-  KEY_Greek_OMEGA                   = 0x07D9,
-  KEY_Greek_alpha                   = 0x07E1,
-  KEY_Greek_beta                    = 0x07E2,
-  KEY_Greek_gamma                   = 0x07E3,
-  KEY_Greek_delta                   = 0x07E4,
-  KEY_Greek_epsilon                 = 0x07E5,
-  KEY_Greek_zeta                    = 0x07E6,
-  KEY_Greek_eta                     = 0x07E7,
-  KEY_Greek_theta                   = 0x07E8,
-  KEY_Greek_iota                    = 0x07E9,
-  KEY_Greek_kappa                   = 0x07EA,
-  KEY_Greek_lamda                   = 0x07EB,
-  KEY_Greek_lambda                  = 0x07EB,
-  KEY_Greek_mu                      = 0x07EC,
-  KEY_Greek_nu                      = 0x07ED,
-  KEY_Greek_xi                      = 0x07EE,
-  KEY_Greek_omicron                 = 0x07EF,
-  KEY_Greek_pi                      = 0x07F0,
-  KEY_Greek_rho                     = 0x07F1,
-  KEY_Greek_sigma                   = 0x07F2,
-  KEY_Greek_finalsmallsigma         = 0x07F3,
-  KEY_Greek_tau                     = 0x07F4,
-  KEY_Greek_upsilon                 = 0x07F5,
-  KEY_Greek_phi                     = 0x07F6,
-  KEY_Greek_chi                     = 0x07F7,
-  KEY_Greek_psi                     = 0x07F8,
-  KEY_Greek_omega                   = 0x07F9,
-  KEY_Greek_switch                  = 0xFF7E,
-
-  // Technical
-  KEY_leftradical                   = 0x08A1,
-  KEY_topleftradical                = 0x08A2,
-  KEY_horizconnector                = 0x08A3,
-  KEY_topintegral                   = 0x08A4,
-  KEY_botintegral                   = 0x08A5,
-  KEY_vertconnector                 = 0x08A6,
-  KEY_topleftsqbracket              = 0x08A7,
-  KEY_botleftsqbracket              = 0x08A8,
-  KEY_toprightsqbracket             = 0x08A9,
-  KEY_botrightsqbracket             = 0x08AA,
-  KEY_topleftparens                 = 0x08AB,
-  KEY_botleftparens                 = 0x08AC,
-  KEY_toprightparens                = 0x08AD,
-  KEY_botrightparens                = 0x08AE,
-  KEY_leftmiddlecurlybrace          = 0x08AF,
-  KEY_rightmiddlecurlybrace         = 0x08B0,
-  KEY_topleftsummation              = 0x08B1,
-  KEY_botleftsummation              = 0x08B2,
-  KEY_topvertsummationconnector     = 0x08B3,
-  KEY_botvertsummationconnector     = 0x08B4,
-  KEY_toprightsummation             = 0x08B5,
-  KEY_botrightsummation             = 0x08B6,
-  KEY_rightmiddlesummation          = 0x08B7,
-  KEY_lessthanequal                 = 0x08BC,
-  KEY_notequal                      = 0x08BD,
-  KEY_greaterthanequal              = 0x08BE,
-  KEY_integral                      = 0x08BF,
-  KEY_therefore                     = 0x08C0,
-  KEY_variation                     = 0x08C1,
-  KEY_infinity                      = 0x08C2,
-  KEY_nabla                         = 0x08C5,
-  KEY_approximate                   = 0x08C8,
-  KEY_similarequal                  = 0x08C9,
-  KEY_ifonlyif                      = 0x08CD,
-  KEY_implies                       = 0x08CE,
-  KEY_identical                     = 0x08CF,
-  KEY_radical                       = 0x08D6,
-  KEY_includedin                    = 0x08DA,
-  KEY_includes                      = 0x08DB,
-  KEY_intersection                  = 0x08DC,
-  KEY_union                         = 0x08DD,
-  KEY_logicaland                    = 0x08DE,
-  KEY_logicalor                     = 0x08DF,
-  KEY_partialderivative             = 0x08EF,
-  KEY_function                      = 0x08F6,
-  KEY_leftarrow                     = 0x08FB,
-  KEY_uparrow                       = 0x08FC,
-  KEY_rightarrow                    = 0x08FD,
-  KEY_downarrow                     = 0x08FE,
-
-  // Special
-  KEY_blank                         = 0x09DF,
-  KEY_soliddiamond                  = 0x09E0,
-  KEY_checkerboard                  = 0x09E1,
-  KEY_ht                            = 0x09E2,
-  KEY_ff                            = 0x09E3,
-  KEY_cr                            = 0x09E4,
-  KEY_lf                            = 0x09E5,
-  KEY_nl                            = 0x09E8,
-  KEY_vt                            = 0x09E9,
-  KEY_lowrightcorner                = 0x09EA,
-  KEY_uprightcorner                 = 0x09EB,
-  KEY_upleftcorner                  = 0x09EC,
-  KEY_lowleftcorner                 = 0x09ED,
-  KEY_crossinglines                 = 0x09EE,
-  KEY_horizlinescan1                = 0x09EF,
-  KEY_horizlinescan3                = 0x09F0,
-  KEY_horizlinescan5                = 0x09F1,
-  KEY_horizlinescan7                = 0x09F2,
-  KEY_horizlinescan9                = 0x09F3,
-  KEY_leftt                         = 0x09F4,
-  KEY_rightt                        = 0x09F5,
-  KEY_bott                          = 0x09F6,
-  KEY_topt                          = 0x09F7,
-  KEY_vertbar                       = 0x09F8,
-
-  // Publishing
-  KEY_emspace                       = 0x0AA1,
-  KEY_enspace                       = 0x0AA2,
-  KEY_em3space                      = 0x0AA3,
-  KEY_em4space                      = 0x0AA4,
-  KEY_digitspace                    = 0x0AA5,
-  KEY_punctspace                    = 0x0AA6,
-  KEY_thinspace                     = 0x0AA7,
-  KEY_hairspace                     = 0x0AA8,
-  KEY_emdash                        = 0x0AA9,
-  KEY_endash                        = 0x0AAA,
-  KEY_signifblank                   = 0x0AAC,
-  KEY_ellipsis                      = 0x0AAE,
-  KEY_doubbaselinedot               = 0x0AAF,
-  KEY_onethird                      = 0x0AB0,
-  KEY_twothirds                     = 0x0AB1,
-  KEY_onefifth                      = 0x0AB2,
-  KEY_twofifths                     = 0x0AB3,
-  KEY_threefifths                   = 0x0AB4,
-  KEY_fourfifths                    = 0x0AB5,
-  KEY_onesixth                      = 0x0AB6,
-  KEY_fivesixths                    = 0x0AB7,
-  KEY_careof                        = 0x0AB8,
-  KEY_figdash                       = 0x0ABB,
-  KEY_leftanglebracket              = 0x0ABC,
-  KEY_decimalpoint                  = 0x0ABD,
-  KEY_rightanglebracket             = 0x0ABE,
-  KEY_marker                        = 0x0ABF,
-  KEY_oneeighth                     = 0x0AC3,
-  KEY_threeeighths                  = 0x0AC4,
-  KEY_fiveeighths                   = 0x0AC5,
-  KEY_seveneighths                  = 0x0AC6,
-  KEY_trademark                     = 0x0AC9,
-  KEY_signaturemark                 = 0x0ACA,
-  KEY_trademarkincircle             = 0x0ACB,
-  KEY_leftopentriangle              = 0x0ACC,
-  KEY_rightopentriangle             = 0x0ACD,
-  KEY_emopencircle                  = 0x0ACE,
-  KEY_emopenrectangle               = 0x0ACF,
-  KEY_leftsinglequotemark           = 0x0AD0,
-  KEY_rightsinglequotemark          = 0x0AD1,
-  KEY_leftdoublequotemark           = 0x0AD2,
-  KEY_rightdoublequotemark          = 0x0AD3,
-  KEY_prescription                  = 0x0AD4,
-  KEY_minutes                       = 0x0AD6,
-  KEY_seconds                       = 0x0AD7,
-  KEY_latincross                    = 0x0AD9,
-  KEY_hexagram                      = 0x0ADA,
-  KEY_filledrectbullet              = 0x0ADB,
-  KEY_filledlefttribullet           = 0x0ADC,
-  KEY_filledrighttribullet          = 0x0ADD,
-  KEY_emfilledcircle                = 0x0ADE,
-  KEY_emfilledrect                  = 0x0ADF,
-  KEY_enopencircbullet              = 0x0AE0,
-  KEY_enopensquarebullet            = 0x0AE1,
-  KEY_openrectbullet                = 0x0AE2,
-  KEY_opentribulletup               = 0x0AE3,
-  KEY_opentribulletdown             = 0x0AE4,
-  KEY_openstar                      = 0x0AE5,
-  KEY_enfilledcircbullet            = 0x0AE6,
-  KEY_enfilledsqbullet              = 0x0AE7,
-  KEY_filledtribulletup             = 0x0AE8,
-  KEY_filledtribulletdown           = 0x0AE9,
-  KEY_leftpointer                   = 0x0AEA,
-  KEY_rightpointer                  = 0x0AEB,
-  KEY_club                          = 0x0AEC,
-  KEY_diamond                       = 0x0AED,
-  KEY_heart                         = 0x0AEE,
-  KEY_maltesecross                  = 0x0AF0,
-  KEY_dagger                        = 0x0AF1,
-  KEY_doubledagger                  = 0x0AF2,
-  KEY_checkmark                     = 0x0AF3,
-  KEY_ballotcross                   = 0x0AF4,
-  KEY_musicalsharp                  = 0x0AF5,
-  KEY_musicalflat                   = 0x0AF6,
-  KEY_malesymbol                    = 0x0AF7,
-  KEY_femalesymbol                  = 0x0AF8,
-  KEY_telephone                     = 0x0AF9,
-  KEY_telephonerecorder             = 0x0AFA,
-  KEY_phonographcopyright           = 0x0AFB,
-  KEY_caret                         = 0x0AFC,
-  KEY_singlelowquotemark            = 0x0AFD,
-  KEY_doublelowquotemark            = 0x0AFE,
-  KEY_cursor                        = 0x0AFF,
-
-  // APL
-  KEY_leftcaret                     = 0x0BA3,
-  KEY_rightcaret                    = 0x0BA6,
-  KEY_downcaret                     = 0x0BA8,
-  KEY_upcaret                       = 0x0BA9,
-  KEY_overbar                       = 0x0BC0,
-  KEY_downtack                      = 0x0BC2,
-  KEY_upshoe                        = 0x0BC3,
-  KEY_downstile                     = 0x0BC4,
-  KEY_underbar                      = 0x0BC6,
-  KEY_jot                           = 0x0BCA,
-  KEY_quad                          = 0x0BCC,
-  KEY_uptack                        = 0x0BCE,
-  KEY_circle                        = 0x0BCF,
-  KEY_upstile                       = 0x0BD3,
-  KEY_downshoe                      = 0x0BD6,
-  KEY_rightshoe                     = 0x0BD8,
-  KEY_leftshoe                      = 0x0BDA,
-  KEY_lefttack                      = 0x0BDC,
-  KEY_righttack                     = 0x0BFC,
-
-  // Hebrew
-  KEY_hebrew_doublelowline          = 0x0CDF,
-  KEY_hebrew_aleph                  = 0x0CE0,
-  KEY_hebrew_bet                    = 0x0CE1,
-  KEY_hebrew_beth                   = 0x0CE1,
-  KEY_hebrew_gimel                  = 0x0CE2,
-  KEY_hebrew_gimmel                 = 0x0CE2,
-  KEY_hebrew_dalet                  = 0x0CE3,
-  KEY_hebrew_daleth                 = 0x0CE3,
-  KEY_hebrew_he                     = 0x0CE4,
-  KEY_hebrew_waw                    = 0x0CE5,
-  KEY_hebrew_zain                   = 0x0CE6,
-  KEY_hebrew_zayin                  = 0x0CE6,
-  KEY_hebrew_chet                   = 0x0CE7,
-  KEY_hebrew_het                    = 0x0CE7,
-  KEY_hebrew_tet                    = 0x0CE8,
-  KEY_hebrew_teth                   = 0x0CE8,
-  KEY_hebrew_yod                    = 0x0CE9,
-  KEY_hebrew_finalkaph              = 0x0CEA,
-  KEY_hebrew_kaph                   = 0x0CEB,
-  KEY_hebrew_lamed                  = 0x0CEC,
-  KEY_hebrew_finalmem               = 0x0CED,
-  KEY_hebrew_mem                    = 0x0CEE,
-  KEY_hebrew_finalnun               = 0x0CEF,
-  KEY_hebrew_nun                    = 0x0CF0,
-  KEY_hebrew_samech                 = 0x0CF1,
-  KEY_hebrew_samekh                 = 0x0CF1,
-  KEY_hebrew_ayin                   = 0x0CF2,
-  KEY_hebrew_finalpe                = 0x0CF3,
-  KEY_hebrew_pe                     = 0x0CF4,
-  KEY_hebrew_finalzade              = 0x0CF5,
-  KEY_hebrew_finalzadi              = 0x0CF5,
-  KEY_hebrew_zade                   = 0x0CF6,
-  KEY_hebrew_zadi                   = 0x0CF6,
-  KEY_hebrew_qoph                   = 0x0CF7,
-  KEY_hebrew_kuf                    = 0x0CF7,
-  KEY_hebrew_resh                   = 0x0CF8,
-  KEY_hebrew_shin                   = 0x0CF9,
-  KEY_hebrew_taw                    = 0x0CFA,
-  KEY_hebrew_taf                    = 0x0CFA,
-  KEY_Hebrew_switch                 = 0xFF7E,
-
-  // Thai
-  KEY_Thai_kokai                    = 0x0DA1,
-  KEY_Thai_khokhai                  = 0x0DA2,
-  KEY_Thai_khokhuat                 = 0x0DA3,
-  KEY_Thai_khokhwai                 = 0x0DA4,
-  KEY_Thai_khokhon                  = 0x0DA5,
-  KEY_Thai_khorakhang               = 0x0DA6,
-  KEY_Thai_ngongu                   = 0x0DA7,
-  KEY_Thai_chochan                  = 0x0DA8,
-  KEY_Thai_choching                 = 0x0DA9,
-  KEY_Thai_chochang                 = 0x0DAA,
-  KEY_Thai_soso                     = 0x0DAB,
-  KEY_Thai_chochoe                  = 0x0DAC,
-  KEY_Thai_yoying                   = 0x0DAD,
-  KEY_Thai_dochada                  = 0x0DAE,
-  KEY_Thai_topatak                  = 0x0DAF,
-  KEY_Thai_thothan                  = 0x0DB0,
-  KEY_Thai_thonangmontho            = 0x0DB1,
-  KEY_Thai_thophuthao               = 0x0DB2,
-  KEY_Thai_nonen                    = 0x0DB3,
-  KEY_Thai_dodek                    = 0x0DB4,
-  KEY_Thai_totao                    = 0x0DB5,
-  KEY_Thai_thothung                 = 0x0DB6,
-  KEY_Thai_thothahan                = 0x0DB7,
-  KEY_Thai_thothong                 = 0x0DB8,
-  KEY_Thai_nonu                     = 0x0DB9,
-  KEY_Thai_bobaimai                 = 0x0DBA,
-  KEY_Thai_popla                    = 0x0DBB,
-  KEY_Thai_phophung                 = 0x0DBC,
-  KEY_Thai_fofa                     = 0x0DBD,
-  KEY_Thai_phophan                  = 0x0DBE,
-  KEY_Thai_fofan                    = 0x0DBF,
-  KEY_Thai_phosamphao               = 0x0DC0,
-  KEY_Thai_moma                     = 0x0DC1,
-  KEY_Thai_yoyak                    = 0x0DC2,
-  KEY_Thai_rorua                    = 0x0DC3,
-  KEY_Thai_ru                       = 0x0DC4,
-  KEY_Thai_loling                   = 0x0DC5,
-  KEY_Thai_lu                       = 0x0DC6,
-  KEY_Thai_wowaen                   = 0x0DC7,
-  KEY_Thai_sosala                   = 0x0DC8,
-  KEY_Thai_sorusi                   = 0x0DC9,
-  KEY_Thai_sosua                    = 0x0DCA,
-  KEY_Thai_hohip                    = 0x0DCB,
-  KEY_Thai_lochula                  = 0x0DCC,
-  KEY_Thai_oang                     = 0x0DCD,
-  KEY_Thai_honokhuk                 = 0x0DCE,
-  KEY_Thai_paiyannoi                = 0x0DCF,
-  KEY_Thai_saraa                    = 0x0DD0,
-  KEY_Thai_maihanakat               = 0x0DD1,
-  KEY_Thai_saraaa                   = 0x0DD2,
-  KEY_Thai_saraam                   = 0x0DD3,
-  KEY_Thai_sarai                    = 0x0DD4,
-  KEY_Thai_saraii                   = 0x0DD5,
-  KEY_Thai_saraue                   = 0x0DD6,
-  KEY_Thai_sarauee                  = 0x0DD7,
-  KEY_Thai_sarau                    = 0x0DD8,
-  KEY_Thai_sarauu                   = 0x0DD9,
-  KEY_Thai_phinthu                  = 0x0DDA,
-  KEY_Thai_maihanakat_maitho        = 0x0DDE,
-  KEY_Thai_baht                     = 0x0DDF,
-  KEY_Thai_sarae                    = 0x0DE0,
-  KEY_Thai_saraae                   = 0x0DE1,
-  KEY_Thai_sarao                    = 0x0DE2,
-  KEY_Thai_saraaimaimuan            = 0x0DE3,
-  KEY_Thai_saraaimaimalai           = 0x0DE4,
-  KEY_Thai_lakkhangyao              = 0x0DE5,
-  KEY_Thai_maiyamok                 = 0x0DE6,
-  KEY_Thai_maitaikhu                = 0x0DE7,
-  KEY_Thai_maiek                    = 0x0DE8,
-  KEY_Thai_maitho                   = 0x0DE9,
-  KEY_Thai_maitri                   = 0x0DEA,
-  KEY_Thai_maichattawa              = 0x0DEB,
-  KEY_Thai_thanthakhat              = 0x0DEC,
-  KEY_Thai_nikhahit                 = 0x0DED,
-  KEY_Thai_leksun                   = 0x0DF0,
-  KEY_Thai_leknung                  = 0x0DF1,
-  KEY_Thai_leksong                  = 0x0DF2,
-  KEY_Thai_leksam                   = 0x0DF3,
-  KEY_Thai_leksi                    = 0x0DF4,
-  KEY_Thai_lekha                    = 0x0DF5,
-  KEY_Thai_lekhok                   = 0x0DF6,
-  KEY_Thai_lekchet                  = 0x0DF7,
-  KEY_Thai_lekpaet                  = 0x0DF8,
-  KEY_Thai_lekkao                   = 0x0DF9,
-
-  // Korean
-  KEY_Hangul                        = 0xFF31,
-  KEY_Hangul_Start                  = 0xFF32,
-  KEY_Hangul_End                    = 0xFF33,
-  KEY_Hangul_Hanja                  = 0xFF34,
-  KEY_Hangul_Jamo                   = 0xFF35,
-  KEY_Hangul_Romaja                 = 0xFF36,
-  KEY_Hangul_Codeinput              = 0xFF37,
-  KEY_Hangul_Jeonja                 = 0xFF38,
-  KEY_Hangul_Banja                  = 0xFF39,
-  KEY_Hangul_PreHanja               = 0xFF3A,
-  KEY_Hangul_PostHanja              = 0xFF3B,
-  KEY_Hangul_SingleCandidate        = 0xFF3C,
-  KEY_Hangul_MultipleCandidate      = 0xFF3D,
-  KEY_Hangul_PreviousCandidate      = 0xFF3E,
-  KEY_Hangul_Special                = 0xFF3F,
-  KEY_Hangul_switch                 = 0xFF7E,
-  KEY_Hangul_Kiyeog                 = 0x0EA1,
-  KEY_Hangul_SsangKiyeog            = 0x0EA2,
-  KEY_Hangul_KiyeogSios             = 0x0EA3,
-  KEY_Hangul_Nieun                  = 0x0EA4,
-  KEY_Hangul_NieunJieuj             = 0x0EA5,
-  KEY_Hangul_NieunHieuh             = 0x0EA6,
-  KEY_Hangul_Dikeud                 = 0x0EA7,
-  KEY_Hangul_SsangDikeud            = 0x0EA8,
-  KEY_Hangul_Rieul                  = 0x0EA9,
-  KEY_Hangul_RieulKiyeog            = 0x0EAA,
-  KEY_Hangul_RieulMieum             = 0x0EAB,
-  KEY_Hangul_RieulPieub             = 0x0EAC,
-  KEY_Hangul_RieulSios              = 0x0EAD,
-  KEY_Hangul_RieulTieut             = 0x0EAE,
-  KEY_Hangul_RieulPhieuf            = 0x0EAF,
-  KEY_Hangul_RieulHieuh             = 0x0EB0,
-  KEY_Hangul_Mieum                  = 0x0EB1,
-  KEY_Hangul_Pieub                  = 0x0EB2,
-  KEY_Hangul_SsangPieub             = 0x0EB3,
-  KEY_Hangul_PieubSios              = 0x0EB4,
-  KEY_Hangul_Sios                   = 0x0EB5,
-  KEY_Hangul_SsangSios              = 0x0EB6,
-  KEY_Hangul_Ieung                  = 0x0EB7,
-  KEY_Hangul_Jieuj                  = 0x0EB8,
-  KEY_Hangul_SsangJieuj             = 0x0EB9,
-  KEY_Hangul_Cieuc                  = 0x0EBA,
-  KEY_Hangul_Khieuq                 = 0x0EBB,
-  KEY_Hangul_Tieut                  = 0x0EBC,
-  KEY_Hangul_Phieuf                 = 0x0EBD,
-  KEY_Hangul_Hieuh                  = 0x0EBE,
-  KEY_Hangul_A                      = 0x0EBF,
-  KEY_Hangul_AE                     = 0x0EC0,
-  KEY_Hangul_YA                     = 0x0EC1,
-  KEY_Hangul_YAE                    = 0x0EC2,
-  KEY_Hangul_EO                     = 0x0EC3,
-  KEY_Hangul_E                      = 0x0EC4,
-  KEY_Hangul_YEO                    = 0x0EC5,
-  KEY_Hangul_YE                     = 0x0EC6,
-  KEY_Hangul_O                      = 0x0EC7,
-  KEY_Hangul_WA                     = 0x0EC8,
-  KEY_Hangul_WAE                    = 0x0EC9,
-  KEY_Hangul_OE                     = 0x0ECA,
-  KEY_Hangul_YO                     = 0x0ECB,
-  KEY_Hangul_U                      = 0x0ECC,
-  KEY_Hangul_WEO                    = 0x0ECD,
-  KEY_Hangul_WE                     = 0x0ECE,
-  KEY_Hangul_WI                     = 0x0ECF,
-  KEY_Hangul_YU                     = 0x0ED0,
-  KEY_Hangul_EU                     = 0x0ED1,
-  KEY_Hangul_YI                     = 0x0ED2,
-  KEY_Hangul_I                      = 0x0ED3,
-  KEY_Hangul_J_Kiyeog               = 0x0ED4,
-  KEY_Hangul_J_SsangKiyeog          = 0x0ED5,
-  KEY_Hangul_J_KiyeogSios           = 0x0ED6,
-  KEY_Hangul_J_Nieun                = 0x0ED7,
-  KEY_Hangul_J_NieunJieuj           = 0x0ED8,
-  KEY_Hangul_J_NieunHieuh           = 0x0ED9,
-  KEY_Hangul_J_Dikeud               = 0x0EDA,
-  KEY_Hangul_J_Rieul                = 0x0EDB,
-  KEY_Hangul_J_RieulKiyeog          = 0x0EDC,
-  KEY_Hangul_J_RieulMieum           = 0x0EDD,
-  KEY_Hangul_J_RieulPieub           = 0x0EDE,
-  KEY_Hangul_J_RieulSios            = 0x0EDF,
-  KEY_Hangul_J_RieulTieut           = 0x0EE0,
-  KEY_Hangul_J_RieulPhieuf          = 0x0EE1,
-  KEY_Hangul_J_RieulHieuh           = 0x0EE2,
-  KEY_Hangul_J_Mieum                = 0x0EE3,
-  KEY_Hangul_J_Pieub                = 0x0EE4,
-  KEY_Hangul_J_PieubSios            = 0x0EE5,
-  KEY_Hangul_J_Sios                 = 0x0EE6,
-  KEY_Hangul_J_SsangSios            = 0x0EE7,
-  KEY_Hangul_J_Ieung                = 0x0EE8,
-  KEY_Hangul_J_Jieuj                = 0x0EE9,
-  KEY_Hangul_J_Cieuc                = 0x0EEA,
-  KEY_Hangul_J_Khieuq               = 0x0EEB,
-  KEY_Hangul_J_Tieut                = 0x0EEC,
-  KEY_Hangul_J_Phieuf               = 0x0EED,
-  KEY_Hangul_J_Hieuh                = 0x0EEE,
-  KEY_Hangul_RieulYeorinHieuh       = 0x0EEF,
-  KEY_Hangul_SunkyeongeumMieum      = 0x0EF0,
-  KEY_Hangul_SunkyeongeumPieub      = 0x0EF1,
-  KEY_Hangul_PanSios                = 0x0EF2,
-  KEY_Hangul_KkogjiDalrinIeung      = 0x0EF3,
-  KEY_Hangul_SunkyeongeumPhieuf     = 0x0EF4,
-  KEY_Hangul_YeorinHieuh            = 0x0EF5,
-  KEY_Hangul_AraeA                  = 0x0EF6,
-  KEY_Hangul_AraeAE                 = 0x0EF7,
-  KEY_Hangul_J_PanSios              = 0x0EF8,
-  KEY_Hangul_J_KkogjiDalrinIeung    = 0x0EF9,
-  KEY_Hangul_J_YeorinHieuh          = 0x0EFA,
-  KEY_Korean_Won                    = 0x0EFF
-  };
-
-}
-
-
-#ifndef FX_NO_GLOBAL_NAMESPACE
-using namespace FX;
-#endif
-
-
-#endif
diff --git a/fox-includes/fxunicode.h b/fox-includes/fxunicode.h
deleted file mode 100644
index 9e8f0045..00000000
--- a/fox-includes/fxunicode.h
+++ /dev/null
@@ -1,322 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*                   U N I C O D E   C h a r a c t e r   I n f o                 *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 2005 by Jeroen van der Zijp.   All Rights Reserved.             *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: fxunicode.h 2291 2005-12-05 03:37:36Z lyle $                          *
-********************************************************************************/
-#ifndef FXUNICODE_H
-#define FXUNICODE_H
-
-
-namespace FX {
-
-
-/// General Category
-enum {
-  CatNotAssigned          = 0,     /// Cn Other, Not Assigned (no characters in the file have this property)
-  CatControl              = 1,     /// Cc Other, Control
-  CatFormat               = 2,     /// Cf Other, Format
-  CatSurrogate            = 3,     /// Cs Other, Surrogate
-  CatOther                = 4,     /// Co Other, Private Use
-  CatMarkNonSpacing       = 5,     /// Mn Mark, Nonspacing
-  CatMarkSpacingCombining = 6,     /// Mc Mark, Spacing Combining
-  CatMarkEnclosing        = 7,     /// Me Mark, Enclosing
-  CatSeparatorSpace       = 8,     /// Zs Separator, Space
-  CatSeparatorLine        = 9,     /// Zl Separator, Line
-  CatSeparatorParagraph   = 10,    /// Zp Separator, Paragraph
-  CatLetterUpper          = 11,    /// Lu Letter, Uppercase
-  CatLetterLower          = 12,    /// Ll Letter, Lowercase
-  CatLetterTitle          = 13,    /// Lt Letter, Titlecase
-  CatLetterModifier       = 14,    /// Lm Letter, Modifier
-  CatLetterOther          = 15,    /// Lo Letter, Other
-  CatNumberLetter         = 16,    /// Nl Number, Letter
-  CatNumberDecimal        = 17,    /// Nd Number, Decimal Digit
-  CatNumberOther          = 18,    /// No Number, Other
-  CatPunctConnector       = 19,    /// Pc Punctuation, Connector
-  CatPunctDash            = 20,    /// Pd Punctuation, Dash
-  CatPunctOpen            = 21,    /// Ps Punctuation, Open
-  CatPunctClose           = 22,    /// Pe Punctuation, Close
-  CatPunctInitial         = 23,    /// Pi Punctuation, Initial quote (may behave like Ps or Pe depending on usage)
-  CatPunctFinal           = 24,    /// Pf Punctuation, Final quote (may behave like Ps or Pe depending on usage)
-  CatPunctOther           = 25,    /// Po Punctuation, Other
-  CatSymbolMath           = 26,    /// Sm Symbol, Math
-  CatSymbolCurrency       = 27,    /// Sc Symbol, Currency
-  CatSymbolModifier       = 28,    /// Sk Symbol, Modifier
-  CatSymbolOther          = 29     /// So Symbol, Other
-  };
-
-
-/// Bidi types
-enum {
-  DirL   = 0,           /// Left-to-Right
-  DirLRE = 1,           /// Left-to-Right Embedding
-  DirLRO = 2,           /// Left-to-Right Override
-  DirR   = 3,           /// Right-to-Left
-  DirAL  = 4,           /// Right-to-Left Arabic
-  DirRLE = 5,           /// Right-to-Left Embedding
-  DirRLO = 6,           /// Right-to-Left Override
-  DirPDF = 7,           /// Pop Directional Format
-  DirEN  = 8,           /// European Number
-  DirES  = 9,           /// European Number Separator
-  DirET  = 10,          /// European Number Terminator
-  DirAN  = 11,          /// Arabic Number
-  DirCS  = 12,          /// Common Number Separator
-  DirNSM = 13,          /// Non-Spacing Mark
-  DirBN  = 14,          /// Boundary Neutral
-  DirB   = 15,          /// Paragraph Separator
-  DirS   = 16,          /// Segment Separator
-  DirWS  = 17,          /// Whitespace
-  DirON  = 18           /// Other Neutrals
-  };
-
-
-/// Arabic joining
-enum {
-  NonJoining   = 0,
-  RightJoining = 1,
-  DualJoining  = 2,
-  JoinCausing  = 3
-  };
-
-
-/// Combining class
-enum {
-  CombBelowLeftAtt  = 200,     /// Below left attached
-  CombBelowAtt      = 202,     /// Below attached
-  CombBelowRightAtt = 204,     /// Below right attached
-  CombLeftAtt       = 208,     /// Left attached (reordrant around single base character)
-  CombRightAtt      = 210,     /// Right attached
-  CombAboveLeftAtt  = 212,     /// Above left attached
-  CombAboveAtt      = 214,     /// Above attached
-  CombAboveRightAtt = 216,     /// Above right attached
-  CombBelowLeft     = 218,     /// Below left
-  CombBelow         = 220,     /// Below
-  CombBelowRight    = 222,     /// Below right
-  CombLeft          = 224,     /// Left (reordrant around single base character)
-  CombRight         = 226,     /// Right
-  CombAboveLeft     = 228,     /// Above left
-  CombAbove         = 230,     /// Above
-  CombAboveRight    = 232,     /// Above right
-  CombDoubleBelow   = 233,     /// Double below
-  CombDoubleAbove   = 234,     /// Double above
-  CombIotaSub       = 240      /// Below (iota subscript)
-  };
-
-
-/// Decompose types
-enum {
-  DecNone      = 0,     /// Non-decomposable
-  DecFont      = 1,     /// A font variant (e.g. a blackletter form)
-  DecNoBreak   = 2,     /// A no-break version of a space or hyphen
-  DecInitial   = 3,     /// An initial presentation form (Arabic)
-  DecMedial    = 4,     /// A medial presentation form (Arabic)
-  DecFinal     = 5,     /// A final presentation form (Arabic)
-  DecIsolated  = 6,     /// An isolated presentation form (Arabic)
-  DecCircle    = 7,     /// An encircled form
-  DecSuper     = 8,     /// A superscript form
-  DecSub       = 9,     /// A subscript form
-  DecVertical  = 10,    /// A vertical layout presentation form
-  DecWide      = 11,    /// A wide (or zenkaku) compatibility character
-  DecNarrow    = 12,    /// A narrow (or hankaku) compatibility character
-  DecSmall     = 13,    /// A small variant form (CNS compatibility)
-  DecSquare    = 14,    /// A CJK squared font variant
-  DecFraction  = 15,    /// A vulgar fraction form
-  DecCompat    = 16,    /// Compatible
-  DecCanonical = 17     /// Canonical (equivalent)
-  };
-
-
-/// Line break types
-enum {
-  BreakUnknown    = 0,          /// XX Unknown
-
-  BreakMandarory  = 1,          /// BK Mandatory Break
-  BreakReturn     = 2,          /// CR Carriage Return
-  BreakLineFeed   = 3,          /// LF Line Feed
-  BreakCombMark   = 4,          /// CM Attached Characters and Combining Marks
-  BreakNextLine   = 5,          /// NL Next Line
-  BreakSurrogate  = 6,          /// SG Surrogates
-  BreakWordJoiner = 7,          /// WJ Word Joiner
-  BreakZWSpace    = 8,          /// ZW Zero Width Space
-  BreakGlue       = 9,          /// GL Non-breaking Glue
-  BreakContingent = 10,         /// CB Contingent Break Opportunity
-  BreakSpace      = 11,         /// SP Space
-
-  BreakBoth       = 12,         /// B2 Break Opportunity Before and After
-  BreakAfter      = 13,         /// BA Break Opportunity After
-  BreakBefore     = 14,         /// BB Break Opportunity Before
-  BreakHyphen     = 15,         /// HY Hyphen
-
-  BreakOpen       = 16,         /// OP Opening Punctuation
-  BreakClose      = 17,         /// CL Closing Punctuation
-  BreakQuote      = 18,         /// QU Ambiguous Quotation
-  BreakExclaim    = 19,         /// EX Exclamation/Interrogation
-  BreakInsep      = 20,         /// IN Inseparable
-  BreakNonStart   = 21,         /// NS Non Starter
-
-  BreakInfix      = 22,         /// IS Infix Separator (Numeric)
-  BreakNumeric    = 23,         /// NU Numeric
-  BreakPostfix    = 24,         /// PO Postfix (Numeric)
-  BreakPrefix     = 25,         /// PR Prefix (Numeric)
-  BreakSymbol     = 26,         /// SY Symbols Allowing Breaks
-
-  BreakOrdinary   = 27,         /// AL Ordinary Alphabetic and Symbol Characters
-  BreakIdeograph  = 28,         /// ID Ideographic
-  BreakComplex    = 29          /// SA Complex Context (South East Asian)
-  };
-
-
-/// Scripts
-enum {
-  ScriptCommon             = 0,       /// Zyyy
-  ScriptInherited          = 1,       /// Qaai
-
-  ScriptLatin              = 2,       /// Latn  European scripts
-  ScriptGreek              = 3,       /// Grek
-  ScriptCyrillic           = 4,       /// Cyrl (Cyrs)
-  ScriptArmenian           = 5,       /// Armn
-  ScriptGeorgian           = 6,       /// Geor (Geon, Geoa)
-  ScriptRunic              = 7,       /// Runr
-  ScriptOgham              = 8,       /// Ogam
-
-  ScriptHebrew             = 9,       /// Hebr  Middle eastern
-  ScriptArabic             = 10,      /// Arab
-  ScriptSyriac             = 11,      /// Syrc (Syrj, Syrn, Syre)
-  ScriptThaana             = 12,      /// Thaa
-
-  ScriptDevanagari         = 13,      /// Deva  Indic
-  ScriptBengali            = 14,      /// Beng
-  ScriptGurmukhi           = 15,      /// Guru
-  ScriptGujarati           = 16,      /// Gujr
-  ScriptOriya              = 17,      /// Orya
-  ScriptTamil              = 18,      /// Taml
-  ScriptTelugu             = 19,      /// Telu
-  ScriptKannada            = 20,      /// Knda
-  ScriptMalayalam          = 21,      /// Mlym
-  ScriptSinhala            = 22,      /// Sinh
-  ScriptThai               = 23,      /// Thai
-  ScriptLao                = 24,      /// Laoo
-  ScriptTibetan            = 25,      /// Tibt
-  ScriptMyanmar            = 26,      /// Mymr
-  ScriptKhmer              = 27,      /// Khmr
-
-  ScriptHan                = 28,      /// Hani  Asian
-  ScriptHiragana           = 29,      /// Hira
-  ScriptKatakana           = 30,      /// Kana
-  ScriptHangul             = 31,      /// Hang
-  ScriptBopomofo           = 32,      /// Bopo
-  ScriptYi                 = 33,      /// Yiii
-
-  ScriptEthiopic           = 34,      /// Ethi  Misc
-  ScriptCherokee           = 35,      /// Cher
-  ScriptCanadianAboriginal = 36,      /// Cans
-  ScriptMongolian          = 37,      /// Mong
-  ScriptGothic             = 38,      /// Goth
-
-  ScriptTagalog            = 39,      /// Tglg
-  ScriptHanunoo            = 40,      /// Hano
-  ScriptBuhid              = 41,      /// Buhd
-  ScriptTagbanwa           = 42,      /// Tagb
-  ScriptLimbu              = 43,      /// Limb
-  ScriptTaiLe              = 44,      /// Tale
-  ScriptUgaritic           = 45,      /// Ugar
-  ScriptOsmanya            = 46,      /// Osma
-  ScriptCypriot            = 47,      /// Cprt
-  ScriptShavian            = 48,      /// Shaw
-  ScriptDeseret            = 49,      /// Dsrt
-  ScriptKatakanaHiragana   = 50       /// Hrkt
-  };
-
-
-/// Unicode versions of common character functions
-namespace Unicode {
-
-/// Character wide character category
-extern FXAPI FXuint charCategory(FXwchar ucs);
-
-/// Get character wide character direction
-extern FXAPI FXuint charDirection(FXwchar ucs);
-
-/// Get wide character decompose type
-extern FXAPI FXuint decomposeType(FXwchar ucs);
-
-/// Return number of wide characters in decomposition
-extern FXAPI FXuint charNumDecompose(FXwchar ucs);
-
-/// Return wide character decomposition
-extern FXAPI const FXwchar* charDecompose(FXwchar ucs);
-
-/// Return wide character composition from ucsa and ucsb
-extern FXAPI FXwchar charCompose(FXwchar ucsa,FXwchar ucsb);
-
-/// Get wide character joining
-extern FXAPI FXuint joiningType(FXwchar ucs);
-
-/// Get wide character symmetry
-extern FXAPI FXuint isSymmetric(FXwchar ucs);
-
-/// Get wide character combining type; zero means starter
-extern FXAPI FXuint charCombining(FXwchar ucs);
-
-/// Get numeric value of wide character (this includes hex value)
-extern FXAPI FXint digitValue(FXwchar ucs);
-
-/// Get linebreak type of wide character
-extern FXAPI FXuint lineBreakType(FXwchar ucs);
-
-
-/// Get mirror image of wide character or character itself
-extern FXAPI FXwchar mirrorImage(FXwchar ucs);
-
-/// Script type of wide character
-extern FXAPI FXuint scriptType(FXwchar ucs);
-
-
-/// Unicode flavor of common functions
-extern FXAPI bool hasCase(FXwchar ucs);
-extern FXAPI bool isUpper(FXwchar ucs);
-extern FXAPI bool isLower(FXwchar ucs);
-extern FXAPI bool isTitle(FXwchar ucs);
-extern FXAPI bool isAscii(FXwchar ucs);
-extern FXAPI bool isLetter(FXwchar ucs);
-extern FXAPI bool isDigit(FXwchar ucs);
-extern FXAPI bool isAlphaNumeric(FXwchar ucs);
-extern FXAPI bool isControl(FXwchar ucs);
-extern FXAPI bool isSpace(FXwchar ucs);
-extern FXAPI bool isBlank(FXwchar ucs);
-extern FXAPI bool isPunct(FXwchar ucs);
-extern FXAPI bool isGraph(FXwchar ucs);
-extern FXAPI bool isPrint(FXwchar ucs);
-extern FXAPI bool isHexDigit(FXwchar ucs);
-extern FXAPI bool isSymbol(FXwchar ucs);
-extern FXAPI bool isMark(FXwchar ucs);
-extern FXAPI bool isSep(FXwchar ucs);
-
-/// Case conversion
-extern FXAPI FXwchar toUpper(FXwchar ucs);
-extern FXAPI FXwchar toLower(FXwchar ucs);
-extern FXAPI FXwchar toTitle(FXwchar ucs);
-
-}
-
-
-}
-
-#endif
diff --git a/fox-includes/fxver.h b/fox-includes/fxver.h
deleted file mode 100755
index b41e4f38..00000000
--- a/fox-includes/fxver.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#ifndef FXVER_H
-#define FXVER_H
-
-
-// FOX version
-#define FOX_MAJOR  1
-#define FOX_MINOR  6
-#define FOX_LEVEL  0
-
-
-
-// FOX byte order
-#ifndef FOX_BIGENDIAN
-#define FOX_BIGENDIAN 1
-#endif
-
-
-#endif
diff --git a/fox-includes/xincs.h b/fox-includes/xincs.h
deleted file mode 100755
index d9f1cfae..00000000
--- a/fox-includes/xincs.h
+++ /dev/null
@@ -1,404 +0,0 @@
-/********************************************************************************
-*                                                                               *
-*              F O X   P r i v a t e   I n c l u d e   F i l e s                *
-*                                                                               *
-*********************************************************************************
-* Copyright (C) 1997,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
-*********************************************************************************
-* This library is free software; you can redistribute it and/or                 *
-* modify it under the terms of the GNU Lesser General Public                    *
-* License as published by the Free Software Foundation; either                  *
-* version 2.1 of the License, or (at your option) any later version.            *
-*                                                                               *
-* This library is distributed in the hope that it will be useful,               *
-* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU             *
-* Lesser General Public License for more details.                               *
-*                                                                               *
-* You should have received a copy of the GNU Lesser General Public              *
-* License along with this library; if not, write to the Free Software           *
-* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.    *
-*********************************************************************************
-* $Id: xincs.h 2343 2006-02-12 20:26:26Z lyle $                             *
-********************************************************************************/
-#ifndef XINCS_H
-#define XINCS_H
-
-
-////////////////////  DO NOT INCLUDE THIS PRIVATE HEADER FILE  //////////////////
-
-// Thread safe
-#ifndef _POSIX_PTHREAD_SEMANTICS
-#define _POSIX_PTHREAD_SEMANTICS
-#endif
-
-// GNU extras if we can get them
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-
-// Use 64-bit files
-#ifndef WIN32
-#ifndef _FILE_OFFSET_BITS
-#define _FILE_OFFSET_BITS 64
-#endif
-#endif
-
-// Basic includes
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdarg.h>
-#include <limits.h>
-#include <math.h>
-#include <float.h>
-#include <string.h>
-#include <errno.h>
-#include <signal.h>
-#include <time.h>
-#include <locale.h>
-#include <fcntl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#ifndef WIN32
-
-#include <grp.h>
-#include <pwd.h>
-#include <sys/ioctl.h>
-#ifdef HAVE_SYS_FILIO_H         // Get FIONREAD on Solaris
-#include <sys/filio.h>
-#endif
-#else
-
-#include <io.h>                 // For _access()
-#if defined(_MSC_VER) || defined(__WATCOMC__)		// Microsoft Visual C++ or Watcom C++
-#include <direct.h>
-#define stat _stat
-#define lstat _stat
-#define getcwd _getcwd
-#define mkdir _mkdir
-#define access _access
-#define vsnprintf _vsnprintf
-#define execl _execl
-#define execlp _execlp
-#define execle _execle
-#define execv _execv
-#define execve _execve
-#define execvp _execvp
-#define strdup _strdup
-#define alloca _alloca
-#endif
-#ifdef __BORLANDC__	        // Borland C++ Builder
-#include <dir.h>
-#if __BORLANDC__ <= 0x0530      // C++ Builder 3.0
-#define vsnprintf(a, b, c, d) vsprintf(a, c, d)
-#endif
-#define lstat stat
-#endif
-#ifdef __MINGW32__              // GCC MingW32
-#include <direct.h>
-#define vsnprintf _vsnprintf
-#endif
-#ifdef __SC__                   // Digital Mars C++ Compiler
-#include <direct.h>
-#include <io.h>                 // For _access()
-#define vsnprintf _vsnprintf
-#endif
-
-#endif
-
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_SYS_WAIT_H
-#include <sys/wait.h>
-#endif
-#ifdef TIME_WITH_SYS_TIME
-#include <sys/time.h>
-#include <time.h>
-#else
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#else
-#include <time.h>
-#endif
-#endif
-#ifdef HAVE_SYS_PARAM_H
-#include <sys/param.h>
-#endif
-#ifdef HAVE_SYS_SELECT_H
-#if (!defined(__MINGW32__)) && (!defined(hpux))
-#include <sys/select.h>
-#endif
-#endif
-#ifdef HAVE_DIRENT_H
-#include <dirent.h>
-#define NAMLEN(dirent) strlen((dirent)->d_name)
-#else
-#define dirent direct
-#define NAMLEN(dirent) (dirent)->d_namlen
-#ifdef HAVE_SYS_NDIR_H
-#include <sys/ndir.h>
-#endif
-#ifdef HAVE_SYS_DIR_H
-#include <sys/dir.h>
-#endif
-#ifdef HAVE_NDIR_H
-#include <ndir.h>
-#endif
-#endif
-#ifdef HAVE_XSHM_H
-#include <sys/ipc.h>
-#include <sys/shm.h>
-#endif
-#ifdef HAVE_MMAP
-#include <sys/mman.h>
-#endif
-
-
-// For thread-safe readdir_r, we sometimes need extra
-// space above and beyond the space for dirent itself
-#ifdef HAVE_DIRENT_H
-#ifndef WIN32
-struct fxdirent : public dirent {
-  char buffer[256];
-  };
-#endif
-#endif
-
-
-// MS-Windows
-#ifdef WIN32
-#ifndef STRICT
-#define STRICT
-#endif
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <windows.h>
-#ifndef __CYGWIN__
-#include <winsock2.h>
-#endif
-#include <commctrl.h>           // For _TrackMouseEvent
-#include <shellapi.h>
-
-// X windows includes
-#else
-
-#include <X11/X.h>
-#define XRegisterIMInstantiateCallback broken_XRegisterIMInstantiateCallback
-#define XUnregisterIMInstantiateCallback broken_XUnregisterIMInstantiateCallback
-#define XSetIMValues broken_XSetIMValues
-#include <X11/Xlib.h>
-#undef XRegisterIMInstantiateCallback
-#undef XUnregisterIMInstantiateCallback
-#undef XSetIMValues
-#include <X11/Xcms.h>
-#include <X11/Xutil.h>
-#include <X11/Xresource.h>
-#include <X11/Xatom.h>
-#include <X11/cursorfont.h>
-#ifdef HUMMINGBIRD
-#include <X11/XlibXtra.h>
-#endif
-#ifdef HAVE_XSHM_H
-#include <X11/extensions/XShm.h>
-#endif
-#ifdef HAVE_XCURSOR_H
-#include <X11/Xcursor/Xcursor.h>
-#endif
-#ifdef HAVE_XFT_H
-#include <X11/Xft/Xft.h>
-#endif
-#ifdef HAVE_XSHAPE_H
-#include <X11/extensions/shape.h>
-#endif
-#ifdef HAVE_XRANDR_H
-#include <X11/extensions/Xrandr.h>
-#endif
-
-#ifndef NO_XIM
-#ifndef XlibSpecificationRelease        // Not defined until X11R5
-#define NO_XIM
-#elif XlibSpecificationRelease < 6      // Need at least Xlib X11R6
-#define NO_XIM
-#endif
-#endif
-
-#ifndef NO_XIM
-extern "C" Bool XRegisterIMInstantiateCallback(Display*,struct _XrmHashBucketRec*,char*,char*,XIMProc,XPointer);
-extern "C" Bool XUnregisterIMInstantiateCallback(Display*,struct _XrmHashBucketRec*,char*,char*,XIMProc,XPointer);
-extern "C" char *XSetIMValues(XIM,...);
-#endif
-
-#endif
-
-
-
-
-// OpenGL includes
-#ifdef HAVE_GL_H
-#ifndef SUN_OGL_NO_VERTEX_MACROS
-#define SUN_OGL_NO_VERTEX_MACROS
-#endif
-#ifndef HPOGL_SUPPRESS_FAST_API
-#define HPOGL_SUPPRESS_FAST_API
-#endif
-#include <GL/gl.h>
-#ifndef WIN32
-#include <GL/glx.h>
-#endif
-#endif
-#ifndef GLAPIENTRY
-#define GLAPIENTRY
-#endif
-#ifndef GLAPI
-#define GLAPI
-#endif
-#ifdef HAVE_GLU_H
-#include <GL/glu.h>
-#endif
-
-// Maximum path length
-#ifndef MAXPATHLEN
-#if defined(PATH_MAX)
-#define MAXPATHLEN   PATH_MAX
-#elif defined(_MAX_PATH)
-#define MAXPATHLEN   _MAX_PATH
-#elif defined(MAX_PATH)
-#define MAXPATHLEN   MAX_PATH
-#else
-#define MAXPATHLEN   1024
-#endif
-#endif
-
-// Modes for access(filename,mode) on Windows
-#ifdef WIN32
-#ifndef R_OK
-#define R_OK 4
-#endif
-#ifndef W_OK
-#define W_OK 2
-#endif
-#ifndef X_OK
-#define X_OK 1
-#endif
-#ifndef F_OK
-#define F_OK 0
-#endif
-#endif
-
-// File open modes on Windows
-#ifdef WIN32
-#if defined(_MSC_VER)
-#define O_APPEND _O_APPEND
-#define O_CREAT  _O_CREAT
-#define O_EXCL   _O_EXCL
-#define O_RDONLY _O_RDONLY
-#define O_RDWR   _O_RDWR
-#define O_TRUNC  _O_TRUNC
-#define O_WRONLY _O_WRONLY
-#define O_BINARY _O_BINARY
-#endif
-#endif
-
-// Some systems don't have it
-#ifndef SEEK_SET
-#define SEEK_SET 0
-#endif
-#ifndef SEEK_CUR
-#define SEEK_CUR 1
-#endif
-#ifndef SEEK_END
-#define SEEK_END 2
-#endif
-
-// Printer stuff
-#ifdef WIN32
-#include <winspool.h>
-#endif
-
-
-// Wheel support (OS >= W98, OS>=NT4.0)
-#ifdef WIN32
-
-// Missing wheel message id's
-#ifndef SPI_GETWHEELSCROLLLINES
-#define SPI_GETWHEELSCROLLLINES   104
-#endif
-#ifndef WM_MOUSEWHEEL
-#define WM_MOUSEWHEEL             0x020A
-#endif
-
-// GetSystemMetrics parameters missing in header files
-#ifndef SM_XVIRTUALSCREEN
-#define SM_XVIRTUALSCREEN       76
-#endif
-#ifndef SM_YVIRTUALSCREEN
-#define SM_YVIRTUALSCREEN       77
-#endif
-#ifndef SM_CXVIRTUALSCREEN
-#define SM_CXVIRTUALSCREEN      78
-#endif
-#ifndef SM_CYVIRTUALSCREEN
-#define SM_CYVIRTUALSCREEN      79
-#endif
-#ifndef SM_CMONITORS
-#define SM_CMONITORS            80
-#endif
-#ifndef SM_SAMEDISPLAYFORMAT
-#define SM_SAMEDISPLAYFORMAT    81
-#endif
-
-// Missing in CYGWIN
-#ifndef IMAGE_SUBSYSTEM_NATIVE_WINDOWS
-#define IMAGE_SUBSYSTEM_NATIVE_WINDOWS 8
-#endif
-#ifndef IMAGE_SUBSYSTEM_WINDOWS_CE_GUI
-#define IMAGE_SUBSYSTEM_WINDOWS_CE_GUI 9
-#endif
-#endif
-
-
-// IBM VisualAge for C++ 3.5
-#if defined(__IBMCPP__) && defined(WIN32)
-#include <direct.h>
-#include <io.h>         // for _access()
-#define _mkdir(x) mkdir((char *)(x))
-#define _vsnprintf(a, b, c, d) vsprintf(a, c, d)
-#define ICON_SMALL      0
-#define ICON_BIG        1
-#define bool            int
-
-// This declarations come from Microsoft SDK
-#define TME_HOVER       0x00000001
-#define TME_LEAVE       0x00000002
-#define TME_QUERY       0x40000000
-#define TME_CANCEL      0x80000000
-#define HOVER_DEFAULT   0xFFFFFFFF
-#define WM_MOUSEHOVER   0x02A1
-#define WM_MOUSELEAVE   0x02A3
-
-typedef struct tagTRACKMOUSEEVENT {
-    DWORD cbSize;
-    DWORD dwFlags;
-    HWND  hwndTrack;
-    DWORD dwHoverTime;
-} TRACKMOUSEEVENT, *LPTRACKMOUSEEVENT;
-
-WINUSERAPI
-BOOL
-WINAPI
-TrackMouseEvent(
-    IN OUT LPTRACKMOUSEEVENT lpEventTrack);
-
-#ifdef __GL_H__
-#define GL_COLOR_LOGIC_OP                 0x0BF2
-#define GL_POLYGON_OFFSET_POINT           0x2A01
-#define GL_POLYGON_OFFSET_LINE            0x2A02
-WINGDIAPI void APIENTRY glPolygonOffset (GLfloat factor,GLfloat units);
-#endif
-
-#endif
-
-#endif
diff --git a/fxruby.gemspec b/fxruby.gemspec
new file mode 100644
index 00000000..5eba0dd4
--- /dev/null
+++ b/fxruby.gemspec
@@ -0,0 +1,54 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fox16/version'
+
+SWIG_MODULES = {
+  "core.i" => "core_wrap.cpp",
+  "dcmodule.i" => "dc_wrap.cpp",
+  "dialogs.i" => "dialogs_wrap.cpp",
+  "framesmodule.i" => "frames_wrap.cpp",
+  "iconlistmodule.i" => "iconlist_wrap.cpp",
+  "icons.i" => "icons_wrap.cpp",
+  "image.i" => "image_wrap.cpp",
+  "labelmodule.i" => "label_wrap.cpp",
+  "layout.i" => "layout_wrap.cpp",
+  "listmodule.i" => "list_wrap.cpp",
+  "mdi.i" => "mdi_wrap.cpp",
+  "menumodule.i" => "menu_wrap.cpp",
+  "fx3d.i" => "fx3d_wrap.cpp",
+  "scintilla.i" => "scintilla_wrap.cpp",
+  "table-module.i" => "table_wrap.cpp",
+  "text-module.i" => "text_wrap.cpp",
+  "treelist-module.i" => "treelist_wrap.cpp",
+  "ui.i" => "ui_wrap.cpp"
+}
+
+Gem::Specification.new do |spec|
+  spec.name          = "fxruby"
+  spec.version       = Fox.fxrubyversion
+  spec.authors       = ["Lyle Johnson", "Lars Kanis"]
+  spec.email         = ["lyle@lylejohnson.name", "lars@greiz-reinsdorf.de"]
+
+  spec.summary       = %q{FXRuby is the Ruby binding to the FOX GUI toolkit.}
+  spec.homepage      = "https://github.com/larskanis/fxruby"
+  spec.license       = 'LGPL-2.1'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f=~/^fox-includes|^web/
+  end
+  spec.files += SWIG_MODULES.values.map{|f| File.join("ext/fox16_c", f) }
+  spec.files << 'ext/fox16_c/include/inlinestubs.h'
+  spec.files << 'ext/fox16_c/swigruby.h'
+  spec.files << 'doap.rdf'
+  spec.files << 'lib/fox16/kwargs.rb'
+
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extensions = ["ext/fox16_c/extconf.rb"]
+  spec.metadata['msys2_mingw_dependencies'] = 'fox'
+  spec.required_ruby_version = "~> 2.2"
+
+  spec.add_runtime_dependency 'mini_portile2', '~> 2.1'
+end
diff --git a/lib/fox16.rb b/lib/fox16.rb
index 7902976d..d3a57867 100644
--- a/lib/fox16.rb
+++ b/lib/fox16.rb
@@ -6,11 +6,26 @@ rescue LoadError
     major_minor = RUBY_VERSION[ /^(\d+\.\d+)/ ] or
       raise "Oops, can't extract the major/minor version from #{RUBY_VERSION.dump}"
 
-    # Set the PATH environment variable, so that libpq.dll can be found.
-    old_path = ENV['PATH']
-    ENV['PATH'] = "#{File.expand_path("../#{RUBY_PLATFORM.gsub("i386", "x86")}", __FILE__)};#{old_path}"
-    require "#{major_minor}/fox16_c"
-    ENV['PATH'] = old_path
+    add_dll_path = proc do |path, &block|
+      begin
+        require 'ruby_installer/runtime'
+        RubyInstaller::Runtime.add_dll_directory(path, &block)
+      rescue LoadError
+        old_path = ENV['PATH']
+        ENV['PATH'] = "#{path};#{old_path}"
+        block.call
+        ENV['PATH'] = old_path
+      end
+    end
+
+    # Temporary add this directory for DLL search, so that bundled DLLs can be found.
+    ports_dir = RbConfig::CONFIG["host"].gsub('i686-pc-mingw32') do
+      major_minor < '2.0' ? 'i586-mingw32msvc' : 'i686-w64-mingw32'
+    end
+    ports_bin = File.expand_path("../../ports/#{ports_dir}/bin", __FILE__)
+    add_dll_path.call(ports_bin) do
+      require "#{major_minor}/fox16_c"
+    end
   else
     raise
   end
@@ -28,3 +43,4 @@ require "fox16/execute_nonmodal"
 require "fox16/version"
 require "fox16/kwargs"
 require "fox16/exceptions_for_fxerror"
+require "fox16/thread"
diff --git a/lib/fox16/aliases.rb b/lib/fox16/aliases.rb
old mode 100755
new mode 100644
index 1206d1ec..025a91ed
--- a/lib/fox16/aliases.rb
+++ b/lib/fox16/aliases.rb
@@ -1976,7 +1976,7 @@ module Fox
   end
   class FXGLVisual
     def FXGLVisual.supported?(*args) # :nodoc:
-      FXGLVisual.supported(*args)
+      FXGLVisual.supported(*args)[0]
     end
     def redSize(*args) # :nodoc:
       getRedSize(*args)
@@ -2414,6 +2414,9 @@ module Fox
     def data(*args) # :nodoc:
       getData(*args)
     end
+    def dataPtr(*args) # :nodoc:
+      getDataPtr(*args)
+    end
     def pixels=(*args) # :nodoc:
       setPixels(*args)
     end
diff --git a/lib/fox16/bitmapview.rb b/lib/fox16/bitmapview.rb
old mode 100755
new mode 100644
diff --git a/lib/fox16/calendar.rb b/lib/fox16/calendar.rb
old mode 100755
new mode 100644
index 251194e8..75a21eac
--- a/lib/fox16/calendar.rb
+++ b/lib/fox16/calendar.rb
@@ -99,7 +99,7 @@ module Fox
         btn.connect(SEL_COMMAND) do |send, sel, ev|
           @selected = Time.local(@date_showing.year, @date_showing.month,
                                  send.text.to_i)
-          target.handle(self, MKUINT(selector, SEL_COMMAND), @selected) if target
+          target.handle(self, Fox.MKUINT(selector, SEL_COMMAND), @selected) if target
         end
       end
       _build_date_matrix()
@@ -202,16 +202,14 @@ end
 
 if __FILE__ == $0
 
-  include Fox
-
-  app = FXApp.new('Calendar', 'FXRuby')
+  app = Fox::FXApp.new('Calendar', 'FXRuby')
   app.init(ARGV)
-  mainwin = FXMainWindow.new(app, "Calendar Test", nil, nil, DECOR_ALL, 0, 0, 500, 500)
-  calendar = FXCalendar.new(mainwin, Time.now, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y)
-  calendar.connect(SEL_COMMAND) do |sender, sel, data|
+  mainwin = Fox::FXMainWindow.new(app, "Calendar Test", nil, nil, Fox::DECOR_ALL, 0, 0, 500, 500)
+  calendar = Fox::FXCalendar.new(mainwin, Time.now, nil, 0, Fox::LAYOUT_FILL_X|Fox::LAYOUT_FILL_Y)
+  calendar.connect(Fox::SEL_COMMAND) do |sender, sel, data|
     puts data.to_s
   end
   app.create
-  mainwin.show(PLACEMENT_SCREEN)
+  mainwin.show(Fox::PLACEMENT_SCREEN)
   app.run
 end
diff --git a/lib/fox16/canvas.rb b/lib/fox16/canvas.rb
old mode 100755
new mode 100644
index 535bbda2..24ccb4c8
--- a/lib/fox16/canvas.rb
+++ b/lib/fox16/canvas.rb
@@ -312,7 +312,7 @@ module Fox
           shape.select
           @canvas.updateShape(shape)
           if notify && (@canvas.target != nil)
-            @canvas.target.handle(@canvas, MKUINT(@canvas.message, SEL_SELECTED), shape)
+            @canvas.target.handle(@canvas, Fox.MKUINT(@canvas.message, SEL_SELECTED), shape)
           end
         end
       end
@@ -322,7 +322,7 @@ module Fox
           shape.deselect
           @canvas.updateShape(shape)
           if notify && (@canvas.target != nil)
-            @canvas.target.handle(@canvas, MKUINT(@canvas.message, SEL_DESELECTED), shape)
+            @canvas.target.handle(@canvas, Fox.MKUINT(@canvas.message, SEL_DESELECTED), shape)
           end
         end
       end
@@ -463,7 +463,7 @@ module Fox
             updateShape(shape)
             changes = true
             if notify && (target != nil)
-              target.handle(self, MKUINT(message, SEL_DESELECTED), shape)
+              target.handle(self, Fox.MKUINT(message, SEL_DESELECTED), shape)
             end
           end
         end
@@ -486,7 +486,7 @@ module Fox
       def onMotion(sender, sel, evt)
         # Drag and drop mode
         if (@flags & FLAG_DODRAG) != 0
-          handle(self, MKUINT(0, SEL_DRAGGED), evt)
+          handle(self, Fox.MKUINT(0, SEL_DRAGGED), evt)
           return 1
         end
 
@@ -494,7 +494,7 @@ module Fox
         if (@flags & FLAG_TRYDRAG) != 0
           if evt.moved?
             @flags &= ~FLAG_TRYDRAG
-            if handle(this, MKUINT(0, SEL_BEGINDRAG), evt) != 0
+            if handle(this, Fox.MKUINT(0, SEL_BEGINDRAG), evt) != 0
               @flags |= FLAG_DODRAG
             end
           end
@@ -504,13 +504,13 @@ module Fox
 
       # Left button press
       def onLeftBtnPress(sender, sel, evt)
-        handle(self, MKUINT(0, SEL_FOCUS_SELF), evt)
+        handle(self, Fox.MKUINT(0, SEL_FOCUS_SELF), evt)
         if enabled?
           grab
           flags &= ~FLAG_UPDATE
 
           # Give target the first chance at handling this
-          return 1 if target && (target.handle(self, MKUINT(message, SEL_LEFTBUTTONPRESS), evt) != 0)
+          return 1 if target && (target.handle(self, Fox.MKUINT(message, SEL_LEFTBUTTONPRESS), evt) != 0)
 
           # Locate shape
           shape = findShape(evt.win_x, evt.win_y)
@@ -548,11 +548,11 @@ module Fox
           @flags &= ~(FLAG_PRESSED|FLAG_TRYDRAG|FLAG_LASSO|FLAG_DODRAG)
 
           # First chance callback
-          return 1 if target && target.handle(self, MKUINT(message, SEL_LEFTBUTTONRELEASE), evt) != 0
+          return 1 if target && target.handle(self, Fox.MKUINT(message, SEL_LEFTBUTTONRELEASE), evt) != 0
 
           # Was dragging
           if (flg & FLAG_DODRAG) != 0
-            handle(self, MKUINT(0, SEL_ENDDRAG), evt)
+            handle(self, Fox.MKUINT(0, SEL_ENDDRAG), evt)
             return 1
           end
 
@@ -565,16 +565,16 @@ module Fox
 
             # Generate clicked callbacks
             if evt.click_count == 1
-              handle(self, MKUINT(0, SEL_CLICKED), @currentShape)
+              handle(self, Fox.MKUINT(0, SEL_CLICKED), @currentShape)
             elsif evt.click_count == 2
-              handle(self, MKUINT(0, SEL_DOUBLECLICKED), @currentShape)
+              handle(self, Fox.MKUINT(0, SEL_DOUBLECLICKED), @currentShape)
             elseif evt.click_count == 3
-              handle(self, MKUINT(0, SEL_TRIPLECLICKED), @currentShape)
+              handle(self, Fox.MKUINT(0, SEL_TRIPLECLICKED), @currentShape)
             end
 
             # Generate command callback only when clicked on item
             if @currentShape && @currentShape.enabled?
-              handle(self, MKUINT(0, SEL_COMMAND), @currentShape)
+              handle(self, Fox.MKUINT(0, SEL_COMMAND), @currentShape)
             end
             return 1
           end
@@ -584,22 +584,22 @@ module Fox
 
       # Command message
       def onCommand(sender, sel, ptr)
-        return target && target.handle(self, MKUINT(message, SEL_COMMAND), ptr)
+        return target && target.handle(self, Fox.MKUINT(message, SEL_COMMAND), ptr)
       end
 
       # Clicked on canvas
       def onClicked(sender, sel, ptr)
-        return target && target.handle(self, MKUINT(message, SEL_CLICKED), ptr)
+        return target && target.handle(self, Fox.MKUINT(message, SEL_CLICKED), ptr)
       end
 
       # Double-clicked on canvas
       def onDoubleClicked(sender, sel, ptr)
-        return target && target.handle(self, MKUINT(message, SEL_DOUBLECLICKED), ptr)
+        return target && target.handle(self, Fox.MKUINT(message, SEL_DOUBLECLICKED), ptr)
       end
 
       # Triple-clicked on canvas
       def onTripleClicked(sender, sel, ptr)
-        return target && target.handle(self, MKUINT(message, SEL_TRIPLECLICKED), ptr)
+        return target && target.handle(self, Fox.MKUINT(message, SEL_TRIPLECLICKED), ptr)
       end
     end
   end
diff --git a/lib/fox16/chore.rb b/lib/fox16/chore.rb
old mode 100755
new mode 100644
diff --git a/lib/fox16/colors.rb b/lib/fox16/colors.rb
old mode 100755
new mode 100644
diff --git a/lib/fox16/core.rb b/lib/fox16/core.rb
old mode 100755
new mode 100644
index 18e56bbd..c6213105
--- a/lib/fox16/core.rb
+++ b/lib/fox16/core.rb
@@ -421,24 +421,24 @@ module Fox
     #
     def FXStreamError.makeStreamError(status)
       case status
-	when FXStreamEnd
-	  FXStreamEndError
-	when FXStreamFull
-	  FXStreamFullError
-	when FXStreamNoWrite
-	  FXStreamNoWriteError
-	when FXStreamNoRead
-	  FXStreamNoReadError
-	when FXStreamFormat
-	  FXStreamFormatError
-	when FXStreamUnknown
-	  FXStreamUnknownError
-	when FXStreamAlloc
-	  FXStreamAllocError
-	when FXStreamFailure
-	  FXStreamFailureError
-	else
-	  FXStreamError
+      when FXStreamEnd
+        FXStreamEndError
+      when FXStreamFull
+        FXStreamFullError
+      when FXStreamNoWrite
+        FXStreamNoWriteError
+      when FXStreamNoRead
+        FXStreamNoReadError
+      when FXStreamFormat
+        FXStreamFormatError
+      when FXStreamUnknown
+        FXStreamUnknownError
+      when FXStreamAlloc
+        FXStreamAllocError
+      when FXStreamFailure
+        FXStreamFailureError
+      else
+        FXStreamError
       end
     end
   end
@@ -625,14 +625,6 @@ module Fox
     end
   end
 
-  class FXHVec
-    def normalize!
-      normalized = self.normalize
-      0.upto(3) { |idx| self[idx] = normalized[idx] }
-      self
-    end
-  end
-
   class FXTable
     #
     # Append _numColumns_ columns to the right of the table..
diff --git a/lib/fox16/dict.rb b/lib/fox16/dict.rb
old mode 100755
new mode 100644
diff --git a/lib/fox16/glgroup.rb b/lib/fox16/glgroup.rb
old mode 100755
new mode 100644
diff --git a/lib/fox16/glshapes.rb b/lib/fox16/glshapes.rb
old mode 100755
new mode 100644
diff --git a/lib/fox16/input.rb b/lib/fox16/input.rb
old mode 100755
new mode 100644
index 1f693602..29efefbc
--- a/lib/fox16/input.rb
+++ b/lib/fox16/input.rb
@@ -5,10 +5,13 @@ module Fox
     alias addInputOrig addInput # :nodoc:
 
     #
-    # Add a file descriptor _fileDesc_ to be watched for activity as determined
-    # by _mode_, where _mode_ is a bitwise OR (+INPUT_READ+, +INPUT_WRITE+, +INPUT_EXCEPT+).
-    # A message of type +SEL_IO_READ+, +SEL_IO_WRITE+, or +SEL_IO_EXCEPT+ will be sent
-    # to the target when the specified activity is detected on the file descriptor.
+    # Add an IO object as _io_ to be watched for activity as determined by _mode_, where _mode_ is a bitwise OR (+INPUT_READ+, +INPUT_WRITE+, +INPUT_EXCEPT+).
+    # A message of type +SEL_IO_READ+, +SEL_IO_WRITE+, or +SEL_IO_EXCEPT+ will be sent to the target when the specified activity is detected on the file descriptor.
+    #
+    # On POSIX operating systems all kinds of file descriptors can be watched.
+    # It works for +Socket.new+, +IO.popen+, +IO.pipe+, +IO.for_fd+, +File.open+, etc.
+    # Windows provides level triggered events only for network sockets.
+    # So on Windows only socket IO objects like +TCPSocket.new+ and +TCPServer.new+ are currently supported to be watched.
     #
     # There are several forms for #addInput; the original form (from FOX)
     # takes four arguments:
@@ -30,8 +33,7 @@ module Fox
     #     ... handle the I/O event ...
     #   }
     #
-
-    def addInput(fd, mode, *args, &block)
+    def addInput(io, mode, *args, &block)
       params = {}
       params = args.pop if args.last.is_a? Hash
       tgt, sel = nil, 0
@@ -51,7 +53,7 @@ module Fox
         tgt.pconnect(SEL_IO_WRITE, block, params)
         tgt.pconnect(SEL_IO_EXCEPT, block, params)
       end
-      addInputOrig(fd, mode, tgt, sel)
+      addInputOrig(io, mode, tgt, sel)
     end
 
   end # class FXApp
diff --git a/lib/fox16/irb.rb b/lib/fox16/irb.rb
old mode 100755
new mode 100644
diff --git a/lib/fox16/iterators.rb b/lib/fox16/iterators.rb
old mode 100755
new mode 100644
diff --git a/lib/fox16/keys.rb b/lib/fox16/keys.rb
old mode 100755
new mode 100644
diff --git a/lib/fox16/kwargs.rb b/lib/fox16/kwargs.rb
new file mode 100644
index 00000000..3045e562
--- /dev/null
+++ b/lib/fox16/kwargs.rb
@@ -0,0 +1,2738 @@
+old_verbose = $VERBOSE; $VERBOSE = nil
+
+module Fox
+
+
+  class FX4Splitter
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{opts x y width height}
+      default_params = { :opts => FOURSPLITTER_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      if args.length > 0 && (args.first.nil? || args.first.is_a?(FXObject))
+        tgt, sel = args[0], args[1]
+        args.each_with_index { |e, i| params[argument_names[i-2].intern] = e if i >= 2 }
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(p, tgt, sel, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      else
+        args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      end
+    end
+  end
+
+  class FXDockBar
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :opts => LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 3, :padRight => 3, :padTop => 2, :padBottom => 2, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      if args.length > 0 && (args.first.nil? || args.first.is_a?(FXComposite))
+        q = args[0]
+        args.each_with_index { |e, i| params[argument_names[i-1].intern] = e if i >= 1 }
+        if params.key? :padding
+          value = params.delete(:padding)
+          [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+        end
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(p, q, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+      else
+        args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+        if params.key? :padding
+          value = params.delete(:padding)
+          [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+        end
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+      end
+    end
+  end
+
+  class FXFont
+
+    alias old_initialize initialize
+
+    def initialize(a, arg1, *args, &blk)
+      if args.length > 0
+        face, size = arg1, args[0]
+        argument_names = %w{weight slant encoding setWidth hints}
+        default_params = { :weight => FXFont::Normal, :slant => FXFont::Straight, :encoding => FONTENCODING_DEFAULT, :setWidth => FXFont::NonExpanded, :hints => 0 }
+        params = {}
+        params = args.pop if args.last.is_a? Hash
+        args.each_with_index { |e, i| params[argument_names[i-1].intern] = e if i >= 1 }
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(a, face, size, params[:weight], params[:slant], params[:encoding], params[:setWidth], params[:hints], &blk)
+      else
+        old_initialize(a, arg1, &blk)
+      end
+    end
+
+    class << self
+      alias old_listFonts listFonts
+    end
+
+    def FXFont.listFonts(face, *args)
+      argument_names = %w{weight slant setWidth encoding hints}
+      default_params = { :weight => 0, :slant => 0, :setWidth => 0, :encoding => 0, :hints => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_listFonts(face, params[:weight], params[:slant], params[:setWidth], params[:encoding], params[:hints])
+    end
+
+  end
+
+  class FXGLCanvas
+    alias old_initialize initialize
+    def initialize(parent, vis, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      if args.length > 0 && (args[0].is_a?(FXGLCanvas))
+        sharegroup = args[0]
+        args.each_with_index { |e, i| params[argument_names[i-1].intern] = e if i >= 1 }
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(parent, vis, sharegroup, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      else
+        args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(parent, vis, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      end
+    end
+  end
+
+  class FXGLViewer
+    alias old_initialize initialize
+    def initialize(parent, vis, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      if args.length > 0 && (args[0].is_a?(FXGLViewer))
+        sharegroup = args[0]
+        args.each_with_index { |e, i| params[argument_names[i-1].intern] = e if i >= 1 }
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(parent, vis, sharegroup, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      else
+        args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(parent, vis, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      end
+    end
+  end
+
+  class FXMenuBar
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :opts => LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 3, :padRight => 3, :padTop => 2, :padBottom => 2, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      if args.length > 0 && (args[0].nil? || args[0].is_a?(FXComposite))
+        q = args[0]
+        args.each_with_index { |e, i| params[argument_names[i-1].intern] = e if i >= 1 }
+        if params.key? :padding
+          value = params.delete(:padding)
+          [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+        end
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(p, q, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+      else
+        args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+        if params.key? :padding
+          value = params.delete(:padding)
+          [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+        end
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+      end
+    end
+  end
+
+  class FXSplitter
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{opts x y width height}
+      default_params = { :opts => SPLITTER_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      if args.length > 0 && (args.first.nil? || args.first.is_a?(FXObject))
+        tgt, sel = args[0], args[1]
+        args.each_with_index { |e, i| params[argument_names[i-2].intern] = e if i >= 2 }
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(p, tgt, sel, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      else
+        args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      end
+    end
+  end
+
+  class FXToolBar
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :opts => LAYOUT_TOP|LAYOUT_LEFT|LAYOUT_FILL_X, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 3, :padRight => 3, :padTop => 2, :padBottom => 2, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      if args.length > 0 && (args[0].nil? || args[0].is_a?(FXComposite))
+        q = args[0]
+        args.each_with_index { |e, i| params[argument_names[i-1].intern] = e if i >= 1 }
+        if params.key? :padding
+          value = params.delete(:padding)
+          [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+        end
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(p, q, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+      else
+        args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+        if params.key? :padding
+          value = params.delete(:padding)
+          [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+        end
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+      end
+    end
+  end
+
+  class FXWindow
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      if p.is_a? FXApp
+        old_initialize(p, *args, &blk)
+      else
+        argument_names = %w{opts x y width height}
+        default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+        params = {}
+        params = args.pop if args.last.is_a? Hash
+        args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+        params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+        params = default_params.merge(params)
+        old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+      end
+    end
+  end
+
+  class FXMenuTitle
+    alias old_initialize initialize
+    def initialize(parent, text, *args, &blk)
+      argument_names = %w{icon popupMenu opts}
+      default_params = { :icon => nil, :popupMenu => nil, :opts => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(parent, text, params[:icon], params[:popupMenu], params[:opts], &blk)
+    end
+  end
+
+  class FXRGBImage
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix opts width height}
+      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXGIFIcon
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix clr opts width height}
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXICOImage
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix opts width height}
+      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXFontDialog
+    alias old_initialize initialize
+    def initialize(owner, name, *args, &blk)
+      argument_names = %w{opts x y width height}
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 600, :height => 380 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(owner, name, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXPPMIcon
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix clr opts width height}
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXDirBox
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_SUNKEN|FRAME_THICK|TREELISTBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXScrollArea
+    alias old_initialize initialize
+    def initialize(parent, *args, &blk)
+      argument_names = %w{opts x y width height}
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(parent, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXTabBar
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => TABBOOK_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXSeparator
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :opts => SEPARATOR_GROOVE|LAYOUT_FILL_X, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXHorizontalSeparator
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :opts => SEPARATOR_GROOVE|LAYOUT_FILL_X, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 1, :padRight => 1, :padTop => 0, :padBottom => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXVerticalSeparator
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :opts => SEPARATOR_GROOVE|LAYOUT_FILL_Y, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 1, :padBottom => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXReplaceDialog
+    alias old_initialize initialize
+    def initialize(owner, caption, *args, &blk)
+      argument_names = %w{ic opts x y width height}
+      default_params = { :ic => nil, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(owner, caption, params[:ic], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXTableItem
+    alias old_initialize initialize
+    def initialize(text, *args, &blk)
+      argument_names = %w{icon data}
+      default_params = { :icon => nil, :data => nil }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(text, params[:icon], params[:data], &blk)
+    end
+  end
+
+  class FXTable
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_MARGIN, :padRight => DEFAULT_MARGIN, :padTop => DEFAULT_MARGIN, :padBottom => DEFAULT_MARGIN }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXPNGImage
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix opts width height}
+      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXColorWell
+    alias old_initialize initialize
+    def initialize(parent, *args, &blk)
+      argument_names = %w{color target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :color => 0, :target => nil, :selector => 0, :opts => COLORWELL_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(parent, params[:color], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXFileSelector
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXStream
+    alias old_initialize initialize
+    def initialize(*args, &blk)
+      argument_names = %w{cont}
+      default_params = { :cont => nil }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(params[:cont], &blk)
+    end
+  end
+
+  class FXTriStateButton
+    alias old_initialize initialize
+    def initialize(p, text1, text2, text3, *args, &blk)
+      argument_names = %w{icon1 icon2 icon3 target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :icon1 => nil, :icon2 => nil, :icon3 => nil, :target => nil, :selector => 0, :opts => TOGGLEBUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, text1, text2, text3, params[:icon1], params[:icon2], params[:icon3], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXMenuPane
+    alias old_initialize initialize
+    def initialize(owner, *args, &blk)
+      argument_names = %w{opts}
+      default_params = { :opts => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(owner, params[:opts], &blk)
+    end
+  end
+
+  class FXComboBox
+    alias old_initialize initialize
+    def initialize(p, cols, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => COMBOBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, cols, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXPrintDialog
+    alias old_initialize initialize
+    def initialize(owner, name, *args, &blk)
+      argument_names = %w{opts x y width height}
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(owner, name, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXXBMImage
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pixels mask opts width height}
+      default_params = { :pixels => nil, :mask => nil, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pixels], params[:mask], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXMDIClient
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{opts x y width height}
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXPicker
+    alias old_initialize initialize
+    def initialize(p, text, *args, &blk)
+      argument_names = %w{ic target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :ic => nil, :target => nil, :selector => 0, :opts => BUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, text, params[:ic], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXMenuButton
+    alias old_initialize initialize
+    def initialize(parent, text, *args, &blk)
+      argument_names = %w{icon popupMenu opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :icon => nil, :popupMenu => nil, :opts => JUSTIFY_NORMAL|ICON_BEFORE_TEXT|MENUBUTTON_DOWN, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(parent, text, params[:icon], params[:popupMenu], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXProgressBar
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => PROGRESSBAR_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXMenuCheck
+    alias old_initialize initialize
+    def initialize(p, text, *args, &blk)
+      argument_names = %w{target selector opts}
+      default_params = { :target => nil, :selector => 0, :opts => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, text, params[:target], params[:selector], params[:opts], &blk)
+    end
+  end
+
+  class FXTabBook
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => TABBOOK_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXRulerView
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXApp
+    alias old_initialize initialize
+    def initialize(*args, &blk)
+      argument_names = %w{appName vendorName}
+      default_params = { :appName => "Application", :vendorName => "FoxDefault" }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(params[:appName], params[:vendorName], &blk)
+    end
+  end
+
+  class FXVisual
+    alias old_initialize initialize
+    def initialize(a, flgs, *args, &blk)
+      argument_names = %w{d}
+      default_params = { :d => 32 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, flgs, params[:d], &blk)
+    end
+  end
+
+  class FXStatusLine
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector}
+      default_params = { :target => nil, :selector => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], &blk)
+    end
+  end
+
+  class FXDelegator
+    alias old_initialize initialize
+    def initialize(*args, &blk)
+      argument_names = %w{delegate}
+      default_params = { :delegate => nil }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(params[:delegate], &blk)
+    end
+  end
+
+  class FXFileItem
+    alias old_initialize initialize
+    def initialize(text, *args, &blk)
+      argument_names = %w{bi mi ptr}
+      default_params = { :bi => nil, :mi => nil, :ptr => nil }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(text, params[:bi], params[:mi], params[:ptr], &blk)
+    end
+  end
+
+  class FXFileList
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXPacker
+    alias old_initialize initialize
+    def initialize(parent, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(parent, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+    end
+  end
+
+  class FXArrowButton
+    alias old_initialize initialize
+    def initialize(parent, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => ARROW_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(parent, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXListBox
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_SUNKEN|FRAME_THICK|LISTBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXXPMImage
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix opts width height}
+      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXButton
+    alias old_initialize initialize
+    def initialize(parent, text, *args, &blk)
+      argument_names = %w{icon target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :icon => nil, :target => nil, :selector => 0, :opts => BUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(parent, text, params[:icon], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXColorDialog
+    alias old_initialize initialize
+    def initialize(owner, title, *args, &blk)
+      argument_names = %w{opts x y width height}
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(owner, title, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXMenuCommand
+    alias old_initialize initialize
+    def initialize(p, text, *args, &blk)
+      argument_names = %w{ic target selector opts}
+      default_params = { :ic => nil, :target => nil, :selector => 0, :opts => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, text, params[:ic], params[:target], params[:selector], params[:opts], &blk)
+    end
+  end
+
+  class FXToolBarGrip
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => TOOLBARGRIP_SINGLE, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXRadioButton
+    alias old_initialize initialize
+    def initialize(parent, text, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => RADIOBUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(parent, text, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXCanvas
+    alias old_initialize initialize
+    def initialize(parent, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(parent, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXDirDialog
+    alias old_initialize initialize
+    def initialize(owner, name, *args, &blk)
+      argument_names = %w{opts x y width height}
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 500, :height => 300 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(owner, name, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXSpinner
+    alias old_initialize initialize
+    def initialize(p, cols, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => SPIN_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, cols, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXScrollPane
+    alias old_initialize initialize
+    def initialize(owner, nvis, *args, &blk)
+      argument_names = %w{opts}
+      default_params = { :opts => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(owner, nvis, params[:opts], &blk)
+    end
+  end
+
+  class FXTIFImage
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix opts width height}
+      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXFontSelector
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXDirItem
+    alias old_initialize initialize
+    def initialize(text, *args, &blk)
+      argument_names = %w{oi ci data}
+      default_params = { :oi => nil, :ci => nil, :data => nil }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(text, params[:oi], params[:ci], params[:data], &blk)
+    end
+  end
+
+  class FXDirList
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXFileStream
+    alias old_initialize initialize
+    def initialize(*args, &blk)
+      argument_names = %w{cont}
+      default_params = { :cont => nil }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(params[:cont], &blk)
+    end
+  end
+
+  class FXHeaderItem
+    alias old_initialize initialize
+    def initialize(text, *args, &blk)
+      argument_names = %w{ic s ptr}
+      default_params = { :ic => nil, :s => 0, :ptr => nil }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(text, params[:ic], params[:s], params[:ptr], &blk)
+    end
+  end
+
+  class FXHeader
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => HEADER_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXJPGIcon
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix clr opts width height quality}
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1, :quality => 75 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], params[:quality], &blk)
+    end
+  end
+
+  class FXDial
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => DIAL_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXScintilla
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXBMPImage
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix opts width height}
+      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXRGBIcon
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix clr opts width height}
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXColorSelector
+    alias old_initialize initialize
+    def initialize(parent, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(parent, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXSlider
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => SLIDER_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXCheckButton
+    alias old_initialize initialize
+    def initialize(parent, text, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => CHECKBUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(parent, text, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXDataTarget
+    alias old_initialize initialize
+    def initialize(*args, &blk)
+      argument_names = %w{value target selector}
+      default_params = { :value => nil, :target => nil, :selector => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(params[:value], params[:target], params[:selector], &blk)
+    end
+  end
+
+  class FXTreeListBox
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_SUNKEN|FRAME_THICK|TREELISTBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXKnob
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => KNOB_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXSplashWindow
+    alias old_initialize initialize
+    def initialize(owner, icon, *args, &blk)
+      argument_names = %w{opts ms}
+      default_params = { :opts => SPLASH_SIMPLE, :ms => 5000 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(owner, icon, params[:opts], params[:ms], &blk)
+    end
+  end
+
+  class FXScrollBar
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => SCROLLBAR_VERTICAL, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXTabItem
+    alias old_initialize initialize
+    def initialize(p, text, *args, &blk)
+      argument_names = %w{ic opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :ic => nil, :opts => TAB_TOP_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, text, params[:ic], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXBitmapFrame
+    alias old_initialize initialize
+    def initialize(p, bmp, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :opts => FRAME_SUNKEN|FRAME_THICK, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, bmp, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXSearchDialog
+    alias old_initialize initialize
+    def initialize(owner, caption, *args, &blk)
+      argument_names = %w{ic opts x y width height}
+      default_params = { :ic => nil, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(owner, caption, params[:ic], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXRealSpinner
+    alias old_initialize initialize
+    def initialize(p, cols, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => REALSPIN_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, cols, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXTextField
+    alias old_initialize initialize
+    def initialize(p, ncols, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => TEXTFIELD_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, ncols, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXMenuRadio
+    alias old_initialize initialize
+    def initialize(p, text, *args, &blk)
+      argument_names = %w{target selector opts}
+      default_params = { :target => nil, :selector => 0, :opts => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, text, params[:target], params[:selector], params[:opts], &blk)
+    end
+  end
+
+  class FXShutterItem
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{text icon opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :text => "", :icon => nil, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:text], params[:icon], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+    end
+  end
+
+  class FXShutter
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+    end
+  end
+
+  class FXGLContext
+    alias old_initialize initialize
+    def initialize(app, visual, *args, &blk)
+      argument_names = %w{other}
+      default_params = { :other => nil }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(app, visual, params[:other], &blk)
+    end
+  end
+
+  class FXGIFCursor
+    alias old_initialize initialize
+    def initialize(a, pix, *args, &blk)
+      argument_names = %w{hx hy}
+      default_params = { :hx => -1, :hy => -1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, pix, params[:hx], params[:hy], &blk)
+    end
+  end
+
+  class FXBMPIcon
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix clr opts width height}
+      default_params = { :pix => nil, :clr => Fox.FXRGB(192,192,192), :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXColorWheel
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXIconDict
+    alias old_initialize initialize
+    def initialize(app, *args, &blk)
+      argument_names = %w{path}
+      default_params = { :path => FXIconDict.defaultIconPath }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(app, params[:path], &blk)
+    end
+  end
+
+  class FXFrame
+    alias old_initialize initialize
+    def initialize(parent, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :opts => FRAME_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(parent, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXText
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 3, :padRight => 3, :padTop => 2, :padBottom => 2 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+    alias old_findText findText
+    def findText(string, *args)
+      argument_names = %w{start flags}
+      default_params = { :start => 0, :flags => SEARCH_FORWARD|SEARCH_WRAP|SEARCH_EXACT }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_findText(string, params[:start], params[:flags])
+    end
+  end
+
+  class FXJPGImage
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix opts width height quality}
+      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1, :quality => 75 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], params[:quality], &blk)
+    end
+  end
+
+  class FXProgressDialog
+    alias old_initialize initialize
+    def initialize(owner, caption, label, *args, &blk)
+      argument_names = %w{opts x y width height}
+      default_params = { :opts => PROGRESSDIALOG_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(owner, caption, label, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXRuler
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => RULER_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXSpring
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{opts relw relh x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :opts => 0, :relw => 0, :relh => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:opts], params[:relw], params[:relh], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+    end
+  end
+
+  class FXTGAImage
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix opts width height}
+      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXPCXIcon
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix clr opts width height}
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXToolTip
+    alias old_initialize initialize
+    def initialize(app, *args, &blk)
+      argument_names = %w{opts x y width height}
+      default_params = { :opts => TOOLTIP_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(app, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXImageFrame
+    alias old_initialize initialize
+    def initialize(p, img, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :opts => FRAME_SUNKEN|FRAME_THICK, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, img, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXPPMImage
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix opts width height}
+      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXWizard
+    alias old_initialize initialize
+    def initialize(owner, name, image, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :opts => DECOR_TITLE|DECOR_BORDER|DECOR_RESIZE, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 10, :padRight => 10, :padTop => 10, :padBottom => 10, :hSpacing => 10, :vSpacing => 10 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(owner, name, image, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+    end
+  end
+
+  class FXXPMIcon
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix clr opts width height}
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXDockTitle
+    alias old_initialize initialize
+    def initialize(p, text, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_NORMAL|JUSTIFY_CENTER_X|JUSTIFY_CENTER_Y, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, text, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXVerticalFrame
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+    end
+  end
+
+  class FXFileDict
+    alias old_initialize initialize
+    def initialize(app, *args, &blk)
+      argument_names = %w{db}
+      default_params = { :db => nil }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(app, params[:db], &blk)
+    end
+  end
+
+  class FXScrollWindow
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{opts x y width height}
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXMainWindow
+    alias old_initialize initialize
+    def initialize(app, title, *args, &blk)
+      argument_names = %w{icon miniIcon opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :icon => nil, :miniIcon => nil, :opts => DECOR_ALL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0, :hSpacing => 4, :vSpacing => 4 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(app, title, params[:icon], params[:miniIcon], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+    end
+  end
+
+  class FXToolBarTab
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_RAISED, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXPopup
+    alias old_initialize initialize
+    def initialize(owner, *args, &blk)
+      argument_names = %w{opts x y width height}
+      default_params = { :opts => POPUP_VERTICAL|FRAME_RAISED|FRAME_THICK, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(owner, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXHorizontalFrame
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+    end
+  end
+
+  class FXICOIcon
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix clr opts width height}
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXColorItem
+    alias old_initialize initialize
+    def initialize(text, clr, *args, &blk)
+      argument_names = %w{data}
+      default_params = { :data => nil }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(text, clr, params[:data], &blk)
+    end
+  end
+
+  class FXColorList
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => LIST_BROWSESELECT, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXTIFIcon
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix clr opts width height}
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXRealSlider
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => REALSLIDER_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXMessageBox
+    alias old_initialize initialize
+    def initialize(owner, caption, text, *args, &blk)
+      argument_names = %w{ic opts x y}
+      default_params = { :ic => nil, :opts => 0, :x => 0, :y => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(owner, caption, text, params[:ic], params[:opts], params[:x], params[:y], &blk)
+    end
+  end
+
+  class FXToolBarShell
+    alias old_initialize initialize
+    def initialize(owner, *args, &blk)
+      argument_names = %w{opts x y width height hSpacing vSpacing}
+      default_params = { :opts => FRAME_RAISED|FRAME_THICK, :x => 0, :y => 0, :width => 0, :height => 0, :hSpacing => 4, :vSpacing => 4 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(owner, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:hSpacing], params[:vSpacing], &blk)
+    end
+  end
+
+  class FXImageView
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{img target selector opts x y width height}
+      default_params = { :img => nil, :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:img], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXChoiceBox
+    alias old_initialize initialize
+    def initialize(owner, caption, text, icon, choices, *args, &blk)
+      argument_names = %w{opts x y width height}
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(owner, caption, text, icon, choices, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXOption
+    alias old_initialize initialize
+    def initialize(p, text, *args, &blk)
+      argument_names = %w{ic target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :ic => nil, :target => nil, :selector => 0, :opts => JUSTIFY_NORMAL|ICON_BEFORE_TEXT, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, text, params[:ic], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXOptionMenu
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{pup opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :pup => nil, :opts => JUSTIFY_NORMAL|ICON_BEFORE_TEXT, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:pup], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXBitmap
+    alias old_initialize initialize
+    def initialize(app, *args, &blk)
+      argument_names = %w{pixels opts width height}
+      default_params = { :pixels => nil, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(app, params[:pixels], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXMDIChild
+    alias old_initialize initialize
+    def initialize(p, name, *args, &blk)
+      argument_names = %w{ic pup opts x y width height}
+      default_params = { :ic => nil, :pup => nil, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, name, params[:ic], params[:pup], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXListItem
+    alias old_initialize initialize
+    def initialize(text, *args, &blk)
+      argument_names = %w{icon data}
+      default_params = { :icon => nil, :data => nil }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(text, params[:icon], params[:data], &blk)
+    end
+  end
+
+  class FXList
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => LIST_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXIconItem
+    alias old_initialize initialize
+    def initialize(text, *args, &blk)
+      argument_names = %w{bigIcon miniIcon data}
+      default_params = { :bigIcon => nil, :miniIcon => nil, :data => nil }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(text, params[:bigIcon], params[:miniIcon], params[:data], &blk)
+    end
+  end
+
+  class FXIconList
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => ICONLIST_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FX7Segment
+    alias old_initialize initialize
+    def initialize(p, text, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :opts => SEVENSEGMENT_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, text, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXXBMIcon
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pixels mask clr opts width height}
+      default_params = { :pixels => nil, :mask => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pixels], params[:mask], params[:clr], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXInputDialog
+    alias old_initialize initialize
+    def initialize(owner, caption, label, *args, &blk)
+      argument_names = %w{icon opts x y width height}
+      default_params = { :icon => nil, :opts => INPUTDIALOG_STRING, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(owner, caption, label, params[:icon], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXMenuSeparator
+    alias old_initialize initialize
+    def initialize(parent, *args, &blk)
+      argument_names = %w{opts}
+      default_params = { :opts => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(parent, params[:opts], &blk)
+    end
+  end
+
+  class FXDialogBox
+    alias old_initialize initialize
+    def initialize(owner, title, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :opts => DECOR_TITLE|DECOR_BORDER, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 10, :padRight => 10, :padTop => 10, :padBottom => 10, :hSpacing => 4, :vSpacing => 4 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(owner, title, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+    end
+  end
+
+  class FXPCXImage
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix opts width height}
+      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXMenuCaption
+    alias old_initialize initialize
+    def initialize(parent, text, *args, &blk)
+      argument_names = %w{icon opts}
+      default_params = { :icon => nil, :opts => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(parent, text, params[:icon], params[:opts], &blk)
+    end
+  end
+
+  class FXGradientBar
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXMDIDeleteButton
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_RAISED, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXMDIRestoreButton
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_RAISED, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXMDIMaximizeButton
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_RAISED, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXMDIMinimizeButton
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_RAISED, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXMDIWindowButton
+    alias old_initialize initialize
+    def initialize(p, pup, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, pup, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXMDIMenu
+    alias old_initialize initialize
+    def initialize(owner, *args, &blk)
+      argument_names = %w{target}
+      default_params = { :target => nil }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(owner, params[:target], &blk)
+    end
+  end
+
+  class FXFileDialog
+    alias old_initialize initialize
+    def initialize(owner, name, *args, &blk)
+      argument_names = %w{opts x y width height}
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 500, :height => 300 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(owner, name, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXPNGIcon
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix clr opts width height}
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXGroupBox
+    alias old_initialize initialize
+    def initialize(parent, text, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :opts => GROUPBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(parent, text, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+    end
+  end
+
+  class FXIcon
+    alias old_initialize initialize
+    def initialize(app, *args, &blk)
+      argument_names = %w{pix clr opts width height}
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(app, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXFoldingItem
+    alias old_initialize initialize
+    def initialize(text, *args, &blk)
+      argument_names = %w{openIcon closedIcon data}
+      default_params = { :openIcon => nil, :closedIcon => nil, :data => nil }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(text, params[:openIcon], params[:closedIcon], params[:data], &blk)
+    end
+  end
+
+  class FXFoldingList
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => TREELIST_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXColorRing
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXMenuCascade
+    alias old_initialize initialize
+    def initialize(parent, text, *args, &blk)
+      argument_names = %w{icon popupMenu opts}
+      default_params = { :icon => nil, :popupMenu => nil, :opts => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(parent, text, params[:icon], params[:popupMenu], params[:opts], &blk)
+    end
+  end
+
+  class FXBitmapView
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{bmp target selector opts x y width height}
+      default_params = { :bmp => nil, :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:bmp], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXComposite
+    alias old_initialize initialize
+    def initialize(parent, *args, &blk)
+      argument_names = %w{opts x y width height}
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(parent, params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXImage
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pixels opts width height}
+      default_params = { :pixels => nil, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pixels], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXStatusBar
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 3, :padRight => 3, :padTop => 2, :padBottom => 2, :hSpacing => 4, :vSpacing => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+    end
+  end
+
+  class FXRegistry
+    alias old_initialize initialize
+    def initialize(*args, &blk)
+      argument_names = %w{appKey vendorKey}
+      default_params = { :appKey => "", :vendorKey => "" }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(params[:appKey], params[:vendorKey], &blk)
+    end
+  end
+
+  class FXGIFImage
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix opts width height}
+      default_params = { :pix => nil, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pix], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXDriveBox
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_SUNKEN|FRAME_THICK|LISTBOX_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXSwitcher
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXTGAIcon
+    alias old_initialize initialize
+    def initialize(a, *args, &blk)
+      argument_names = %w{pix clr opts width height}
+      default_params = { :pix => nil, :clr => 0, :opts => 0, :width => 1, :height => 1 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(a, params[:pix], params[:clr], params[:opts], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXToggleButton
+    alias old_initialize initialize
+    def initialize(p, text1, text2, *args, &blk)
+      argument_names = %w{icon1 icon2 target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :icon1 => nil, :icon2 => nil, :target => nil, :selector => 0, :opts => TOGGLEBUTTON_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, text1, text2, params[:icon1], params[:icon2], params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXColorBar
+    alias old_initialize initialize
+    def initialize(parent, *args, &blk)
+      argument_names = %w{target selector opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :target => nil, :selector => 0, :opts => FRAME_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(parent, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+  class FXDockSite
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => 0, :padRight => 0, :padTop => 0, :padBottom => 0, :hSpacing => 0, :vSpacing => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+    end
+  end
+
+  class FXMemoryStream
+    alias old_initialize initialize
+    def initialize(*args, &blk)
+      argument_names = %w{cont}
+      default_params = { :cont => nil }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(params[:cont], &blk)
+    end
+  end
+
+  class FXTreeItem
+    alias old_initialize initialize
+    def initialize(text, *args, &blk)
+      argument_names = %w{openIcon closedIcon data}
+      default_params = { :openIcon => nil, :closedIcon => nil, :data => nil }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(text, params[:openIcon], params[:closedIcon], params[:data], &blk)
+    end
+  end
+
+  class FXTreeList
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => TREELIST_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXDirSelector
+    alias old_initialize initialize
+    def initialize(p, *args, &blk)
+      argument_names = %w{target selector opts x y width height}
+      default_params = { :target => nil, :selector => 0, :opts => 0, :x => 0, :y => 0, :width => 0, :height => 0 }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(p, params[:target], params[:selector], params[:opts], params[:x], params[:y], params[:width], params[:height], &blk)
+    end
+  end
+
+  class FXMatrix
+    alias old_initialize initialize
+    def initialize(parent, *args, &blk)
+      argument_names = %w{n opts x y width height padLeft padRight padTop padBottom hSpacing vSpacing}
+      default_params = { :n => 1, :opts => MATRIX_BY_ROWS, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_SPACING, :padRight => DEFAULT_SPACING, :padTop => DEFAULT_SPACING, :padBottom => DEFAULT_SPACING, :hSpacing => DEFAULT_SPACING, :vSpacing => DEFAULT_SPACING }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(parent, params[:n], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], params[:hSpacing], params[:vSpacing], &blk)
+    end
+  end
+
+  class FXLabel
+    alias old_initialize initialize
+    def initialize(parent, text, *args, &blk)
+      argument_names = %w{icon opts x y width height padLeft padRight padTop padBottom}
+      default_params = { :icon => nil, :opts => LABEL_NORMAL, :x => 0, :y => 0, :width => 0, :height => 0, :padLeft => DEFAULT_PAD, :padRight => DEFAULT_PAD, :padTop => DEFAULT_PAD, :padBottom => DEFAULT_PAD }
+      params = {}
+      params = args.pop if args.last.is_a? Hash
+      args.each_with_index { |e, i| params[argument_names[i].intern] = e }
+      if params.key? :padding
+        value = params.delete(:padding)
+        [:padLeft, :padRight, :padTop, :padBottom].each { |s| params[s] ||= value }
+      end
+      params.keys.each { |key| raise ArgumentError, "Unrecognized parameter #{key}" unless default_params.keys.include?(key) }
+      params = default_params.merge(params)
+      old_initialize(parent, text, params[:icon], params[:opts], params[:x], params[:y], params[:width], params[:height], params[:padLeft], params[:padRight], params[:padTop], params[:padBottom], &blk)
+    end
+  end
+
+end
+
+$VERBOSE = old_verbose
diff --git a/lib/fox16/missingdep.rb b/lib/fox16/missingdep.rb
old mode 100755
new mode 100644
diff --git a/lib/fox16/pseudokeyboard.rb b/lib/fox16/pseudokeyboard.rb
old mode 100755
new mode 100644
diff --git a/lib/fox16/pseudomouse.rb b/lib/fox16/pseudomouse.rb
old mode 100755
new mode 100644
diff --git a/lib/fox16/responder.rb b/lib/fox16/responder.rb
old mode 100755
new mode 100644
diff --git a/lib/fox16/responder2.rb b/lib/fox16/responder2.rb
old mode 100755
new mode 100644
diff --git a/lib/fox16/scintilla.rb b/lib/fox16/scintilla.rb
old mode 100755
new mode 100644
diff --git a/lib/fox16/settings.rb b/lib/fox16/settings.rb
old mode 100755
new mode 100644
diff --git a/lib/fox16/signal.rb b/lib/fox16/signal.rb
old mode 100755
new mode 100644
diff --git a/lib/fox16/thread.rb b/lib/fox16/thread.rb
new file mode 100644
index 00000000..78ece6d1
--- /dev/null
+++ b/lib/fox16/thread.rb
@@ -0,0 +1,52 @@
+require 'thread'
+
+module Fox
+
+  class FXApp
+
+    alias initialize_before_thread initialize # :nodoc:
+
+    def initialize(*args, &block)
+      initialize_before_thread(*args)
+      event_handler_setup
+      block.call(self) if block_given?
+    end
+
+    def runOnUiThread(&block)
+      @event_handler_events << block
+      @event_handler_pwr.write 'e'
+    end
+
+    private
+
+    def event_handler_setup
+      if RUBY_PLATFORM =~ /mingw|mswin/i
+        require 'socket'
+        gs = TCPServer.open('localhost', 0)
+        prd = TCPSocket.open('localhost', gs.addr[1])
+        pwr = gs.accept
+        gs.close
+      else
+        prd, pwr = IO.pipe
+      end
+      self.addInput(prd, Fox::INPUT_READ){ event_handler_pull(prd) }
+      @event_handler_pwr = pwr
+      @event_handler_events = Queue.new
+    end
+
+    def event_handler_pull(prd)
+      prd.read(1)
+      while !@event_handler_events.empty?
+        ev = @event_handler_events.shift
+        ev.call
+      end
+    end
+
+  end # class FXApp
+
+  class FXId
+    def runOnUiThread(&block)
+      app.runOnUiThread(&block)
+    end
+  end
+end # module Fox
diff --git a/lib/fox16/timeout.rb b/lib/fox16/timeout.rb
old mode 100755
new mode 100644
diff --git a/lib/fox16/tkcompat.rb b/lib/fox16/tkcompat.rb
old mode 100755
new mode 100644
diff --git a/lib/fox16/undolist.rb b/lib/fox16/undolist.rb
old mode 100755
new mode 100644
index 49080677..fcdfbceb
--- a/lib/fox16/undolist.rb
+++ b/lib/fox16/undolist.rb
@@ -344,9 +344,9 @@ module Fox
 
     def onUpdUndo(sender, sel, ptr) # :nodoc:
       if canUndo?
-	sender.handle(self, MKUINT(FXWindow::ID_ENABLE, SEL_COMMAND), nil)
+	sender.handle(self, Fox.MKUINT(FXWindow::ID_ENABLE, SEL_COMMAND), nil)
       else
-	sender.handle(self, MKUINT(FXWindow::ID_DISABLE, SEL_COMMAND), nil)
+	sender.handle(self, Fox.MKUINT(FXWindow::ID_DISABLE, SEL_COMMAND), nil)
       end
       return 1
     end
@@ -358,9 +358,9 @@ module Fox
 
     def onUpdRedo(sender, sel, ptr) # :nodoc:
       if canRedo?
-	sender.handle(self, MKUINT(FXWindow::ID_ENABLE, SEL_COMMAND), nil)
+	sender.handle(self, Fox.MKUINT(FXWindow::ID_ENABLE, SEL_COMMAND), nil)
       else
-	sender.handle(self, MKUINT(FXWindow::ID_DISABLE, SEL_COMMAND), nil)
+	sender.handle(self, Fox.MKUINT(FXWindow::ID_DISABLE, SEL_COMMAND), nil)
       end
       return 1
     end
@@ -372,9 +372,9 @@ module Fox
 
     def onUpdClear(sender, sel, ptr) # :nodoc:
       if canUndo? || canRedo?
-	sender.handle(self, MKUINT(FXWindow::ID_ENABLE, SEL_COMMAND), nil)
+	sender.handle(self, Fox.MKUINT(FXWindow::ID_ENABLE, SEL_COMMAND), nil)
       else
-	sender.handle(self, MKUINT(FXWindow::ID_DISABLE, SEL_COMMAND), nil)
+	sender.handle(self, Fox.MKUINT(FXWindow::ID_DISABLE, SEL_COMMAND), nil)
       end
       return 1
     end
@@ -386,9 +386,9 @@ module Fox
 
     def onUpdRevert(sender, sel, ptr) # :nodoc:
       if canRevert?
-	sender.handle(self, MKUINT(FXWindow::ID_ENABLE, SEL_COMMAND), nil)
+	sender.handle(self, Fox.MKUINT(FXWindow::ID_ENABLE, SEL_COMMAND), nil)
       else
-	sender.handle(self, MKUINT(FXWindow::ID_DISABLE, SEL_COMMAND), nil)
+	sender.handle(self, Fox.MKUINT(FXWindow::ID_DISABLE, SEL_COMMAND), nil)
       end
       return 1
     end
diff --git a/lib/fox16/version.rb b/lib/fox16/version.rb
old mode 100755
new mode 100644
index 9b6237ad..bbdc0e29
--- a/lib/fox16/version.rb
+++ b/lib/fox16/version.rb
@@ -1,5 +1,5 @@
 module Fox
   def Fox.fxrubyversion
-    "1.6.29"
+    "1.6.42"
   end
 end
diff --git a/rdoc-sources/FXApp.rb b/rdoc-sources/FXApp.rb
index d21b7f3b..3e533be2 100755
--- a/rdoc-sources/FXApp.rb
+++ b/rdoc-sources/FXApp.rb
@@ -538,5 +538,10 @@ module Fox
 
     # Check to see if multithreaded applications are supported
     def threadsEnabled?(); end
+
+    # Runs the specified block on the UI thread.
+    #
+    # The block is posted to the event queue of the UI thread.
+    def runOnUiThread(&block); end
   end
 end
diff --git a/rdoc-sources/FXGLVisual.rb b/rdoc-sources/FXGLVisual.rb
index b341b8be..c2ccbc36 100755
--- a/rdoc-sources/FXGLVisual.rb
+++ b/rdoc-sources/FXGLVisual.rb
@@ -77,6 +77,14 @@ module Fox
     # even support no OpenGL at all!  This function returns the lesser
     # of the client support level and the display server support level.
     #
+    # Return an array with the following 3 elements: [supported, major, minor]
+    #
+    def FXGLVisual.supported(app); end
+
+    # Test if OpenGL is possible.
+    #
+    # Same as {FXGLVisual.supported}, but returns the first element (true/false) only.
+    #
     def FXGLVisual.supported?(app); end
 
     # Return +true+ if double-buffered
diff --git a/rdoc-sources/FXIconList.rb b/rdoc-sources/FXIconList.rb
index 5cdbca25..b67a9c4c 100755
--- a/rdoc-sources/FXIconList.rb
+++ b/rdoc-sources/FXIconList.rb
@@ -267,6 +267,8 @@ module Fox
     # after the item is appended.
     def appendItem(text, bigIcon=nil, miniIcon=nil, data=nil, notify=false); end
 
+    alias << appendItem
+
     # Prepend a new (possibly subclassed) _item_ to the beginning of the list.
     # If _notify_ is +true+, a +SEL_INSERTED+ message is sent to the list's message target
     # after the item is prepended.
diff --git a/rdoc-sources/FXId.rb b/rdoc-sources/FXId.rb
index 664c4f9d..cbef7252 100755
--- a/rdoc-sources/FXId.rb
+++ b/rdoc-sources/FXId.rb
@@ -30,5 +30,10 @@ module Fox
     # Destroy resource.
     #
     def destroy(); end
+
+    # Runs the specified block on the UI thread.
+    #
+    # The block is posted to the event queue of the UI thread.
+    def runOnUiThread(&block); end
   end
 end
diff --git a/rdoc-sources/FXImage.rb b/rdoc-sources/FXImage.rb
index 46292c16..582fc2f2 100755
--- a/rdoc-sources/FXImage.rb
+++ b/rdoc-sources/FXImage.rb
@@ -45,6 +45,11 @@ module Fox
     # [deprecated] Pixel data {FXMemoryBuffer}
     attr_reader :data
 
+    # The pointer to the raw color representation of all image pixels.
+    #
+    # It can be used to pass raw image data to FFI, Fiddle or OpenGL.
+    attr_reader :dataPtr
+
     # Array of colors of all image pixels. Can also be written as String of raw [RGBA] values.
     attr_accessor :pixels
 
diff --git a/rdoc-sources/FXList.rb b/rdoc-sources/FXList.rb
index e00980cd..a7621a19 100755
--- a/rdoc-sources/FXList.rb
+++ b/rdoc-sources/FXList.rb
@@ -217,6 +217,8 @@ module Fox
     # Returns the integer index of the newly appended item.
     def appendItem(text, icon=nil, data=nil, notify=false) ; end
 
+    alias << appendItem
+
     # Prepend a (possibly subclassed) _item_ to the list, e.g.
     #
     #   list.prependItem(FXListItem.new("clyde"))
diff --git a/rdoc-sources/FXListBox.rb b/rdoc-sources/FXListBox.rb
index d5ef5e6e..40dc9551 100755
--- a/rdoc-sources/FXListBox.rb
+++ b/rdoc-sources/FXListBox.rb
@@ -186,6 +186,6 @@ module Fox
     # Sort items using current sort function
     def sortItems; end
 
-    alias appendItem <<
+    alias << appendItem
   end
 end
diff --git a/rdoc-sources/FXText.rb b/rdoc-sources/FXText.rb
index 635d5668..81581bec 100755
--- a/rdoc-sources/FXText.rb
+++ b/rdoc-sources/FXText.rb
@@ -436,8 +436,8 @@ module Fox
     #
     # Search for _string_ in text buffer, and return the extent of
     # the string as a two-element array of arrays.
-    # The first array contains the beginning index (or indices)
-    # and the second array contains the ending index (or indices).
+    # The first array contains the beginning index (or indices if +SEARCH_REGEX+)
+    # and the second array contains the ending index (or indices if +SEARCH_REGEX+) of the first match.
     # The search starts from the given
     # _start_ position, scans forward (+SEARCH_FORWARD+) or backward
     # (+SEARCH_BACKWARD+), and wraps around if +SEARCH_WRAP+ has been
@@ -445,6 +445,8 @@ module Fox
     # case insensitive search (+SEARCH_IGNORECASE+), or regular expression
     # search (+SEARCH_REGEX+).
     #
+    # For regular expression searches, the found regex match begin and end is returned at index 0 and captures are returned as entries starting at index 1 in both beginning and ending arrays.
+    #
     def findText(string, start=0, flags=SEARCH_FORWARD|SEARCH_WRAP|SEARCH_EXACT); end
 
     # Return +true+ if position _pos_ is selected
diff --git a/swig-interfaces/FXApp.i b/swig-interfaces/FXApp.i
index 9f20fca0..9e7f18ee 100644
--- a/swig-interfaces/FXApp.i
+++ b/swig-interfaces/FXApp.i
@@ -357,18 +357,13 @@ public:
     */
     bool addInput(VALUE obj,FXuint mode,FXObject *tgt,FXSelector sel){
       FXInputHandle fd;
-      FXuint m;
-      if(mode&INPUT_READ){
-        m=INPUT_READ;
-        if(mode&INPUT_EXCEPT) m|=INPUT_EXCEPT;
-        fd=FXRbGetReadFileHandle(obj);
-        self->addInput(fd,m,tgt,sel);
+      if(mode&(INPUT_READ|INPUT_EXCEPT)){
+        fd=FXRbGetReadFileHandle(obj, mode);
+        self->addInput(fd,mode,tgt,sel);
         }
-      if(mode&INPUT_WRITE){
-        m=INPUT_WRITE;
-        if(mode&INPUT_EXCEPT) m|=INPUT_EXCEPT;
-        fd=FXRbGetWriteFileHandle(obj);
-        self->addInput(fd,m,tgt,sel);
+      if(mode&(INPUT_WRITE|INPUT_EXCEPT)){
+        fd=FXRbGetWriteFileHandle(obj, mode);
+        self->addInput(fd,mode,tgt,sel);
         }
       return true;
       }
@@ -379,18 +374,15 @@ public:
     */
     bool removeInput(VALUE obj,FXuint mode){
       FXInputHandle fd;
-      FXuint m;
-      if(mode&INPUT_READ){
-        m=INPUT_READ;
-        if(mode&INPUT_EXCEPT) m|=INPUT_EXCEPT;
-        fd=FXRbGetReadFileHandle(obj);
-        self->removeInput(fd,m);
+      if(mode&(INPUT_READ|INPUT_EXCEPT)){
+        fd=FXRbGetReadFileHandle(obj, mode);
+        self->removeInput(fd,mode);
+        FXRbRemoveReadFileHandle(obj, mode);
         }
-      if(mode&INPUT_WRITE){
-        m=INPUT_WRITE;
-        if(mode&INPUT_EXCEPT) m|=INPUT_EXCEPT;
-        fd=FXRbGetWriteFileHandle(obj);
-        self->removeInput(fd,m);
+      if(mode&(INPUT_WRITE|INPUT_EXCEPT)){
+        fd=FXRbGetWriteFileHandle(obj, mode);
+        self->removeInput(fd,mode);
+        FXRbRemoveWriteFileHandle(obj, mode);
         }
       return true;
       }
@@ -402,62 +394,6 @@ public:
   /// Peek to determine if there's an event
   bool peekEvent();
 
-  /// Perform one event dispatch; return true if event was dispatched
-  bool runOneEvent(bool blocking=true);
-
-  /**
-  * Run the main application event loop until stop() is called,
-  * and return the exit code passed as argument to stop().
-  */
-  FXint run();
-
-  /**
-  * Run an event loop till some flag becomes non-zero, and
-  * then return.
-  */
-  FXint runUntil(FXuint& condition); // FIXME
-
-  /**
-  * Run event loop while events are available, non-modally.
-  * Return when no more events, timers, or chores are outstanding.
-  */
-  FXint runWhileEvents();
-
-  /**
-  * Run event loop while there are events are available in the queue.
-  * Returns 1 when all events in the queue have been handled, and 0 when
-  * the event loop was terminated due to stop() or stopModal().
-  * Except for the modal window and its children, user input to all windows
-  * is blocked; if the modal window is NULL, all user input is blocked.
-  */
-  FXint runModalWhileEvents(FXWindow* window=NULL);
-
-  /**
-  * Run modal event loop, blocking keyboard and mouse events to all windows
-  * until stopModal is called.
-  */
-  FXint runModal();
-
-  /**
-  * Run a modal event loop for the given window, until stop() or stopModal() is
-  * called. Except for the modal window and its children, user input to all
-  * windows is blocked; if the modal window is NULL all user input is blocked.
-  */
-  FXint runModalFor(FXWindow* window);
-
-  /**
-  * Run modal while window is shown, or until stop() or stopModal() is called.
-  * Except for the modal window and its children, user input to all windows
-  * is blocked; if the modal window is NULL all user input is blocked.
-  */
-  FXint runModalWhileShown(FXWindow* window);
-
-  /**
-  * Run popup menu while shown, until stop() or stopModal() is called.
-  * Also returns when entering previous cascading popup menu.
-  */
-  FXint runPopup(FXWindow* owner);
-
   /// True if the window is modal
   bool isModal(FXWindow* window) const;
 
diff --git a/swig-interfaces/FXGLVisual.i b/swig-interfaces/FXGLVisual.i
index 5e9cc95c..5d316b35 100644
--- a/swig-interfaces/FXGLVisual.i
+++ b/swig-interfaces/FXGLVisual.i
@@ -41,7 +41,7 @@ public:
    * of the client support level and the display server support level.
    */
   %extend {
-    static FXbool supported(FXApp* application){
+    static VALUE supported(FXApp* application){
       int major,minor;
       FXbool answer=FXGLVisual::supported(application,major,minor);
       return rb_ary_new3(3,answer?Qtrue:Qfalse,INT2NUM(major),INT2NUM(minor));
diff --git a/swig-interfaces/FXImage.i b/swig-interfaces/FXImage.i
index c472d732..df9971db 100644
--- a/swig-interfaces/FXImage.i
+++ b/swig-interfaces/FXImage.i
@@ -58,7 +58,7 @@ public:
     FXImage(FXApp* a,VALUE string_or_ary=Qnil,FXuint opts=0,FXint w=1,FXint h=1){
       FXColor* pix=0;
       if(!NIL_P(string_or_ary)){
-        FXuint len=FXRbNumberOfFXColors(string_or_ary);
+        FXint len=FXRbNumberOfFXColors(string_or_ary);
         if(w*h != len){
           rb_raise( rb_eArgError, "Array size does not match image size" );
         }
@@ -76,6 +76,11 @@ public:
         return 0;
       }
     }
+
+    /// Get a pointer to the pixel data
+    VALUE getDataPtr() const {
+      return ULL2NUM((uintptr_t)self->getData());
+    }
   }
 
   /// To get to the option flags
@@ -92,9 +97,9 @@ public:
     * This can be done by calling render().
     */
     void setPixels(VALUE string_or_ary,FXuint opts=0,VALUE w=Qnil,VALUE h=Qnil){
-      FXuint len=FXRbNumberOfFXColors(string_or_ary);
+      FXint len=FXRbNumberOfFXColors(string_or_ary);
       if( ( (NIL_P(w) || NIL_P(h)) && self->getWidth()*self->getHeight() != len) ||
-          (!(NIL_P(w) || NIL_P(h)) && NUM2UINT(w)*NUM2UINT(h) != len)){
+          (!(NIL_P(w) || NIL_P(h)) && NUM2INT(w)*NUM2INT(h) != len)){
         rb_raise( rb_eArgError, "Array size does not match image size" );
       }
 
@@ -111,7 +116,7 @@ public:
       if (data) {
         FXuint size = self->getWidth()*self->getHeight();
         VALUE ary = rb_ary_new2(size);
-        for (int i = 0; i < size; i++)
+        for (FXuint i = 0; i < size; i++)
           rb_ary_store(ary, i, UINT2NUM(data[i]));
         return ary;
       } else {
diff --git a/swig-interfaces/FXMemoryBuffer.i b/swig-interfaces/FXMemoryBuffer.i
index 3382e4da..4e3dd14c 100644
--- a/swig-interfaces/FXMemoryBuffer.i
+++ b/swig-interfaces/FXMemoryBuffer.i
@@ -27,19 +27,19 @@
 class FXMemoryBuffer {
 public:
   // Create an memory buffer object
-  FXMemoryBuffer(FXColor *data,FXuint size);
+  FXMemoryBuffer(FXColor *data,FXint size);
 
   // Returns the size (in bytes)
   FXuint getSize() const;
 
   %extend {
-    // Returns the data as an array of Bignums
+    // Returns the data as an array of Integers
     VALUE getData() const {
       FXColor* data = self->getData();
       if (data) {
         FXuint size = self->getSize();
         VALUE ary = rb_ary_new2(size);
-        for (int i = 0; i < size; i++)
+        for (FXuint i = 0; i < size; i++)
           rb_ary_store(ary, i, UINT2NUM(data[i]));
         return ary;
         }
diff --git a/swig-interfaces/FXText.i b/swig-interfaces/FXText.i
index c8569fdf..f3001908 100644
--- a/swig-interfaces/FXText.i
+++ b/swig-interfaces/FXText.i
@@ -519,6 +519,8 @@ public:
 
   %extend {
     /**
+    * TODO: Change API to return [beg, end] instead of [[beg], [end]] for non regex.
+    *
     * Search for string in text buffer, returning the extent of
     * the string in beg and end.  The search starts from the given
     * starting position, scans forward (SEARCH_FORWARD) or backward
@@ -536,23 +538,23 @@ public:
       FXint* beg;
       FXint* end;
       VALUE ary=Qnil;
-			FXint ngroups=string.contains('(')+1;  // FIXME: is this right?
+      FXint ngroups = flags&SEARCH_REGEX ? string.contains('(')+1 : 1;  // FIXME: is this right?
       if(!FXMALLOC(&beg,FXint,ngroups)){
         return Qnil;
-				}
+      }
       if(!FXMALLOC(&end,FXint,ngroups)){
         FXFREE(&beg);
-				return Qnil;
-				}
+        return Qnil;
+      }
       if(self->findText(string,beg,end,start,flags,ngroups)){
         ary=rb_ary_new();
-				rb_ary_push(ary,FXRbMakeArray(beg,ngroups));
-				rb_ary_push(ary,FXRbMakeArray(end,ngroups));
-        }
+        rb_ary_push(ary,FXRbMakeArray(beg,ngroups));
+        rb_ary_push(ary,FXRbMakeArray(end,ngroups));
+      }
       FXFREE(&beg);
       FXFREE(&end);
       return ary;
-      }
+    }
   }
 
   /// Return TRUE if position pos is selected
diff --git a/swig-interfaces/FXVec2d.i b/swig-interfaces/FXVec2d.i
index afde5b56..01f5ffec 100644
--- a/swig-interfaces/FXVec2d.i
+++ b/swig-interfaces/FXVec2d.i
@@ -20,6 +20,7 @@
  * at "lyle@lylejohnson.name".
  ***********************************************************************/
 
+%naturalvar FXVec2d;
 /// Double-precision 2-element vector
 class FXVec2d {
 public:
diff --git a/swig-interfaces/FXVec2f.i b/swig-interfaces/FXVec2f.i
index c52c3f01..1a1d9bd8 100644
--- a/swig-interfaces/FXVec2f.i
+++ b/swig-interfaces/FXVec2f.i
@@ -20,6 +20,7 @@
  * at "lyle@lylejohnson.name".
  ***********************************************************************/
 
+%naturalvar FXVec2f;
 /// Single-precision 2-element vector
 class FXVec2f {
 public:
diff --git a/swig-interfaces/FXVec3d.i b/swig-interfaces/FXVec3d.i
index 094e13e8..282eee73 100644
--- a/swig-interfaces/FXVec3d.i
+++ b/swig-interfaces/FXVec3d.i
@@ -20,6 +20,7 @@
  * at "lyle@lylejohnson.name".
  ***********************************************************************/
 
+%naturalvar FXVec3d;
 /// Double-precision 3-element vector
 class FXVec3d {
 public:
diff --git a/swig-interfaces/FXVec3f.i b/swig-interfaces/FXVec3f.i
index 2da73ad5..587fcf77 100644
--- a/swig-interfaces/FXVec3f.i
+++ b/swig-interfaces/FXVec3f.i
@@ -20,6 +20,7 @@
  * at "lyle@lylejohnson.name".
  ***********************************************************************/
 
+%naturalvar FXVec3f;
 /// Single-precision 3-element vector
 class FXVec3f {
 public:
diff --git a/swig-interfaces/FXVec4d.i b/swig-interfaces/FXVec4d.i
index ea9b2d5d..54e72562 100644
--- a/swig-interfaces/FXVec4d.i
+++ b/swig-interfaces/FXVec4d.i
@@ -21,6 +21,7 @@
  ***********************************************************************/
 
 %rename("crosses?") FXVec4d::crosses(const FXVec3d& a,const FXVec3d& b) const;
+%naturalvar FXVec4d;
 
 /// Double-precision 4-element vector
 class FXVec4d {
diff --git a/swig-interfaces/FXVec4f.i b/swig-interfaces/FXVec4f.i
index 988a0fe0..1c4e69e8 100644
--- a/swig-interfaces/FXVec4f.i
+++ b/swig-interfaces/FXVec4f.i
@@ -21,6 +21,7 @@
  ***********************************************************************/
 
 %rename("crosses?") FXVec4f::crosses(const FXVec3f& a,const FXVec3f& b) const;
+%naturalvar FXVec4f;
 
 /// Single-precision 4-element vector
 class FXVec4f {
diff --git a/swig-interfaces/macros.i b/swig-interfaces/macros.i
index 8ed1e82d..5518a41c 100644
--- a/swig-interfaces/macros.i
+++ b/swig-interfaces/macros.i
@@ -31,6 +31,62 @@
   /// Detach application's windows
   virtual void detach();
 
+  /**
+  * Run the main application event loop until stop() is called,
+  * and return the exit code passed as argument to stop().
+  */
+  FXint run();
+
+  /// Perform one event dispatch; return true if event was dispatched
+  bool runOneEvent(bool blocking=true);
+
+  /**
+  * Run an event loop till some flag becomes non-zero, and
+  * then return.
+  */
+  FXint runUntil(FXuint& condition); // FIXME
+
+  /**
+  * Run event loop while events are available, non-modally.
+  * Return when no more events, timers, or chores are outstanding.
+  */
+  FXint runWhileEvents();
+
+  /**
+  * Run event loop while there are events are available in the queue.
+  * Returns 1 when all events in the queue have been handled, and 0 when
+  * the event loop was terminated due to stop() or stopModal().
+  * Except for the modal window and its children, user input to all windows
+  * is blocked; if the modal window is NULL, all user input is blocked.
+  */
+  FXint runModalWhileEvents(FXWindow* window=NULL);
+
+  /**
+  * Run modal event loop, blocking keyboard and mouse events to all windows
+  * until stopModal is called.
+  */
+  FXint runModal();
+
+  /**
+  * Run a modal event loop for the given window, until stop() or stopModal() is
+  * called. Except for the modal window and its children, user input to all
+  * windows is blocked; if the modal window is NULL all user input is blocked.
+  */
+  FXint runModalFor(FXWindow* window);
+
+  /**
+  * Run modal while window is shown, or until stop() or stopModal() is called.
+  * Except for the modal window and its children, user input to all windows
+  * is blocked; if the modal window is NULL all user input is blocked.
+  */
+  FXint runModalWhileShown(FXWindow* window);
+
+  /**
+  * Run popup menu while shown, until stop() or stopModal() is called.
+  * Also returns when entering previous cascading popup menu.
+  */
+  FXint runPopup(FXWindow* owner);
+
   /**
    * Initialize application.
    * Parses and removes common command line arguments, reads the registry.
@@ -1109,6 +1165,15 @@
 
 %define DECLARE_FXTEXT_VIRTUALS(klass)
 %extend klass {
+  virtual void eraseCursorOverhang();
+  virtual void drawCursor(FXuint state);
+  virtual FXuint style(FXint row,FXint beg,FXint end,FXint pos);
+  virtual void drawBufferText(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h,FXint pos,FXint n,FXuint style);
+  virtual void fillBufferRect(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h,FXuint style);
+  virtual void drawTextRow(FXDCWindow& dc,FXint line,FXint left,FXint right);
+  virtual void drawContents(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
+  virtual void drawNumbers(FXDCWindow& dc,FXint x,FXint y,FXint w,FXint h);
+
   virtual void setCursorPos(FXint pos,FXbool notify=FALSE);
   virtual FXbool extendSelection(FXint pos,FXTextSelectionMode mode=SELECT_CHARS,FXbool notify=FALSE);
   virtual FXbool killSelection(FXbool notify=FALSE);
diff --git a/swig-interfaces/ruby-typemaps.i b/swig-interfaces/ruby-typemaps.i
index 25c1e936..4d95f4fa 100644
--- a/swig-interfaces/ruby-typemaps.i
+++ b/swig-interfaces/ruby-typemaps.i
@@ -493,13 +493,27 @@ inline void* to_FXEvent(VALUE obj){
 %typemap(out) FXVec2f* "$result = FXRbGetRubyObj($1, \"$1_ltype\");";
 %typemap(out) FXVec2f& "$result = FXRbGetRubyObj($1, \"$1_ltype\");";
 
+/* Output typemap for FXVec3f instances */
+%typemap(out) FXVec3f {
+    FXVec3f* resultptr = new FXVec3f($1);
+    $result = FXRbGetRubyObj(resultptr, "FXVec3f *");
+}
+%typemap(out) FXVec3f*       "$result = FXRbGetRubyObj($1, \"$1_ltype\");";
+%typemap(out) const FXVec3f& {
+    FXVec3f* resultptr = new FXVec3f(*$1);
+    $result = FXRbGetRubyObj(resultptr, "FXVec3f *");
+}
+
 /* Output typemap for FXVec4f instances */
 %typemap(out) FXVec4f {
     FXVec4f* resultptr = new FXVec4f($1);
     $result = FXRbGetRubyObj(resultptr, "FXVec4f *");
 }
 %typemap(out) FXVec4f* "$result = FXRbGetRubyObj($1, \"$1_ltype\");";
-%typemap(out) FXVec4f& "$result = FXRbGetRubyObj($1, \"$1_ltype\");";
+%typemap(out) const FXVec4f& {
+    FXVec4f* resultptr = new FXVec4f(*$1);
+    $result = FXRbGetRubyObj(resultptr, "FXVec4f *");
+}
 
 /* Output typemap for FXIcon instances */
 %typemap(out) FXIcon * = FXObject *;
@@ -610,14 +624,6 @@ inline void* to_FXEvent(VALUE obj){
 /* Output typemap for FXTreeItem instances */
 %typemap(out) FXTreeItem * = FXObject *;
 
-/* Output typemap for FXVec3f instances */
-%typemap(out) FXVec3f {
-    FXVec3f* resultptr = new FXVec3f($1);
-    $result = FXRbGetRubyObj(resultptr, "FXVec3f *");
-}
-%typemap(out) FXVec3f*       "$result = FXRbGetRubyObj($1, \"$1_ltype\");";
-%typemap(out) const FXVec3f& "$result = FXRbGetRubyObj($1, \"$1_ltype\");";
-
 /* Output typemap for FXVerticalFrame instances */
 %typemap(out) FXVerticalFrame * = FXObject *;
 
@@ -709,7 +715,7 @@ inline void* to_FXEvent(VALUE obj){
     $2 = RSTRING_LEN($input);
 }
 
-// Extract a C array (dashpattern) and its length (dashlength) from a Ruby array of Fixnums
+// Extract a C array (dashpattern) and its length (dashlength) from a Ruby array of Integers
 %typemap(in) (const FXchar* dashpattern, FXuint dashlength) {
     Check_Type($input, T_ARRAY);
     $1 = new FXchar[RARRAY_LEN($input)];
@@ -757,7 +763,7 @@ inline void* to_FXEvent(VALUE obj){
  */
 
 %typemap(in) FXWindow* TOOLBAR_DOCK_AFTER {
-    if (TYPE($input) == T_FIXNUM) {
+    if (TYPE($input) == T_FIXNUM || TYPE($input) == T_BIGNUM)) {
         $1 = reinterpret_cast<FXWindow *>(static_cast<long>(NUM2INT($input)));
     } else {
         SWIG_ConvertPtr($input, (void **) &$1, SWIGTYPE_p_FXWindow, 1);
diff --git a/test/TC_FXApp.rb b/test/TC_FXApp.rb
index 75010176..385074f8 100755
--- a/test/TC_FXApp.rb
+++ b/test/TC_FXApp.rb
@@ -7,11 +7,8 @@ class TC_FXApp < Test::Unit::TestCase
   include Fox
 
   def test_exception_for_second_app
-    app = FXApp.new
-    mainWindow = FXMainWindow.new(app, "")
-    app.create
     assert_raise RuntimeError do
-      app2 = FXApp.new
+      FXApp.new
     end
   end
 end
@@ -33,21 +30,40 @@ class TC_FXApp2 < Fox::TestCase
     app.removeInput(pipe_wr, INPUT_WRITE)
 
     app.addInput(pipe_rd, INPUT_READ, app, FXApp::ID_QUIT)
-    data_sent = false
-    app.addTimeout(1) do
-      data_sent = true
-      pipe_wr.write " "
+    2.times do
+      data_sent = false
+      app.addTimeout(1) do
+        data_sent = true
+        pipe_wr.write " "
+      end
+      app.run
+      assert data_sent, "the read input event shouldn't fire before some data is available"
+      assert " ", pipe_rd.read(1)
     end
-    app.run
-    assert data_sent, "the read input event shouldn't fire before some data is available"
-
     app.removeInput(pipe_rd, INPUT_READ)
     pipe_wr.close
     pipe_rd.close unless pipe_rd.closed?
   end
 
   def test_addInput_on_pipe
-    check_events *IO.pipe
+    pend "addInput on IO.pipe object isn't supported on Windows" if RUBY_PLATFORM=~/mingw|mswin/i
+    check_events(*IO.pipe)
+  end
+
+  def test_addInput_on_socket_accept
+    s = TCPServer.open 'localhost', 0
+    app.addInput(s, INPUT_READ, app, FXApp::ID_QUIT)
+    2.times do
+      pipe_wr = nil
+      app.addTimeout(1) do
+        pipe_wr = TCPSocket.open 'localhost', s.addr[1]
+      end
+      app.run
+      assert pipe_wr, "the read input event shouldn't fire before client connection happens"
+      s.accept.close
+    end
+    app.removeInput(s, INPUT_READ)
+    s.close
   end
 
   def test_addInput_on_socket
@@ -60,7 +76,43 @@ class TC_FXApp2 < Fox::TestCase
   end
 
   def test_addInput_on_popen
+    pend "addInput on IO.popen object isn't supported on Windows" if RUBY_PLATFORM=~/mingw|mswin/i
     pipe_rdwr = IO.popen("cat", "r+")
     check_events pipe_rdwr, pipe_rdwr
   end
+
+  def test_runOnUiThread
+    count = 0
+    thread = nil
+    Thread.new do
+      10.times do |idx|
+        app.runOnUiThread do
+          count += 1
+          thread = Thread.current
+          app.stop if idx == 9
+        end
+        sleep 0.001
+      end
+    end
+    app.run
+
+    assert_equal Thread.current, thread
+    assert_equal 10, count
+  end
+
+  def test_runOnUiThread_same_thread
+    count = 0
+    app.addTimeout(1) do
+      10.times do |idx|
+        app.runOnUiThread do
+          count += 1
+          app.stop if idx == 9
+        end
+        sleep 0.001
+      end
+    end
+    app.run
+
+    assert_equal 10, count
+  end
 end
diff --git a/test/TC_FXButton.rb b/test/TC_FXButton.rb
index 425076c6..5b08a135 100755
--- a/test/TC_FXButton.rb
+++ b/test/TC_FXButton.rb
@@ -26,7 +26,7 @@ class TC_FXButton < Fox::TestCase
 
   def testStyle
     assert(@button.buttonStyle)
-    assert_instance_of(Fixnum, @button.buttonStyle)
+    assert_kind_of(Integer, @button.buttonStyle)
 
     @button.buttonStyle |= BUTTON_AUTOGRAY
     assert((@button.buttonStyle & BUTTON_AUTOGRAY) != 0)
@@ -56,7 +56,7 @@ class TC_FXButton < Fox::TestCase
 
   def testState
     assert(@button.state)
-    assert_kind_of(Fixnum, @button.state)
+    assert_kind_of(Integer, @button.state)
 
     @button.state = STATE_UP
     assert_equal(STATE_UP, @button.state)
diff --git a/test/TC_FXCheckButton.rb b/test/TC_FXCheckButton.rb
index 98401ae8..04ab040f 100755
--- a/test/TC_FXCheckButton.rb
+++ b/test/TC_FXCheckButton.rb
@@ -12,7 +12,6 @@ class TC_FXCheckButton < Fox::TestCase
 
   def test_setCheck_TRUE
     @checkButton.check = Fox::TRUE
-    assert_equal(true, @checkButton.check)
     assert_equal(Fox::TRUE, @checkButton.checkState)
     assert(@checkButton.checked?)
     assert(!@checkButton.unchecked?)
@@ -21,7 +20,6 @@ class TC_FXCheckButton < Fox::TestCase
 
   def test_setCheck_FALSE
     @checkButton.check = Fox::FALSE
-    assert_equal(false, @checkButton.check)
     assert_equal(Fox::FALSE, @checkButton.checkState)
     assert(!@checkButton.checked?)
     assert(@checkButton.unchecked?)
@@ -30,7 +28,6 @@ class TC_FXCheckButton < Fox::TestCase
 
   def test_setCheck_MAYBE
     @checkButton.check = Fox::MAYBE
-    assert_equal(true, @checkButton.check) # this is not a typo!
     assert_equal(Fox::MAYBE, @checkButton.checkState)
     assert(!@checkButton.checked?)
     assert(!@checkButton.unchecked?)
@@ -39,7 +36,6 @@ class TC_FXCheckButton < Fox::TestCase
 
   def test_setCheck_true
     @checkButton.check = true
-    assert_equal(true, @checkButton.check)
     assert_equal(Fox::TRUE, @checkButton.checkState)
     assert(@checkButton.checked?)
     assert(!@checkButton.unchecked?)
@@ -48,7 +44,6 @@ class TC_FXCheckButton < Fox::TestCase
 
   def test_setCheck_false
     @checkButton.check = false
-    assert_equal(false, @checkButton.check)
     assert_equal(Fox::FALSE, @checkButton.checkState)
     assert(!@checkButton.checked?)
     assert(@checkButton.unchecked?)
diff --git a/test/TC_FXDCPrint.rb b/test/TC_FXDCPrint.rb
index 46b2b4d4..d24af26a 100755
--- a/test/TC_FXDCPrint.rb
+++ b/test/TC_FXDCPrint.rb
@@ -95,7 +95,7 @@ public
   end
 
   def teardown
-    if File.exists?("output.ps")
+    if File.exist?("output.ps")
       FileUtils.rm_f("output.ps")
     end
   end
diff --git a/test/TC_FXFileStream.rb b/test/TC_FXFileStream.rb
index 0f666b85..76784fce 100755
--- a/test/TC_FXFileStream.rb
+++ b/test/TC_FXFileStream.rb
@@ -62,6 +62,8 @@ class TC_FXFileStream < Test::Unit::TestCase
       FXFileStream.open("non_existing_file", FXStreamLoad) { |s| }
     }
 
+    pend "chmod isn't supported on Windows" if RUBY_PLATFORM=~/mingw|mswin/i
+
     # Write-only file (i.e. no read permissions)
     tf = Tempfile.new("write_only_file")
     tf.puts("junk")
@@ -82,7 +84,7 @@ class TC_FXFileStream < Test::Unit::TestCase
   end
 
   def teardown
-    if File.exists?("goobers")
+    if File.exist?("goobers")
       FileUtils.rm_f("goobers")
     end
   end
diff --git a/test/TC_FXFont.rb b/test/TC_FXFont.rb
index 72173a25..1fbe5b94 100755
--- a/test/TC_FXFont.rb
+++ b/test/TC_FXFont.rb
@@ -15,7 +15,7 @@ class TC_FXFont < Test::Unit::TestCase
 
   def testConstructFromFontDescription
     fontdesc = @app.normalFont.fontDesc
-    font = FXFont.new(@app, fontdesc)
+    FXFont.new(@app, fontdesc)
   end
 
   def testConstructFromParameters
@@ -42,7 +42,7 @@ class TC_FXFont < Test::Unit::TestCase
   end
 
   def testConstructFromFontString
-    font = FXFont.new(@app, "")
+    FXFont.new(@app, "")
   end
 
   def testGetTextWidthAndHeight
diff --git a/test/TC_FXGLViewer.rb b/test/TC_FXGLViewer.rb
index dede2a49..661e154f 100755
--- a/test/TC_FXGLViewer.rb
+++ b/test/TC_FXGLViewer.rb
@@ -12,7 +12,14 @@ class TC_FXGLViewer < Fox::TestCase
   end
 
   def test_supported
-    assert FXGLVisual.supported?(app)
+    arr = FXGLVisual.supported(app)
+    assert_equal 3, arr.length, "return array should have elements [support, major, minor]"
+    assert_true arr[0], "OpenGL should be supported"
+    assert_operator 1, :<=, arr[1], "OpenGL should be version 1.0 or greater"
+  end
+
+  def test_supported?
+    assert_true FXGLVisual.supported?(app), "OpenGL should be supported"
   end
 
   def test_nil_app_raises_argument_error
diff --git a/test/TC_FXHeader.rb b/test/TC_FXHeader.rb
index 0f39e473..eaaea3a4 100755
--- a/test/TC_FXHeader.rb
+++ b/test/TC_FXHeader.rb
@@ -22,7 +22,7 @@ class TC_FXHeader < Fox::TestCase
 
   def test_getArrowDir
     @header.appendItem("")
-    assert_instance_of(Fixnum, @header.getArrowDir(0))
+    assert_kind_of(Integer, @header.getArrowDir(0))
   end
 
   def test_arrowUp?
diff --git a/test/TC_FXId.rb b/test/TC_FXId.rb
index ed334657..7e677e64 100755
--- a/test/TC_FXId.rb
+++ b/test/TC_FXId.rb
@@ -11,7 +11,7 @@ class TC_FXId < Fox::TestCase
 
   def test_created?
     assert !mainWindow.created?
-    app.create
+    mainWindow.create
     assert mainWindow.created?, "main window should be created after call to FXApp#create"
     mainWindow.destroy
     assert !mainWindow.created?
diff --git a/test/TC_FXImage.rb b/test/TC_FXImage.rb
index e683c467..b73c44bc 100755
--- a/test/TC_FXImage.rb
+++ b/test/TC_FXImage.rb
@@ -1,6 +1,7 @@
 require 'test/unit'
 require 'testcase'
 require 'fox16'
+require 'fiddle'
 
 class TC_FXImage < Fox::TestCase
   include Fox
@@ -80,6 +81,13 @@ class TC_FXImage < Fox::TestCase
     assert_equal("rgbaRGBA", img.pixel_string)
   end
 
+  def test_dataPtr
+    img = FXImage.new(app, nil, 0, 2, 1)
+    img.pixels = "rgbaRGBA"
+    assert_equal(0, img.options)
+    assert_equal("rgbaRGBA", Fiddle::Pointer.new(img.dataPtr)[0, 8])
+  end
+
   def test_create
     #
     # If the image owns its pixel data and IMAGE_KEEP was not specified,
@@ -119,7 +127,7 @@ class TC_FXImage < Fox::TestCase
   def test_create_with_non_owned_data
     GC.stress = true
     img = image_with_non_owned_data
-    " " * 10000
+    _ = " " * 10000
     GC.stress = false
     assert_equal("rgbaRGBA", img.pixel_string)
     assert_equal(0, img.options)
@@ -134,7 +142,7 @@ class TC_FXImage < Fox::TestCase
     img = FXImage.new(app, nil, 0, 1, 2)
     GC.stress = true
     set_non_owned_data(img)
-    " " * 10000
+    _ = " " * 10000
     GC.stress = false
     assert_equal("rgbaRGBA", img.pixel_string)
     assert_equal(0, img.options)
diff --git a/test/TC_FXJPGImage.rb b/test/TC_FXJPGImage.rb
new file mode 100644
index 00000000..2da3abeb
--- /dev/null
+++ b/test/TC_FXJPGImage.rb
@@ -0,0 +1,47 @@
+require 'fox16'
+require 'test/unit'
+require 'testcase'
+require 'openssl'
+
+class TC_FXJPGImage < Fox::TestCase
+  include Fox
+
+  def setup
+    super(self.class.name)
+  end
+
+  def test_save_with_thread
+    w, h = 4000, 3000
+    img_data = OpenSSL::Random.random_bytes(w) * h * 4
+
+    count = 0
+    th = Thread.new do
+      loop do
+        count += 1
+      end
+    end
+
+    img = FXJPGImage.new(app)
+    img.setPixels( img_data, 0, w, h )
+
+    jpeg_data = FXMemoryStream.open(FXStreamSave, nil) do |outfile|
+      img.savePixels(outfile)
+      outfile.takeBuffer
+    end
+
+    assert_operator(count, :>=, 500000)
+    assert_operator(jpeg_data.bytesize, :>=, 1000)
+
+    count = 0
+    img = FXJPGImage.new(app)
+    FXMemoryStream.open(FXStreamLoad, jpeg_data) do |infile|
+      img.loadPixels(infile)
+    end
+
+    th.kill
+
+    assert_equal 4000, img.width
+    assert_equal 3000, img.height
+    assert_operator(count, :>=, 500000)
+  end
+end
diff --git a/test/TC_FXList.rb b/test/TC_FXList.rb
index 3a507abe..affdb139 100755
--- a/test/TC_FXList.rb
+++ b/test/TC_FXList.rb
@@ -46,17 +46,17 @@ class TC_FXList < Fox::TestCase
 
   def test_appendItem_byText
     assert_equal(0, @list.numItems)
-    itemIndex = @list.appendItem("")
+    assert_equal 0, @list.appendItem("")
     assert_equal(1, @list.numItems)
-    itemIndex = @list.appendItem("anItem")
+    assert_equal 1, @list.appendItem("anItem")
     assert_equal(2, @list.numItems)
-    itemIndex = @list.appendItem("anItem", nil)
+    assert_equal 2, @list.appendItem("anItem", nil)
     assert_equal(3, @list.numItems)
-    itemIndex = @list.appendItem("anItem", nil, "someData")
+    assert_equal 3, @list.appendItem("anItem", nil, "someData")
     assert_equal(4, @list.numItems)
-    itemIndex = @list.appendItem("anItem", nil, "someData", true)
+    assert_equal 4, @list.appendItem("anItem", nil, "someData", true)
     assert_equal(5, @list.numItems)
-    itemIndex = @list.appendItem("anItem", nil, "someData", false)
+    assert_equal 5, @list.appendItem("anItem", nil, "someData", false)
     assert_equal(6, @list.numItems)
     assert_raises(ArgumentError) do
       @list.appendItem("anItem", nil, "someData", 42) # last argument must be true or false
@@ -103,9 +103,9 @@ class TC_FXList < Fox::TestCase
   end
 
   def test_makeItemVisible
-    items = []
     0.upto(2) { |i|
-      items << @list.appendItem("item#{i}")
+      itemIndex = @list.appendItem("item#{i}")
+      assert_equal i, itemIndex
     }
     assert_raises(IndexError) {
       @list.makeItemVisible(-1)
diff --git a/test/TC_FXMainWindow.rb b/test/TC_FXMainWindow.rb
index 01fb158c..d8267fb9 100644
--- a/test/TC_FXMainWindow.rb
+++ b/test/TC_FXMainWindow.rb
@@ -11,6 +11,7 @@ class TC_FXMainWindow < Test::Unit::TestCase
   end
 
   def test_non_created_app_raises_runtime_error
+    pend "two FXApp are not allowed"
     app = FXApp.new
     assert_raise RuntimeError do
       FXMainWindow.new(app, "title").create
diff --git a/test/TC_FXMat4f.rb b/test/TC_FXMat4f.rb
index a6c0fd94..978918ff 100755
--- a/test/TC_FXMat4f.rb
+++ b/test/TC_FXMat4f.rb
@@ -81,9 +81,9 @@ class TC_FXMat4f < Test::Unit::TestCase
   def test_mul_by_scalar
     p = FXMat4f.new.eye
     q = FXMat4f.new(4.0, 0.0, 0.0, 0.0,
-                   0.0, 4.0, 0.0, 0.0,
-		   0.0, 0.0, 4.0, 0.0,
-		   0.0, 0.0, 0.0, 4.0)
+                    0.0, 4.0, 0.0, 0.0,
+                    0.0, 0.0, 4.0, 0.0,
+                    0.0, 0.0, 0.0, 4.0)
     r = p*4.0
     assert_instance_of(FXMat4f, r)
 #   assert_equal(q, r)
diff --git a/test/TC_FXMaterial.rb b/test/TC_FXMaterial.rb
index bd006e51..2ac01b24 100755
--- a/test/TC_FXMaterial.rb
+++ b/test/TC_FXMaterial.rb
@@ -48,7 +48,7 @@ class TC_FXMaterial < Test::Unit::TestCase
     assert_in_delta(0.7, @mat.emission[2], DELTA)
     assert_in_delta(0.8, @mat.emission[3], DELTA)
 
-    @mat.emission = FXHVec.new(0.5, 0.6, 0.7, 0.8)
+    @mat.emission = FXVec4f.new(0.5, 0.6, 0.7, 0.8)
     assert_in_delta(0.5, @mat.emission[0], DELTA)
     assert_in_delta(0.6, @mat.emission[1], DELTA)
     assert_in_delta(0.7, @mat.emission[2], DELTA)
diff --git a/test/TC_FXMenuCheck.rb b/test/TC_FXMenuCheck.rb
index 5565268d..749d313a 100755
--- a/test/TC_FXMenuCheck.rb
+++ b/test/TC_FXMenuCheck.rb
@@ -12,7 +12,6 @@ class TC_FXMenuCheck < Fox::TestCase
 
   def test_setCheck_TRUE
     @menuCheck.check = Fox::TRUE
-    assert_equal(true, @menuCheck.check)
     assert_equal(Fox::TRUE, @menuCheck.checkState)
     assert(@menuCheck.checked?)
     assert(!@menuCheck.unchecked?)
@@ -21,7 +20,6 @@ class TC_FXMenuCheck < Fox::TestCase
 
   def test_setCheck_FALSE
     @menuCheck.check = Fox::FALSE
-    assert_equal(false, @menuCheck.check)
     assert_equal(Fox::FALSE, @menuCheck.checkState)
     assert(!@menuCheck.checked?)
     assert(@menuCheck.unchecked?)
@@ -30,7 +28,6 @@ class TC_FXMenuCheck < Fox::TestCase
 
   def test_setCheck_MAYBE
     @menuCheck.check = Fox::MAYBE
-    assert_equal(true, @menuCheck.check) # this is not a typo!
     assert_equal(Fox::MAYBE, @menuCheck.checkState)
     assert(!@menuCheck.checked?)
     assert(!@menuCheck.unchecked?)
@@ -39,7 +36,6 @@ class TC_FXMenuCheck < Fox::TestCase
 
   def test_setCheck_true
     @menuCheck.check = true
-    assert_equal(true, @menuCheck.check)
     assert_equal(Fox::TRUE, @menuCheck.checkState)
     assert(@menuCheck.checked?)
     assert(!@menuCheck.unchecked?)
@@ -48,7 +44,6 @@ class TC_FXMenuCheck < Fox::TestCase
 
   def test_setCheck_false
     @menuCheck.check = false
-    assert_equal(false, @menuCheck.check)
     assert_equal(Fox::FALSE, @menuCheck.checkState)
     assert(!@menuCheck.checked?)
     assert(@menuCheck.unchecked?)
diff --git a/test/TC_FXMenuRadio.rb b/test/TC_FXMenuRadio.rb
index 8dc67cd5..460d3c85 100755
--- a/test/TC_FXMenuRadio.rb
+++ b/test/TC_FXMenuRadio.rb
@@ -12,7 +12,6 @@ class TC_FXMenuRadio < Fox::TestCase
 
   def test_setCheck_TRUE
     @menuRadio.check = Fox::TRUE
-    assert_equal(true, @menuRadio.check)
     assert_equal(Fox::TRUE, @menuRadio.checkState)
     assert(@menuRadio.checked?)
     assert(!@menuRadio.unchecked?)
@@ -21,7 +20,6 @@ class TC_FXMenuRadio < Fox::TestCase
 
   def test_setCheck_FALSE
     @menuRadio.check = Fox::FALSE
-    assert_equal(false, @menuRadio.check)
     assert_equal(Fox::FALSE, @menuRadio.checkState)
     assert(!@menuRadio.checked?)
     assert(@menuRadio.unchecked?)
@@ -30,7 +28,6 @@ class TC_FXMenuRadio < Fox::TestCase
 
   def test_setCheck_MAYBE
     @menuRadio.check = Fox::MAYBE
-    assert_equal(true, @menuRadio.check) # this is not a typo!
     assert_equal(Fox::MAYBE, @menuRadio.checkState)
     assert(!@menuRadio.checked?)
     assert(!@menuRadio.unchecked?)
@@ -39,7 +36,6 @@ class TC_FXMenuRadio < Fox::TestCase
 
   def test_setCheck_true
     @menuRadio.check = true
-    assert_equal(true, @menuRadio.check)
     assert_equal(Fox::TRUE, @menuRadio.checkState)
     assert(@menuRadio.checked?)
     assert(!@menuRadio.unchecked?)
@@ -48,7 +44,6 @@ class TC_FXMenuRadio < Fox::TestCase
 
   def test_setCheck_false
     @menuRadio.check = false
-    assert_equal(false, @menuRadio.check)
     assert_equal(Fox::FALSE, @menuRadio.checkState)
     assert(!@menuRadio.checked?)
     assert(@menuRadio.unchecked?)
diff --git a/test/TC_FXQuatf.rb b/test/TC_FXQuatf.rb
index 6fedb3b9..9aeb75c6 100755
--- a/test/TC_FXQuatf.rb
+++ b/test/TC_FXQuatf.rb
@@ -9,23 +9,23 @@ class TC_FXQuatf < Test::Unit::TestCase
   end
 
   def test_default_constructor
-    q = FXQuatf.new
+    FXQuatf.new
   end
 
   def test_construct_from_axis_and_angle
     axis = FXVec3f.new(1.0, 1.0, 1.0)
-    q = FXQuatf.new(axis)
-    q = FXQuatf.new(axis, 0.0)
+    FXQuatf.new(axis)
+    FXQuatf.new(axis, 0.0)
   end
 
   def test_construct_from_components
     x, y, z, w = 1.0, 1.0, 1.0, 1.0
-    q = FXQuatf.new(x, y, z, w)
+    FXQuatf.new(x, y, z, w)
   end
 
   def test_construct_from_roll_pitch_yaw
     roll, pitch, yaw = 45.0, 45.0, 45.0
-    q = FXQuatf.new(roll, pitch, yaw)
+    FXQuatf.new(roll, pitch, yaw)
   end
 
   def test_adjust!
diff --git a/test/TC_FXRadioButton.rb b/test/TC_FXRadioButton.rb
index 0cf2e0b6..a5572135 100755
--- a/test/TC_FXRadioButton.rb
+++ b/test/TC_FXRadioButton.rb
@@ -12,7 +12,6 @@ class TC_FXRadioButton < Fox::TestCase
 
   def test_setCheck_TRUE
     @radioButton.check = Fox::TRUE
-    assert_equal(true, @radioButton.check)
     assert_equal(Fox::TRUE, @radioButton.checkState)
     assert(@radioButton.checked?)
     assert(!@radioButton.unchecked?)
@@ -21,7 +20,6 @@ class TC_FXRadioButton < Fox::TestCase
 
   def test_setCheck_FALSE
     @radioButton.check = Fox::FALSE
-    assert_equal(false, @radioButton.check)
     assert_equal(Fox::FALSE, @radioButton.checkState)
     assert(!@radioButton.checked?)
     assert(@radioButton.unchecked?)
@@ -30,7 +28,6 @@ class TC_FXRadioButton < Fox::TestCase
 
   def test_setCheck_MAYBE
     @radioButton.check = Fox::MAYBE
-    assert_equal(true, @radioButton.check) # this is not a typo!
     assert_equal(Fox::MAYBE, @radioButton.checkState)
     assert(!@radioButton.checked?)
     assert(!@radioButton.unchecked?)
@@ -39,7 +36,6 @@ class TC_FXRadioButton < Fox::TestCase
 
   def test_setCheck_true
     @radioButton.check = true
-    assert_equal(true, @radioButton.check)
     assert_equal(Fox::TRUE, @radioButton.checkState)
     assert(@radioButton.checked?)
     assert(!@radioButton.unchecked?)
@@ -48,7 +44,6 @@ class TC_FXRadioButton < Fox::TestCase
 
   def test_setCheck_false
     @radioButton.check = false
-    assert_equal(false, @radioButton.check)
     assert_equal(Fox::FALSE, @radioButton.checkState)
     assert(!@radioButton.checked?)
     assert(@radioButton.unchecked?)
diff --git a/test/TC_FXRegion.rb b/test/TC_FXRegion.rb
index 13dee759..2d05ef5b 100755
--- a/test/TC_FXRegion.rb
+++ b/test/TC_FXRegion.rb
@@ -17,9 +17,9 @@ class TC_FXRegion < Test::Unit::TestCase
                FXPoint.new(100, 100),
                FXPoint.new(0, 0)
              ]
-    r1 = FXRegion.new(points, true)
-    r2 = FXRegion.new(points, false)
-    r3 = FXRegion.new(points)
+    FXRegion.new(points, true)
+    FXRegion.new(points, false)
+    FXRegion.new(points)
   end
 
   def test_copy_constructor
diff --git a/test/TC_FXShell.rb b/test/TC_FXShell.rb
index 89391aa9..1cf6cf4a 100755
--- a/test/TC_FXShell.rb
+++ b/test/TC_FXShell.rb
@@ -22,6 +22,7 @@ class TC_FXShell < Test::Unit::TestCase
   def test_new
     # Free-floating
     shell1 = FXShell.new(@app, 0, 0, 0, 0, 0)
+    assert_nil(shell1.owner)
 
     # Owned
     shell2 = FXShell.new(@mainWin, 0, 0, 0, 0, 0)
diff --git a/test/TC_FXTable.rb b/test/TC_FXTable.rb
index b9d66cc3..8f3a055a 100755
--- a/test/TC_FXTable.rb
+++ b/test/TC_FXTable.rb
@@ -76,7 +76,7 @@ private
     clearEdges(extending)
 
     old_nr = @table.numRows
-    old_nc = @table.numColumns
+    _old_nc = @table.numColumns
 
     # resize the table
     nr = @data_lines.size + 2
diff --git a/test/TC_FXText.rb b/test/TC_FXText.rb
index 93638b7a..a3260a15 100755
--- a/test/TC_FXText.rb
+++ b/test/TC_FXText.rb
@@ -87,6 +87,13 @@ public
     assert_equal([10], endIndex)
   end
 
+  def test_find_text_with_startpos_wrap_nocase
+    @text.text = "I came, i saw, I conquered"
+    startIndex, endIndex = @text.findText("i ", 16, SEARCH_FORWARD|SEARCH_IGNORECASE|SEARCH_WRAP)
+    assert_equal([0], startIndex)
+    assert_equal([2], endIndex)
+  end
+
   def test_find_text_with_groups
     @text.text = "I came, I saw, I conquered"
     startIndex, endIndex = @text.findText("I ([a-z]+)(, )?", 0, SEARCH_REGEX)
@@ -94,6 +101,18 @@ public
     assert_equal([8, 6, 8], endIndex)
   end
 
+  def test_find_text_with_loop
+    @text.text = "()  ()()"
+    e = Enumerator.new do |y|
+      pos = 0
+      while a=@text.findText("()", pos, SEARCH_FORWARD|SEARCH_EXACT)
+        y << a
+        pos = a[1][0]
+      end
+    end
+    assert_equal [[[0], [2]], [[4], [6]], [[6], [8]]], e.to_a
+  end
+
   if ''.respond_to?(:encoding)
     def test_encoding
       @text.text = "世界線航跡蔵"
diff --git a/test/TC_FXTreeList.rb b/test/TC_FXTreeList.rb
index d72ca295..58a77648 100755
--- a/test/TC_FXTreeList.rb
+++ b/test/TC_FXTreeList.rb
@@ -67,12 +67,12 @@ class TC_FXTreeList < Fox::TestCase
     @treeList.connect(SEL_INSERTED) { |sender, sel, ptr|
       anItem = ptr
     }
-    theItem = @treeList.appendItem(nil, "", nil, nil, nil, true)
+    theItem = @treeList.appendItem(nil, FXTreeItem.new(""), true)
     assert_same(theItem, anItem)
   end
 
   def test_SEL_DELETED
-    theItem = @treeList.appendItem(nil, "")
+    theItem = @treeList.appendItem(nil, FXTreeItem.new(""))
     anItem = nil
     @treeList.connect(SEL_DELETED) { |sender, sel, ptr|
       anItem = ptr
diff --git a/test/TC_FXVec4f.rb b/test/TC_FXVec4f.rb
index 4fcbc330..3958c52c 100755
--- a/test/TC_FXVec4f.rb
+++ b/test/TC_FXVec4f.rb
@@ -5,6 +5,20 @@ require 'fox16'
 class TC_FXVec4f < Test::Unit::TestCase
   include Fox
 
+  def assert_in_delta(v1, v2, delta)
+    case v1
+      when FXVec3f
+        3.times do |i|
+          super(v1[i], v2[i], delta)
+        end
+      when FXVec4f
+        4.times do |i|
+          super(v1[i], v2[i], delta)
+        end
+      else
+        super(v1, v2, delta)
+    end
+  end
 
   def test_new
     FXVec4f.new
@@ -39,7 +53,7 @@ class TC_FXVec4f < Test::Unit::TestCase
   end
 
   def test_new5
-    c = FXVec4f.new(FXRGB(128, 128, 128))
+    FXVec4f.new(FXRGB(128, 128, 128))
   end
 
   def test_getitem
@@ -65,37 +79,37 @@ class TC_FXVec4f < Test::Unit::TestCase
   def test_neg
     vec = FXVec4f.new(1.0, 2.0, 3.0, 4.0)
     vec = -vec
-    assert_equal(vec[0], -1.0)
-    assert_equal(vec[1], -2.0)
-    assert_equal(vec[2], -3.0)
-    assert_equal(vec[3], -4.0)
+    assert_in_delta(vec[0], -1.0, 0.001)
+    assert_in_delta(vec[1], -2.0, 0.001)
+    assert_in_delta(vec[2], -3.0, 0.001)
+    assert_in_delta(vec[3], -4.0, 0.001)
   end
 
   def test_add
     v1 = FXVec4f.new(1.0, 2.0, 3.0, 4.0)
     v2 = FXVec4f.new(2.0, 4.0, 6.0, 8.0)
     v3 = FXVec4f.new(3.0, 6.0, 9.0, 12.0)
-    assert_equal(v3, v1 + v2)
+    assert_in_delta(v3, v1 + v2, 0.001)
   end
 
   def test_sub
     v1 = FXVec4f.new(3.0, 6.0, 9.0, 12.0)
     v2 = FXVec4f.new(2.0, 4.0, 6.0, 8.0)
     v3 = FXVec4f.new(1.0, 2.0, 3.0, 4.0)
-    assert_equal(v3, v1 - v2)
+    assert_in_delta(v3, v1 - v2, 0.001)
   end
 
   def test_mul
     v1 = FXVec4f.new(3.0,  6.0,  9.0, 12.0)
     v2 = FXVec4f.new(6.0, 12.0, 18.0, 24.0)
-    assert_equal(v2, v1 * 2)
+    assert_in_delta(v2, v1 * 2, 0.001)
   end
 
   def test_mul2 # same as dot product
     v1 = FXVec4f.new(3.0, 6.0, 9.0, 12.0)
     v2 = FXVec4f.new(2.0, 4.0, 6.0, 8.0)
-    assert_equal(180.0, v1*v2)
-    assert_equal(180.0, v2*v1)
+    assert_in_delta(180.0, v1*v2, 0.001)
+    assert_in_delta(180.0, v2*v1, 0.001)
   end
 
   def test_div
@@ -110,8 +124,8 @@ class TC_FXVec4f < Test::Unit::TestCase
   def test_dot
     v1 = FXVec4f.new(3.0, 6.0, 9.0, 12.0)
     v2 = FXVec4f.new(2.0, 4.0, 6.0, 8.0)
-    assert_equal(180.0, v1.dot(v2))
-    assert_equal(180.0, v2.dot(v1))
+    assert_in_delta(180.0, v1.dot(v2), 0.001)
+    assert_in_delta(180.0, v2.dot(v1), 0.001)
   end
 
   def test_length
@@ -121,7 +135,7 @@ class TC_FXVec4f < Test::Unit::TestCase
 
   def test_normalize
     vec = FXVec4f.new(1.0, 1.0, 1.0, 1.0)
-    assert_equal(FXVec4f.new(0.5, 0.5, 0.5, 0.5), vec.normalize)
+    assert_in_delta(FXVec4f.new(0.5, 0.5, 0.5, 0.5), vec.normalize, 0.001)
   end
 
   def test_lo
diff --git a/test/TC_FXWindow.rb b/test/TC_FXWindow.rb
index cb936788..e4bdf567 100644
--- a/test/TC_FXWindow.rb
+++ b/test/TC_FXWindow.rb
@@ -12,7 +12,7 @@ class TC_FXWindow < Fox::TestCase
 
   def test_width_accessor
     pos = @window.width
-    assert_instance_of(Fixnum, pos)
+    assert_kind_of(Integer, pos)
     @window.width = pos + 1
     assert_equal(pos + 1, @window.width)
     @window.width = pos + 2.7
diff --git a/test/TS_All.rb b/test/TS_All.rb
index 92db76e6..0066c24c 100755
--- a/test/TS_All.rb
+++ b/test/TS_All.rb
@@ -2,8 +2,11 @@ require 'fox16'
 require 'test/unit'
 
 if __FILE__ == $0
-  $: << File.dirname(__FILE__)
-  Dir.glob("TC_*.rb").each do |testcase|
-    require "#{testcase}"
+  testdir = File.expand_path("..", __FILE__)
+  $: << testdir
+  Dir.chdir(testdir) do
+    Dir.glob("TC_*.rb").each do |testcase|
+      require "#{testcase}"
+    end
   end
 end
diff --git a/test/dummy.xorg.conf b/test/dummy.xorg.conf
new file mode 100644
index 00000000..fbc5fe39
--- /dev/null
+++ b/test/dummy.xorg.conf
@@ -0,0 +1,140 @@
+# This file is used to setup a dummy X server for testing on http://travis-ci.org
+# See config file ".travis.yml"
+
+##Xdummy:##
+Section "ServerFlags"
+  Option "DontVTSwitch" "true"
+  Option "AllowMouseOpenFail" "true"
+  Option "PciForceNone" "true"
+  Option "AutoEnableDevices" "false"
+  Option "AutoAddDevices" "false"
+EndSection
+
+Section "Module"
+  Load "/usr/lib/xorg/modules/extensions/libglx.so"
+EndSection
+
+Section "Extensions"
+  Option "GLX" "Enable"
+  Option "NV-GLX" "Disable"
+EndSection
+
+
+##Xdummy:##
+Section "InputDevice"
+  Identifier "NoMouse"
+  Option "CorePointer" "true"
+  Driver "void"
+EndSection
+
+Section "InputDevice"
+  Identifier "NoKeyboard"
+  Option "CoreKeyboard" "true"
+  Driver "void"
+EndSection
+
+##Xdummy:##
+Section "Device"
+  Identifier "Videocard0"
+  Driver "dummy"
+  #VideoRam 4096000
+  VideoRam 256000
+EndSection
+
+##Xdummy:##
+Section "Monitor"
+  Identifier "Monitor0"
+  HorizSync   10.0 - 300.0
+  VertRefresh 10.0 - 200.0
+  DisplaySize 4335 1084
+  #The following modeline is invalid (calculator overflowed):
+  #Modeline "32000x32000@0" -38917.43 32000 32032 -115848 -115816 32000 32775 32826 33601
+  Modeline "16384x8192@10" 2101.93 16384 16416 24400 24432 8192 8390 8403 8602
+  Modeline "8192x4096@10" 424.46 8192 8224 9832 9864 4096 4195 4202 4301
+  Modeline "5120x3200@10" 199.75 5120 5152 5904 5936 3200 3277 3283 3361
+  Modeline "3840x2880@10" 133.43 3840 3872 4376 4408 2880 2950 2955 3025
+  Modeline "3840x2560@10" 116.93 3840 3872 4312 4344 2560 2622 2627 2689
+  Modeline "3840x2048@10" 91.45 3840 3872 4216 4248 2048 2097 2101 2151
+  Modeline "2048x2048@10" 49.47 2048 2080 2264 2296 2048 2097 2101 2151
+  Modeline "2560x1600@10" 47.12 2560 2592 2768 2800 1600 1639 1642 1681
+  Modeline "1920x1200@10" 26.28 1920 1952 2048 2080 1200 1229 1231 1261
+  Modeline "1920x1080@10" 23.53 1920 1952 2040 2072 1080 1106 1108 1135
+  Modeline "1680x1050@10" 20.08 1680 1712 1784 1816 1050 1075 1077 1103
+  Modeline "1600x900@20" 33.92 1600 1632 1760 1792 900 921 924 946
+  Modeline "1440x900@20" 30.66 1440 1472 1584 1616 900 921 924 946
+  Modeline "1360x768@20" 24.49 1360 1392 1480 1512 768 786 789 807
+  #common resolutions for android devices (both orientations):
+  Modeline "800x1280@20" 25.89 800 832 928 960 1280 1310 1315 1345
+  Modeline "1280x800@20" 24.15 1280 1312 1400 1432 800 819 822 841
+  Modeline "720x1280@25" 30.22 720 752 864 896 1280 1309 1315 1345
+  Modeline "1280x720@25" 27.41 1280 1312 1416 1448 720 737 740 757
+  Modeline "768x1024@25" 24.93 768 800 888 920 1024 1047 1052 1076
+  Modeline "1024x768@25" 23.77 1024 1056 1144 1176 768 785 789 807
+  Modeline "600x1024@25" 19.90 600 632 704 736 1024 1047 1052 1076
+  Modeline "1024x600@25" 18.26 1024 1056 1120 1152 600 614 617 631
+  Modeline "536x960@25" 16.74 536 568 624 656 960 982 986 1009
+  Modeline "960x536@25" 15.23 960 992 1048 1080 536 548 551 563
+  Modeline "600x800@25" 15.17 600 632 688 720 800 818 822 841
+  Modeline "800x600@25" 14.50 800 832 880 912 600 614 617 631
+  Modeline "480x854@25" 13.34 480 512 560 592 854 873 877 897
+  Modeline "848x480@25" 12.09 848 880 920 952 480 491 493 505
+  Modeline "480x800@25" 12.43 480 512 552 584 800 818 822 841
+  Modeline "800x480@25" 11.46 800 832 872 904 480 491 493 505
+  Modeline "320x480@50" 10.73 320 352 392 424 480 490 494 505
+  Modeline "480x320@50" 9.79 480 512 544 576 320 327 330 337
+  Modeline "240x400@50" 6.96 240 272 296 328 400 408 412 421
+  Modeline "400x240@50" 6.17 400 432 448 480 240 245 247 253
+  Modeline "240x320@50" 5.47 240 272 288 320 320 327 330 337
+  Modeline "320x240@50" 5.10 320 352 368 400 240 245 247 253
+  #resolutions for android devices (both orientations)
+  #minus the status bar
+  #38px status bar (and width rounded up)
+  Modeline "800x1242@20" 25.03 800 832 920 952 1242 1271 1275 1305
+  Modeline "1280x762@20" 22.93 1280 1312 1392 1424 762 780 783 801
+  Modeline "720x1242@25" 29.20 720 752 856 888 1242 1271 1276 1305
+  Modeline "1280x682@25" 25.85 1280 1312 1408 1440 682 698 701 717
+  Modeline "768x986@25" 23.90 768 800 888 920 986 1009 1013 1036
+  Modeline "1024x730@25" 22.50 1024 1056 1136 1168 730 747 750 767
+  Modeline "600x986@25" 19.07 600 632 704 736 986 1009 1013 1036
+  Modeline "1024x562@25" 17.03 1024 1056 1120 1152 562 575 578 591
+  Modeline "536x922@25" 16.01 536 568 624 656 922 943 947 969
+  Modeline "960x498@25" 14.09 960 992 1040 1072 498 509 511 523
+  Modeline "600x762@25" 14.39 600 632 680 712 762 779 783 801
+  Modeline "800x562@25" 13.52 800 832 880 912 562 575 578 591
+  Modeline "480x810@25" 12.59 480 512 552 584 810 828 832 851
+  Modeline "848x442@25" 11.09 848 880 920 952 442 452 454 465
+  Modeline "480x762@25" 11.79 480 512 552 584 762 779 783 801
+  Modeline "800x442@25" 10.51 800 832 864 896 442 452 454 465
+  #32px status bar (no need for rounding):
+  Modeline "320x448@50" 9.93 320 352 384 416 448 457 461 471
+  Modeline "480x288@50" 8.75 480 512 544 576 288 294 297 303
+  #24px status bar:
+  Modeline "240x376@50" 6.49 240 272 296 328 376 384 387 395
+  Modeline "400x216@50" 5.50 400 432 448 480 216 220 222 227
+  Modeline "240x296@50" 5.02 240 272 288 320 296 302 305 311
+  Modeline "320x216@50" 4.55 320 352 368 400 216 220 222 227
+EndSection
+
+##Xdummy:##
+Section "Screen"
+  Identifier "Screen0"
+  Device "Videocard0"
+  Monitor "Monitor0"
+  DefaultDepth 24
+  SubSection "Display"
+    Viewport 0 0
+    Depth 24
+    Modes "32000x32000" "16384x8192" "8192x4096" "5120x3200" "3840x2880" "3840x2560" "3840x2048" "2048x2048" "2560x1600" "1920x1440" "1920x1200" "1920x1080" "1600x1200" "1680x1050" "1600x900" "1400x1050" "1440x900" "1280x1024" "1366x768" "1280x800" "1024x768" "1024x600" "800x600" "320x200"
+    #Virtual 32000 32000
+    #Virtual 16384 8192
+    #Virtual 8192 4096
+    Virtual 1920 1440
+  EndSubSection
+EndSection
+
+Section "ServerLayout"
+  Identifier   "dummy_layout"
+  Screen       "screen0"
+  InputDevice  "NoMouse"
+  InputDevice  "NoKeyboard"
+EndSection
diff --git a/web/community.html b/web/community.html
deleted file mode 100644
index 4e28c90e..00000000
--- a/web/community.html
+++ /dev/null
@@ -1,81 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
-  <meta name="verify-v1" content="oJj9+cXtpch0MSVjYgtyvC+Y57yYC6Cz9zFOd1+FXSw=" />
-  <link rel="stylesheet" href="css/style.css" type="text/css" />
-  <link rel="meta" title="DOAP" type="application/rdf+xml" href="http://www.fxruby.org/doap.rdf" />
-  <title>Community</title>
-</head>
-
-<body>
-<!-- wrap starts here -->
-<div id="wrap">
-		
-		<!--header -->
-		<div id="header">			
-			
-			<h1 id="logo-text"><a href="index.html">FXRuby</a></h1>		
-			<p id="slogan">Graphical User Interface Development for Ruby</p>		
-			
-		</div>
-		
-		<!-- menu -->	
-		<div  id="menu">
-			<ul>
-				<li  ><a href=/ >Home</a></li>
-				<li id='current'><a href=# >Community</a></li>
-				<li ><a href=/downloads.html >Downloads</a></li>
-				<li ><a href=/documentation.html >Documentation</a></li>
-			</ul>
-		</div>					
-			
-		<!-- content-wrap starts here -->
-		<div id="content-wrap">
-				
-			<div id="sidebar">
-			
-				<h3>Get the Book!</h3>
-				<a href="http://www.pragprog.com/titles/fxruby"><img src="images/fxruby-book.jpg" alt="FXRuby: Create Lean and Mean GUIs with Ruby" width="175" height="210" /></a>
-
-				<h3>Links</h3>
-				<ul class="sidemenu">
-					<li><a href="http://rubyforge.org/news/?group_id=300">News</a></li>
-					<li><a href="http://www.fxruby.org/doc/book.html">User's Guide</a></li>
-					<li><a href="http://www.fxruby.org/doc/api">API Docs</a></li>					
-					<li><a href="http://www.fxruby.org/doc/examples.html">Screenshots</a></li>
-					<li><a href="http://rubyforge.org/tracker/?atid=1223&group_id=300&func=browse">Report Bugs</a></li>
-					<li><a href="http://www.gnu.org/copyleft/lesser.html">License</a></li>
-				</ul>
-			
-			</div>
-				
-			<div id="main">
-				
-				<h1>Mailing Lists</h1>
-<h2>Announcements</h2>
-<p>The announcements list is a low-traffic list on which new releases of FXRuby, as well as software based on FXRuby, will be announced. Discussions on various topics however should preferably take place in the users list, to prevent swamping people&#8217;s mailboxes. To subscribe, fill out the <a href="http://rubyforge.org/mailman/listinfo/fxruby-announce" title="Announcements List Subscription Form">web-based subscription form</a>.</p>
-<h2>General Discussion</h2>
-<p>The users list is intended for discussion on various FOX and FXRuby topics between developers and/or users of FXRuby and applications based on it. If you have questions, feel free to post your questions here, as many people are only too happy to answer them. To subscribe, fill out the <a href="http://rubyforge.org/mailman/listinfo/fxruby-users" title="General Discussion List Subscription Form">web-based subscription form</a>.</p>
-
-			</div>
-		
-		<!-- content-wrap ends here -->	
-		</div>
-					
-		<!--footer starts here-->
-		<div id="footer">
-			
-			<p>
-			  &copy; 2008 Lyle Johnson<br />
-			  Web Site Generated Using <a href="http://webby.rubyforge.org/" title="Webby">Webby</a>
-			</p>
-				
-  </div>	
-
-<!-- wrap ends here -->
-</div>
-
-</body>
-</html>
diff --git a/web/css/style.css b/web/css/style.css
deleted file mode 100644
index 36c1a1b1..00000000
--- a/web/css/style.css
+++ /dev/null
@@ -1,407 +0,0 @@
-/********************************************
-   AUTHOR:  			Erwin Aligam 
-   WEBSITE:   			http://www.styleshout.com/
-	TEMPLATE NAME:		Envision
-   TEMPLATE CODE: 	S-0013
-   VERSION:          1.1
-	LAST MODIFIED     Nov-14-2007 	
- *******************************************/
- 
-/********************************************
-   HTML ELEMENTS
-********************************************/ 
-
-/* Top Elements */
-* { margin: 0; padding: 0; outline: 0 }
-
-body {
-	background: #CCC;
-	font: 80%/1.5em Verdana, Tahoma, arial, sans-serif;
-	color: #555; 
-	text-align: center;
-}
-
-/* links */
-a, a:visited {
-	text-decoration: none;
-	color: #2180BC;
-	background: inherit;
-}
-a:hover {
-	color: #88ac0b;
-	background: inherit;
-	text-decoration: underline;
-}
-
-/* headers */
-h1, h2, h3 {
-	font-family: 'Trebuchet MS', Tahoma, Sans-serif;	 		
-}
-h1 {
-	font-size: 150%;	
-	font-weight: normal;
-	color: #006699;
-}
-h2 {
-	font-size: 140%;
-	text-transform: uppercase;
-	color: #88ac0b;
-}
-h3 {
-	font-size: 120%;
-	color: #666666; 
-}
-
-/* images */
-img {
-	background: #FAFAFA;
-   border: 1px solid #E5E5E5;
-	padding: 5px;
-}
-img.float-right {
-  margin: 5px 0px 10px 10px;  
-}
-img.float-left {
-  margin: 5px 10px 10px 0px;
-}
-
-h1, h2, h3, p {
-	padding: 10px;		
-	margin: 0;
-}
-ul, ol {
-	margin: 5px 20px;
-	padding: 0 20px;
-}
-
-code {
-  margin: 5px 0;
-  padding: 10px;
-  text-align: left;
-  display: block;
-  overflow: auto;  
-  font: 500 1em/1.5em 'Lucida Console', 'courier new', monospace ;
-  /* white-space: pre; */
-  background: #FAFAFA;
-  border: 1px solid #f2f2f2;  
-}
-acronym {
-  cursor: help;
-  border-bottom: 1px dotted #777;
-}
-blockquote {
-	margin: 10px;
- 	padding: 0 0 0 28px;  
-   border: 1px solid #f2f2f2; 
-  	background: #FAFAFA url(../images/quote.gif) no-repeat 5px 5px;    
-}
-
-/* start - table */
-table {
-	border-collapse: collapse;
-	margin: 10px;	
-}
-th strong {
-	color: #fff;
-}
-th {
-	background: #93BC0C;
-	height: 29px;
-	padding-left: 12px;
-	padding-right: 12px;
-	color: #FFF;
-	text-align: left;
-	border-left: 1px solid #B6D59A;
-	border-bottom: solid 2px #FFF;
-}
-tr {
-	height: 30px;
-}
-td {
-	padding-left: 11px;
-	padding-right: 11px;
-	border-left: 1px solid #FFF;
-	border-bottom: solid 1px #ffffff;
-}
-td.first,th.first {
-	border-left: 0px;
-}
-tr.row-a {
-	background: #F8F8F8;
-}
-tr.row-b {
-	background: #EFEFEF;
-}
-/* end - table */
-
-/* form elements */
-form {
-	margin:10px; padding: 0 5px;
-	border: 1px solid #f2f2f2; 
-	background-color: #FAFAFA; 	
-}
-label {
-	display:block;
-	font-weight:bold;
-	margin:5px 0;
-}
-input {
-	padding:2px;
-	border:1px solid #eee;
-	font: normal 1em Verdana, sans-serif;
-	color:#777;
-}
-textarea {
-	width:400px;
-	padding:2px;
-	font: normal 1em Verdana, sans-serif;
-	border:1px solid #eee;
-	height:100px;
-	display:block;
-	color:#777;
-}
-input.button { 
-	font: bold 12px Arial, Sans-serif; 
-	height: 24px;
-	margin: 0;
-	padding: 2px 3px; 
-	color: #FFF;
-	background: #8EB50C url(../images/button-bg.jpg) repeat-x 0 0;
-	border: none;
-}
-
-/* search form */
-.searchform {
-	background-color: transparent;
-	border: none;	
-	margin: 0; padding: 5px 0 15px 0;	
-	width: 190px;	
-}
-.searchform p { margin: 0; padding: 0; }
-.searchform input.textbox { 
-	width: 120px;
-	color: #777; 
-	height: 18px;
-	padding: 2px;	
-	border: 1px solid #E5E5E5;
-	vertical-align: top;
-}
-.searchform input.button { 
-	width: 60px;
-	height: 24px;
-	padding: 2px 5px;
-	vertical-align: top;
-}
-
-/********************************************
-   LAYOUT
-********************************************/ 
-#wrap {
-	width: 820px;
-	background: #CCC url(../images/content.jpg) repeat-y center top;
-	margin: 0 auto;
-	text-align: left;
-}
-#content-wrap {
-	clear: both;
-	width: 760px;
-	padding: 0; 
-	margin: 10px auto;
-}
-#header {
-	width: 820px;
-	position: relative;
-	height: 103px;
-	background: #CCC url(../images/header.png) no-repeat center top;
-	padding: 0;	
-	color: #FFF;	
-}
-#header h1#logo-text a {
-	position: absolute;
-	margin: 0; padding: 0;
-	font: bolder 44px 'Trebuchet MS', Arial, Sans-serif;
-	letter-spacing: -2px;
-	color: #FFF;
-	text-transform: none;
-	text-decoration: none;
-	background: transparent;
-	
-	/* change the values of top and left to adjust the position of the logo*/
-	top: 20px; left: 110px;	
-}
-#header p#slogan {
-	position: absolute;
-	margin: 0; padding: 0;
-	font: normal 12px 'Trebuchet MS', Arial, Sans-serif;
-	text-transform: none;
-	color: #FFF;
-	
-	/* change the values of top and left to adjust the position of the slogan*/
-	top: 70px; left: 110px;		
-}
-
-/* header links */
-#header #header-links {
-	position: absolute;
-	top: 20px; right: 30px;	
-	color: #C6DDEE;
-	font-size: 10px;	
-}
-#header #header-links a {	
-	color: #FFF;
-	text-decoration: none;	
-}
-#header #header-links a:hover {
-	color: #D4E59F;	
-}
-
-/* Menu */
-#menu {
-	clear: both;	
-	margin: 0 auto; padding: 0;
-	background: url(../images/menu.jpg) repeat-x 0 0;	
-	font: bold 12px/37px Verdana, Arial, Tahoma, Sans-serif;
-	height: 37px;
-	width: 780px;	
-}
-#menu ul {
-	float: right;
-	list-style: none;
-	margin:0; padding: 0;
-}
-#menu ul li {
-	display: inline;
-}
-#menu ul li a {
-	display: block;
-	float: left;
-	padding: 0 12px;
-	color: #FFF;	
-	text-decoration: none;
-}
-#menu ul li.last a {
-	padding-right: 20px;	
-}
-#menu ul li a:hover {
-	color: #D4E59F;	
-}
-#menu ul li#current a {	
-	color: #D4E59F;
-}
-
-/* Main Column */
-#main {
-	float: left;
-	width: 70%;
-	padding: 0; margin: 5px 0 0 5px;
-	display: inline;
-}
-#main h2 {
-	margin-top: 10px;
-	font: Bold 140% 'Trebuchet MS', Tahoma, Sans-serif;
-	color: #88ac0b; 
-	padding: 5px 0 5px 25px; 	
-	border-bottom: 1px solid #EFF0F1;
-	background: #FFF url(../images/square-green.png) no-repeat 3px 50%;	
-	text-transform: none;
-}
-#main h2 a {
-	background: none;
-	color: #88ac0b;
-	text-decoration: none;
-}
-
-#main ul li {
-	list-style-image: url(../images/bullet.gif);
-}
-
-.post-footer {
-	background-color: #FAFAFA;
-	padding: 5px; margin: 20px 10px 10px 10px;
-	border: 1px solid #f2f2f2;
-	font-size: 95%;	
-}
-.post-footer .date {
-	background: url(../images/clock.gif) no-repeat left center;
-	padding-left: 20px; margin: 0 10px 0 5px;
-}
-.post-footer .comments {
-	background: url(../images/comment.gif) no-repeat left center;
-	padding-left: 20px; margin: 0 10px 0 5px;
-}
-.post-footer .readmore {
-	background: url(../images/page.gif) no-repeat left center;
-	padding-left: 20px; margin: 0 10px 0 5px;
-}
-
-/* Sidebar */	
-#sidebar {
-	float: right;
-	width: 26.5%;
-	padding: 0; margin: 0;	
-	color: #68774A;	
-}
-#sidebar img {
-	text-align: center;
-}	
-#sidebar h3 {
-	margin-top: 10px;
-	/* padding: 5px 5px; */
-	text-align: center;
-	font: bold 1.4em 'Trebuchet MS', Tahoma, Sans-serif;
-	color: #728D26;	
-}
-#sidebar ul.sidemenu {
-	list-style: none;
-	text-align: left;
-	margin: 7px 4px 8px 0; padding: 0;
-	text-decoration: none;		
-	background: url(../images/dots.jpg) repeat-x left top;
-}
-#sidebar ul.sidemenu li {
-	list-style: none;
-	background: url(../images/dots.jpg) repeat-x left bottom;
-	padding: 4px 0 4px 5px;
-	margin: 0 2px;	
-	color: #68774A;	
-}
-* html body #sidebar ul.sidemenu li {
-	height: 1%;
-}
-#sidebar ul.sidemenu li a {
-	text-decoration: none;	
-	background-image: none;	
-	color: #666666;			
-}
-#sidebar ul.sidemenu li a:hover {	
-	color: #1773BC;	
-}
-#sidebar ul.sidemenu ul { margin: 0 0 0 5px; padding: 0; }
-#sidebar ul.sidemenu ul li { background: none; }
-
-
-/* Footer */	
-#footer {
-	color: #C6DDEE;
-	background: #CCC url(../images/footer.jpg) no-repeat center top;
-	clear: both;
-	width: 820px;
-	height: 65px;
-	text-align: center;	
-	font-size: 92%;	
-}
-#footer a { 
-	color: #FFF;
-	text-decoration: none; 
-}
-
-/* alignment classes */
-.float-left  { float: left; }
-.float-right { float: right; }
-.align-left  { text-align: left; }
-.align-right { text-align: right; }
-
-/* display and additional classes */
-.clear { clear: both; }
-
-
diff --git a/web/documentation.html b/web/documentation.html
deleted file mode 100644
index 226a8fb9..00000000
--- a/web/documentation.html
+++ /dev/null
@@ -1,83 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
-  <meta name="verify-v1" content="oJj9+cXtpch0MSVjYgtyvC+Y57yYC6Cz9zFOd1+FXSw=" />
-  <link rel="stylesheet" href="css/style.css" type="text/css" />
-  <link rel="meta" title="DOAP" type="application/rdf+xml" href="http://www.fxruby.org/doap.rdf" />
-  <title>Documentation</title>
-</head>
-
-<body>
-<!-- wrap starts here -->
-<div id="wrap">
-		
-		<!--header -->
-		<div id="header">			
-			
-			<h1 id="logo-text"><a href="index.html">FXRuby</a></h1>		
-			<p id="slogan">Graphical User Interface Development for Ruby</p>		
-			
-		</div>
-		
-		<!-- menu -->	
-		<div  id="menu">
-			<ul>
-				<li  ><a href=/ >Home</a></li>
-				<li ><a href=/community.html >Community</a></li>
-				<li ><a href=/downloads.html >Downloads</a></li>
-				<li id='current'><a href=# >Documentation</a></li>
-			</ul>
-		</div>					
-			
-		<!-- content-wrap starts here -->
-		<div id="content-wrap">
-				
-			<div id="sidebar">
-			
-				<h3>Get the Book!</h3>
-				<a href="http://www.pragprog.com/titles/fxruby"><img src="images/fxruby-book.jpg" alt="FXRuby: Create Lean and Mean GUIs with Ruby" width="175" height="210" /></a>
-
-				<h3>Links</h3>
-				<ul class="sidemenu">
-					<li><a href="http://rubyforge.org/news/?group_id=300">News</a></li>
-					<li><a href="http://www.fxruby.org/doc/book.html">User's Guide</a></li>
-					<li><a href="http://www.fxruby.org/doc/api">API Docs</a></li>					
-					<li><a href="http://www.fxruby.org/doc/examples.html">Screenshots</a></li>
-					<li><a href="http://rubyforge.org/tracker/?atid=1223&group_id=300&func=browse">Report Bugs</a></li>
-					<li><a href="http://www.gnu.org/copyleft/lesser.html">License</a></li>
-				</ul>
-			
-			</div>
-				
-			<div id="main">
-				
-				<h1>Books</h1>
-<p>The book <cite>FXRuby: Create Lean and Mean GUIs with Ruby</cite> (available from the <a href="http://www.pragmaticprogrammer.com/titles/fxruby/">Pragmatic Programmers</a> and other booksellers) is the best print source of documentation for FXRuby. It&#8217;s also available as a PDF.</p>
-<p>Several other books, including <cite>Ruby Developer&#8217;s Guide</cite> and <cite>The Ruby Way</cite>, include chapters or sections on GUI development with FXRuby.</p>
-<h1>Online</h1>
-<p>The <a href="http://www.fxruby.org/doc/book.html">FXRuby User&#8217;s Guide</a> provides detailed installation instructions as well as a handful of tutorial exercises to get you started with FXRuby development.</p>
-<p>If you&#8217;re looking for API reference documentation, all of the classes and methods for FXRuby are documented <a href="http://www.fxruby.org/doc/api/">here</a>.</p>
-<p>Other good sources of documentation include the <a href="http://www.fox-toolkit.org/">FOX home page</a> and the <a href="http://www.fox-toolkit.net/">FOX Community Wiki</a> site.</p>
-
-			</div>
-		
-		<!-- content-wrap ends here -->	
-		</div>
-					
-		<!--footer starts here-->
-		<div id="footer">
-			
-			<p>
-			  &copy; 2008 Lyle Johnson<br />
-			  Web Site Generated Using <a href="http://webby.rubyforge.org/" title="Webby">Webby</a>
-			</p>
-				
-  </div>	
-
-<!-- wrap ends here -->
-</div>
-
-</body>
-</html>
diff --git a/web/downloads.html b/web/downloads.html
deleted file mode 100644
index 04aac14d..00000000
--- a/web/downloads.html
+++ /dev/null
@@ -1,85 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
-  <meta name="verify-v1" content="oJj9+cXtpch0MSVjYgtyvC+Y57yYC6Cz9zFOd1+FXSw=" />
-  <link rel="stylesheet" href="css/style.css" type="text/css" />
-  <link rel="meta" title="DOAP" type="application/rdf+xml" href="http://www.fxruby.org/doap.rdf" />
-  <title>Downloads</title>
-</head>
-
-<body>
-<!-- wrap starts here -->
-<div id="wrap">
-		
-		<!--header -->
-		<div id="header">			
-			
-			<h1 id="logo-text"><a href="index.html">FXRuby</a></h1>		
-			<p id="slogan">Graphical User Interface Development for Ruby</p>		
-			
-		</div>
-		
-		<!-- menu -->	
-		<div  id="menu">
-			<ul>
-				<li  ><a href=/ >Home</a></li>
-				<li ><a href=/community.html >Community</a></li>
-				<li id='current'><a href=# >Downloads</a></li>
-				<li ><a href=/documentation.html >Documentation</a></li>
-			</ul>
-		</div>					
-			
-		<!-- content-wrap starts here -->
-		<div id="content-wrap">
-				
-			<div id="sidebar">
-			
-				<h3>Get the Book!</h3>
-				<a href="http://www.pragprog.com/titles/fxruby"><img src="images/fxruby-book.jpg" alt="FXRuby: Create Lean and Mean GUIs with Ruby" width="175" height="210" /></a>
-
-				<h3>Links</h3>
-				<ul class="sidemenu">
-					<li><a href="http://rubyforge.org/news/?group_id=300">News</a></li>
-					<li><a href="http://www.fxruby.org/doc/book.html">User's Guide</a></li>
-					<li><a href="http://www.fxruby.org/doc/api">API Docs</a></li>					
-					<li><a href="http://www.fxruby.org/doc/examples.html">Screenshots</a></li>
-					<li><a href="http://rubyforge.org/tracker/?atid=1223&group_id=300&func=browse">Report Bugs</a></li>
-					<li><a href="http://www.gnu.org/copyleft/lesser.html">License</a></li>
-				</ul>
-			
-			</div>
-				
-			<div id="main">
-				
-				<p>The latest version of FXRuby is always available from the <a href="http://rubyforge.org/projects/fxruby/">RubyForge project page</a>. The RubyForge releases should always have accompanying release notes describing the changes for that release. A cumulative ChangeLog file is also included in the FXRuby source code distribution. Note that any FXRuby 1.6.x release should be compatible with any FOX 1.6.x release, but won&#8217;t be compatible with earlier (or later) versions of FOX.</p>
-<h1>Source Code</h1>
-<p>The FXRuby source code is distributed as a gzipped tar archive, and is available for download from the <a href="http://rubyforge.org/projects/fxruby/">RubyForge project page</a>.</p>
-<h1>Binaries for Unix/Linux</h1>
-<p>Precompiled binaries for FOX, FXScintilla and FXRuby are available for various Unix/Linux platforms, but not in any centralized way.</p>
-<p>Both the <a href="http://www.fox-toolkit.net/">FOX Community Wiki</a> site and the main <a href="http://www.fox-toolkit.org/">FOX web site</a> list a number of independent sources for package downloads for various Linux distributions, but many of these are for older FOX releases. You may have better luck using a RPM search engine like <a href="http://rpmfind.net/">rpmfind.net</a> to find the most recent packages for your distribution.</p>
-<h1>Binaries for Microsoft Windows</h1>
-<p>Windows installers for FXRuby are available for download from the <a href="http://rubyforge.org/projects/fxruby/">RubyForge project page</a>. The FOX and FXScintilla libraries are built into the Windows installers for FXRuby, and you should not need to download and install those packages separately. These binaries are also compatible with the standard Ruby installer for Windows that are available for download from RubyForge.</p>
-<p>Note that the precompiled binaries for Windows are built with OpenGL support, and thus depend on the OpenGL runtime libraries (opengl32.dll and glu32.dll). These libraries were not included with Windows 95 (earlier than OSR2), so if you&#8217;re using Ruby and FXRuby on a Windows 95 machine, you may need to download the OpenGL runtime libraries. You must have these libraries installed even if you don&#8217;t plan to do anything OpenGL-related with FXRuby.</p>
-
-			</div>
-		
-		<!-- content-wrap ends here -->	
-		</div>
-					
-		<!--footer starts here-->
-		<div id="footer">
-			
-			<p>
-			  &copy; 2008 Lyle Johnson<br />
-			  Web Site Generated Using <a href="http://webby.rubyforge.org/" title="Webby">Webby</a>
-			</p>
-				
-  </div>	
-
-<!-- wrap ends here -->
-</div>
-
-</body>
-</html>
diff --git a/web/images/bullet.gif b/web/images/bullet.gif
deleted file mode 100644
index 0ba2421a..00000000
Binary files a/web/images/bullet.gif and /dev/null differ
diff --git a/web/images/button-bg.jpg b/web/images/button-bg.jpg
deleted file mode 100644
index 1c59ae2f..00000000
Binary files a/web/images/button-bg.jpg and /dev/null differ
diff --git a/web/images/comment.gif b/web/images/comment.gif
deleted file mode 100644
index 951082f9..00000000
Binary files a/web/images/comment.gif and /dev/null differ
diff --git a/web/images/content.jpg b/web/images/content.jpg
deleted file mode 100644
index 23b605f8..00000000
Binary files a/web/images/content.jpg and /dev/null differ
diff --git a/web/images/dots.jpg b/web/images/dots.jpg
deleted file mode 100644
index e7f082d2..00000000
Binary files a/web/images/dots.jpg and /dev/null differ
diff --git a/web/images/footer.jpg b/web/images/footer.jpg
deleted file mode 100644
index 097d99a9..00000000
Binary files a/web/images/footer.jpg and /dev/null differ
diff --git a/web/images/fxruby-book.jpg b/web/images/fxruby-book.jpg
deleted file mode 100644
index f53e2070..00000000
Binary files a/web/images/fxruby-book.jpg and /dev/null differ
diff --git a/web/images/header.png b/web/images/header.png
deleted file mode 100644
index 6f79ed37..00000000
Binary files a/web/images/header.png and /dev/null differ
diff --git a/web/images/menu.jpg b/web/images/menu.jpg
deleted file mode 100644
index daaa8bb3..00000000
Binary files a/web/images/menu.jpg and /dev/null differ
diff --git a/web/images/page.gif b/web/images/page.gif
deleted file mode 100644
index 0c49ba87..00000000
Binary files a/web/images/page.gif and /dev/null differ
diff --git a/web/images/quote.gif b/web/images/quote.gif
deleted file mode 100644
index 43cbdb3f..00000000
Binary files a/web/images/quote.gif and /dev/null differ
diff --git a/web/images/square-green.png b/web/images/square-green.png
deleted file mode 100644
index 82f2dd35..00000000
Binary files a/web/images/square-green.png and /dev/null differ
diff --git a/web/index.html b/web/index.html
deleted file mode 100644
index 7d635183..00000000
--- a/web/index.html
+++ /dev/null
@@ -1,88 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
-  <meta name="verify-v1" content="oJj9+cXtpch0MSVjYgtyvC+Y57yYC6Cz9zFOd1+FXSw=" />
-  <link rel="stylesheet" href="css/style.css" type="text/css" />
-  <link rel="meta" title="DOAP" type="application/rdf+xml" href="http://www.fxruby.org/doap.rdf" />
-  <title>FXRuby</title>
-</head>
-
-<body>
-<!-- wrap starts here -->
-<div id="wrap">
-		
-		<!--header -->
-		<div id="header">			
-			
-			<h1 id="logo-text"><a href="index.html">FXRuby</a></h1>		
-			<p id="slogan">Graphical User Interface Development for Ruby</p>		
-			
-		</div>
-		
-		<!-- menu -->	
-		<div  id="menu">
-			<ul>
-				<li id='current' ><a href=# >Home</a></li>
-				<li ><a href=/community.html >Community</a></li>
-				<li ><a href=/downloads.html >Downloads</a></li>
-				<li ><a href=/documentation.html >Documentation</a></li>
-			</ul>
-		</div>					
-			
-		<!-- content-wrap starts here -->
-		<div id="content-wrap">
-				
-			<div id="sidebar">
-			
-				<h3>Get the Book!</h3>
-				<a href="http://www.pragprog.com/titles/fxruby"><img src="images/fxruby-book.jpg" alt="FXRuby: Create Lean and Mean GUIs with Ruby" width="175" height="210" /></a>
-
-				<h3>Links</h3>
-				<ul class="sidemenu">
-					<li><a href="http://rubyforge.org/news/?group_id=300">News</a></li>
-					<li><a href="http://www.fxruby.org/doc/book.html">User's Guide</a></li>
-					<li><a href="http://www.fxruby.org/doc/api">API Docs</a></li>					
-					<li><a href="http://www.fxruby.org/doc/examples.html">Screenshots</a></li>
-					<li><a href="http://rubyforge.org/tracker/?atid=1223&group_id=300&func=browse">Report Bugs</a></li>
-					<li><a href="http://www.gnu.org/copyleft/lesser.html">License</a></li>
-				</ul>
-			
-			</div>
-				
-			<div id="main">
-				
-				<p>FXRuby is a library for developing powerful and sophisticated cross-platform graphical user interfaces (GUIs) for your Ruby applications. It&#8217;s based on the <a href="http://www.fox-toolkit.org/" title="FOX Home Page">FOX Toolkit</a>, a popular open source C++ library developed by Jeroen van der Zijp. What that means for you as an application developer is that you&#8217;re able to write code in the <a href="http://www.ruby-lang.org/" title="Ruby Home Page">Ruby</a> programming language that you already know and love, while at the same time taking advantage of the performance and functionality of a featureful, highly optimized C++ toolkit.</p>
-<h1>Projects Using FXRuby</h1>
-<p>Projects using FXRuby include:</p>
-<ul>
-	<li><a href="http://www.attiksystem.ch/beerp/beerp-the-fxruby-erp/">BeERP</a> is a commercial ERP built entirely with the FXRuby library.</li>
-	<li><a href="http://www.discretizer.org/">Discretizer</a> is an interactive mesh creation tool. It can be used to create geometry and meshes for three dimensional flow simulations (CFD).</li>
-	<li><a href="http://fox-tool.rubyforge.org/">foxGUIb</a> is an interactive gui builder and codegenerator for FXRuby. This tool makes it easy to quickly build complex and good looking graphical user interfaces for Ruby.</li>
-	<li><a href="http://rubyforge.org/projects/fxri/">FXRI</a> is a FXRuby Interface to RI that supports search-on-typing. FXRI is a small little program that tries to provide the desired information as fast as possible.</li>
-	<li><a href="http://fxtwitter.rubyforge.org/">fxtwitter</a> is a simple Twitter client written in Ruby.</li>
-	<li><a href="http://freeride.rubyforge.org/wiki/wiki.pl">FreeRIDE</a> is an IDE for the Ruby programming language.</li>
-</ul>
-<p>If your project uses FXRuby for its user interface, and you&#8217;d like to see it listed here, please send me an e-mail with the information.</p>
-
-			</div>
-		
-		<!-- content-wrap ends here -->	
-		</div>
-					
-		<!--footer starts here-->
-		<div id="footer">
-			
-			<p>
-			  &copy; 2008 Lyle Johnson<br />
-			  Web Site Generated Using <a href="http://webby.rubyforge.org/" title="Webby">Webby</a>
-			</p>
-				
-  </div>	
-
-<!-- wrap ends here -->
-</div>
-
-</body>
-</html>